 |
CS 374 - Compilers
Course Information |
Course Overview
A compiler translates a program from a higher level language to a lower level
language which is executable. In this course, the basic theory and
application of compilation is taught through a semester-long project: a compiler
of a subset of the Java programming language to the MIPS assembly language.
The project will be implemented using the Java language. The structure of
the program is linear, following the presentation of key topics: lexical
analysis, parsing, abstract syntax, semantic analysis, activation records, and
code generation. The student will gain not only
an understanding of how to construct a compiler, but also the fundamental skills
for interpreter writing as well. Further, compiler writing presents one of
computer science's most beautiful bridges between fundamental theory and useful
practice.
Learning Objectives
- To gain a deep, experiential understanding of the construction of
compilers and interpreters through a semester-long compiler implementation
project.
- To understand and implement the fundamental stages of a compiler:
lexical analysis (scanning), syntactic analysis (parsing), semantic analysis
(type checking), and code generation.
- To gain deeper insight to the inner workings of modern object-oriented
languages by implementing a subset of Java that includes inheritance and
polymorphism.
- To further the broader learning objectives of the Computer Science
major.
Text
Instructor
Todd Neller
Lecture: TTh 10:00-11:15AM, Glatfelter 112
Office: Glatfelter 209
Office Hours: TTh 11:30AM-1PM or by appointment. On Thursdays when
there is a Computer Science colloquium, office hours will be held 2:30-4PM.
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. We may have some
unannounced quizzes to maintain accountability.
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.
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.
