Class: Tuesdays and Thursdays, 3:30-4:45pm, WWH 102
Instructor: Robert Grimm, email@example.com
Office hours: Wednesdays, 5:30-6:30pm, 715 Broadway, room 711
TA: Joel Alwen, jalwen at cs dot nyu dot edu
Office hours: Tuesdays, 5:00-6:00pm, WWH 605
[ Overview | Languages | Syllabus | Tools and Resources ]
Object-oriented programming is a form of "computer programming that emphasizes the structure of data and their encapsulation with the procedures that operate upon it" (Britannica Concise Encyclopedia). Basically, "an object is a software bundle of related variables and methods. Software objects are often used to model real-world objects you find in everyday life" (Sun's Java Tutorial). Object-oriented programming is attractive because it "promote[s] greater flexibility and maintainability in programming, and is widely popular in large-scale software engineering" (Wikipedia).
Goal. To learn how to build and evolve large-scale programs using object-oriented programming.
Topics. In exploring object-oriented programming, we investigate three questions:
Design and primitives matter because they represent the essence of object-oriented programming. Implementation matters because it enables us to debug object-oriented programs and tune their performance.
Project. The focus of our exploration of object-oriented programming is a translator from Java to C++. You design, implement, and evaluate your own translator as a term-long project, working in teams of four to five students. In fact, you build two versions of your translator, taking half a term for each version and presenting your work in class on completion of each version. To make the project manageable, your translator only translates a restricted subset of Java into an even more restricted subset of C++; though the second version covers more functionality than the first version. I also provide you with "helper" code, notably for parsing and pretty printing program source files.
Each group elects a speaker, who coordinates with the members of the group and with me. A new speaker is elected at the middle of the term. In addition to the two in-class presentations, each group provides a weekly progress report, which explores three questions:
Your project presentations explore a different set of questions:
You have a 20 minute slot for your presentation, which includes a demo of your translator as well as 5 minutes for questions and discussion.
You build a large-scale program because that is the domain with the biggest promised impact of object-oriented programming. You build a translator from Java to C++ for two reasons. First, how to translate and transform programs is a real problem and a topic of active research, including my own and that of several other researchers. Second, the translator lets us explore both Java and C++, but without a big break at the middle of the term as we switch from one language to another. You build two versions of the translator so that you can explore object-oriented programming with a real program, learn what worked and what didn't work, and then improve on your first experiences. I expect you to clearly improve the second version; though I also expect you to reuse code from the first version. Finally, you work in teams of students for two reasons. First, it provides you with an opportunity for close interaction with your peers in the face of a shared challenge. Second, team work is the favored approach for building large-scale programs both in academia and industry.
Class. Class is organized as part lecture and part guided discussion. I provide a gentle introduction to individual topics and techniques, usually illustrating them with the Java-to-C++ translator. Together, we explore alternatives and the reasoning behind the techniques. Class also provides a good forum for asking questions and starting the conversation of how to meet the challenges posed by your projects.
Contract. I provide the overall structure of the course, introducing topics and techniques, sharing my experiences, and facilitating our conversation. You actively participate in all aspects of the course, sharing your ideas, questions, and concerns as well as realizing a significant project. Together, we explore how to leverage object-oriented programming to build large-scale programs.
Textbooks. We rely on two textbooks:
Additionally, The C++ Programming Language, 3rd or special edition, by Bjarne Stroustrup, can serve as a useful reference; it is, however, not required.
Mailing list. Please subscribe to the class mailing list v22_0470_001_fa06. Be sure to email your class-related questions to this list and not just the instructor (unless, of course, they concern private rather than technical or organizational issues). Note that messages sent to this list from email accounts that are not subscribed to it will be silently discarded.
In more detail, the source language is
Java without nested classes, anonymous classes, interfaces,
enums, annotations, generics, the enhanced for loop, varargs, and
automatic boxing and unboxing. Furthermore, the source language omits
support for synchronization, i.e., synchronized methods and
statements, and strict arithmetic operations,
strictfp modifier. It also omits support
volatile fields as well
native methods. Finally, you may omit method
overloading but not method overriding for the first version of the
The target language is C++ without virtual methods, inheritance, and, in general, templates. When compared to C, the target language does include support for basic classes, exceptions, and name spaces. For the first version of the translator, you can ignore memory management and assume an infinite main memory. For the second version of the translator, you need to automatically reclaim unused memory through a so-called smart pointer. The smart pointer library, as well as any library support for implementing Java arrays, may use templates.
Most Java statements and expressions translate directly into the corresponding C++ statements and expressions (modulo minor language differences). As a result, the main challenges for the course project are figuring out (1) how to translate Java class hierarchies into C++ without inheritance and (2) how to implement Java's virtual method dispatch in C++ without virtual method dispatch, (3) how to select the right overloaded method, and (4) how to automatically manage memory without an existing garbage collector. Note that we will explore how to approach each challenge in class; we will also leave the latter two challenges for the second version of the translator.
Besides the programming language itself, any version of Java
includes a rather extensive set of platform
libraries, with the facilities in the
package being tightly integrated with Java's execution model. For our
translator, we only support
toString() methods in
and the printing of numbers and strings
java.lang.System. Furthermore, we do not support the
dynamic loading of Java classes, but rather translate all Java classes
of the source program into one C++ program.
Please note that the translator need not perform any correctness checks on source programs; in other words, you can assume that source programs are free of compile-time errors.
For Java, we use the Java 2 Platform Standard Edition 5.0, née JDK 1.5. Sun provides implementations for Windows, Linux, and Solaris. Apple provides implementations for Power PC and Intel based Macs (Mac OS X 10.4). Note that the API documentation for JDK 1.5 typically needs to be downloaded and installed separately (in the case of OS X 10.4, from the Apple Developer Connection).
For C++, we use gcc, the GNU Compiler Collection, as our compiler. It is the default compiler for both Linux and Mac OS X. For Windows, you need Cygwin to provide Unix emulation.
Like many large-scale software projects, we use CVS to provide version control for our program sources and Make to automate the build management.
To simplify the task of reading source files in one language, translating them into another language, and then printing source files for that language, we use the xtc toolkit for source-to-source translators, version 1.9. xtc includes a parser for Java source files, which converts the external, textual representation into an internal tree representation. It also includes support for traversing, modifying, and pretty-printing such trees.
You may also find the following resources useful: