||CS 341 - Survey of Programming Languages
This course surveys three programming languages/paradigms: the functional
language Scheme, and multi-paradigm, dynamically-typed Python and event-driven
Android Java-based programming. More than a
survey course, however, this course covers fundamental design decisions
at the core of every programming language. The larger first part of the
course will explore such issues in the context of the programming language
Scheme. We will learn the techniques necessary to implement a simple
Scheme interpreter in Java. The second part of the course will allow students
to master of the basics of two popular and practical languages
(Python and Android) while gaining an understanding of these languages in the general context
of programming language design. This course is analogous to linguistics
course teaching the basics of three languages, where the first language
is chosen to challenge the student's assumptions about languages, and the
others are chosen to provide a foundation for future practice and reinforce
general understanding about languages. As a fourth hour project students
will design, specify, and build an interpreter for their own general purpose
- Design, code, test, and debug programs in a few representative language
of different programming paradigms.
- Learn how to design a programming language by creating a functional language
interpreter and an interpreter for a student-designed language.
- Formalize the notion of typing, differentiating between static and
dynamic typing, and evaluating languages with regard to typing.
- Explain the different major programming paradigms, and design, code, test, and debug simple event-driven programs
that respond to user events.
This course fulfills the Gettysburg College
Qualitative, Inductive, and Deductive Reasoning (QIDR) curricular requirement.
There is no course text. Necessary materials will be supplied or found
Lecture: Tu, Th, 10:00-11:15AM, Glatfelter 112
Office: Glatfelter 209
Office Hours: M/W 1:00-3:00PM, Tu/Th 2:30-4:00PM. Please drop by or make an appointment.
Note: Generally, feel free to drop in if my office door is open (i.e., most of
the time beyond class).
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. Code must be a legal program in the relevant
language in order to be graded. (It need not be free from logic errors.)
For compiled languages, this means that the program must compile without error.
For interpreted languages, this means it must be interpretable without error. Source code
with compilation/syntax errors 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.
Woody Allen is quoted as saying
"80% of success is
just showing up." While our class attendance/participation grade
is not 80% of the final grade, it is critical that late arrivals and unexcused
absences are not excessive. Missing more than half of class unexcused is
considered being absent. An unexcused late arrival is counted as a half
absence. If the total number of absences counted this way exceeds
20% of class meetings, i.e. 6 absences or more, the student will have failed the
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.