||CS 107 - Introduction to
On the surface it appears that Computer Science is a very dynamic discipline.
However, there are certain principles that are basic to Computer Science.
These are the fundamentals that enable us to solve problems within the context
of a hardware environment. For that reason this course has a heavy emphasis
on the methodology of problem solving with the use of computing equipment,
algorithms, and the implementation of those algorithms in a specific programming
language. This course will be taught using the MATLAB scientific computing
Exercises drawn from Mathematics and the Natural Sciences will introduce the student to basic computing concepts, data types,
classes and methods, decisions, iteration, testing and debugging, arrays and vectors, and other selected topics.
The goal of these exercises is to illustrate good programming principles,
an understanding of programming and elementary
data structures, as well as some basic software engineering principles. Students
will have weekly homework exercises throughout the term that will provide
a solid foundation of experience for future problem-solving.
- Learn the syntax and semantics of a high-level programming language,
including basic computation, simple input/output, standard conditional and
iterative structures, and functions (a.k.a. methods).
- Gain the ability to design, implement, test, debug, analyze, and explain
the behavior of simple high-level computer programs.
- Develop a basic discipline of "computational thinking", whereby a
problem is approached by representing relevant information with simple data
structures, making using of appropriate control structures, methods, and
object-oriented abstraction, and applying relevant problem solving patterns
to compute a solution.
Section A - M,W,F 1:10-2:00PM, Glatfelter 112:
Office: Glatfelter 209
Office Hours: Mo-Fr 2-4PM or by appointment. (I finish teach at 2PM on MWF, so
office hours will start when I arrive back at my office.) Note: Generally,
feel free to drop in if my office door is open (i.e., most of the time
In-class Assistant: Jiangfeng "Jane" Wang (wangji01); office hours: West
110, Tuesdays 7-9PM
Grader: Dan Rustico (rustda01); office hours: West 110, Mondays 7-9PM
10% Fourth Hour Exercises
5% Colloquium Attendance
5% Class Attendance / Participation
You are responsible to know the material from each lecture and reading
assignment before the start of the next class. Homework is due at
the beginning of lecture on the due date. Late homework will not
necessarily be accepted. Source code that does not compile may
not receive partial credit. You are required to attend 3 colloquia or
approved departmental events over the course of the semester. Class attendance and participation is
required. If you attend all classes and are willing to participate,
you'll get 100% for this part of your grade. Even if you know enough
to give a particular lecture, please consider the value of helping your peers
during in-class exercises.
Honesty, Integrity, Honor. These are more important than anything
we will teach in this class. Students can and are encouraged to help
each other understand course concepts, but all graded work must be done
independently unless otherwise specified (e.g. group work). Submitted work
should be created by those submitting it. Submission
of plagiarized code or design work is a violation of the Honor Code, which I
strictly enforce. For
detailed information about the Honor Code, see
What is permitted:
- Discussing algorithms, syntax, and problem specifications with other
- Seeking assistance (as needed) from CS professors, students assistants,
and approved tutors
- Use of "starter code" supplied by your professor, or code you have
What is not permitted:
- Sharing code: Verbal dictation of code, transference of code (e.g.
e-mail, file transfer, entry of printed output, etc.). An important
component of this experiential learning process is developing the ability to
independently devise algorithms and express them in program code.
- Viewing and/or using unauthorized code (e.g. solutions found online,
downloads from code repositories, etc.)
- Submitting work that implicitly takes credit for work that should be
credited to others
- Efforts to obscure the source of unauthorized work
- Outsourcing work
Put simply, students may discuss assignments at an abstract level (e.g.
specifications, algorithm pseudocode), but must actually implement solutions
independently or in permitted groups. Credit should be given where credit
is due. Let your conscience be your guide. Do not merely focus on
the result; learn from the process.