 |
CS 341 - Survey of Programming Languages
Course Information |
Course Overview
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 Scheme itself. 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.Learning Objectives
- Design, code, test, and debug programs, including a functional language
interpreter, using the functional paradigm.
- Formalize the notion of typing, differentiating between static and
dynamic typing, and evaluating languages with regard to typing.
- Explain the difference between event-driven programming and command-line
programming, and design, code, test, and debug simple event-drive programs
that respond to user events.
Text
Instructor
Todd Neller
Lecture: Tu, Th, 10:00-11:15AM, Glatfelter 112
Office: Glatfelter 209
Office Hours: Tu,Th 11:30AM-1PM or by appointment. On days where this
conflicts with CS Colloquiua, office hours will be held 1-2PM.
Note:
Generally, feel free to drop in if my office door is open. If it
is closed, I'm desperately seeking to keep on top of things and rabid attack
ferrets may drop from the ceiling in my defense.
Phone: 337-6643
E-mail: 
Grading
80% Assignments
10% Quizzes / Exams
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 2 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.
Honor Code
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
http://www.gettysburg.edu/about/offices/provost/advising/honor_code/index.dot.
What is permitted:
- Discussing algorithms, syntax, and problem specifications with other
students
- Seeking assistance (as needed) from CS professors, students assistants,
and approved tutors
- Use of "starter code" supplied by your professor, or code you have
previously developed
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.
