CS E61 342S: Object-Oriented Software Development Laboratory

David L. Levine   Christopher D. Gill
levine@cs.wustl.edu   cdgill@cs.wustl.edu
Bryan 502C
Office hours: Tuesday/Thursday, 11:30 am - 12:30 pm
or by appointment
Department of Computer Science
School of Engineering and Applied Science
Washington University in St. Louis

Spring 2000

This page is available through: http://classes.cec.wustl.edu/~cs342/
Or, directly at: http://www.cs.wustl.edu/~levine/courses/cs342/

Final exam: Eliot 102, Tuesday 9 May, 1530 (3:30 pm) - 1730 (5:30 pm)


  1. Course Description
  2. Prerequisites
  3. Assistants
  4. Newsgroup  (Click here to go directly to the newsgroup.)
  5. Discussions/Lectures
  6. Labs
  7. Coding Standards
  8. Textbooks and Other Resources
  9. Grading
  10. Cheating
  11. Times and Locations
  12. Glossary

Course Description

Intensive focus on practical aspects of designing, implementing, and debugging object-oriented software. Topics covered include reusing design patterns and software architectures and developing, documenting, and testing representative applications using object-oriented frameworks and C++. Design and implementation based on design patterns and frameworks are the central themes to enable the construction of reusable, extensible, efficient, and maintainable software.



Please see the CS Graders page for more information, including office hours and location.


Please submit questions, and concerns of public nature, to the class newsgroup. Feel free to answer other people's questions on the newsgroup!

Please note that the newsgroup is a vital part of your CS342 experience. If you have trouble accessing it, please let us know right away!


The discussions/lectures will emphasize three broad topics: object-oriented programming with C++, successful use of patterns and frameworks, and familiarity with useful programming tools and techniques. In general, these may be considered three separate tracks within the course. The examples and labs tie them together.

Reading assignments are shown in brackets for each topic. The C++ reference and GoF are listed in the Textbooks section, below.

OO Programming with C++
Patterns and Frameworks
Tools and Techniques
18 - 20
Course Introduction (gzip-ps) (pdf)
C++ overview (gzip-ps) (pdf)
[C++ Reference, Ch. 1-4, 6-7, and 11]
Java vs. C++ summaries
Software design principles and concepts (slides 1-19)
(gzip-ps) (pdf)
Introduction to Tools and Techniques (gzip-ps) (pdf)
Problem Solving and Reporting (gzip-ps) (pdf)
25 - 27 Software design principles and concepts (slides 20-42)
(gzip-ps) (pdf)
Software design principles and concepts (slides 43-55)
(gzip-ps) (pdf)
1 - 3
A Tour of C++ (selected slides) (gzip-ps) (pdf)
[C++ Reference, Ch. 1-9 and 11]
[C++ Reference, Ch. 12-13]
Unix High-Level Overview (gzip-ps) (pdf)
8 - 10 Introduction to patterns (slides 1-23) (gzip-ps) (pdf)
[GoF, Ch. 1]
Introduction to patterns (slides 24-33) (gzip-ps) (pdf)
[GoF, Ch. 1]
15 - 17 C++ Objects (gzip-ps) (pdf)
[C++ Reference, Ch. 12-13]
Introduction to patterns (slides 34-end) (gzip-ps) (pdf)
[GoF, Ch. 1]
Debuggers (gzip-ps) (pdf)
Debugging Under Unix: gdb
22 - 24 Pattern Case Studies (slides 49-66) (Strategy, Facade, Adapter, Singleton) (gzip-ps) (pdf)
[GoF, Ch. 2-5, Appendix B]
Pattern Case Studies (slides 67-95) (Factory Method, Iterator) (gzip-ps) (pdf)
[GoF, Ch. 2-5, Appendix B]
29 -
2 March
Pattern Case Studies (slides 96-121) (Bridge, Factory) (gzip-ps) (pdf)
[GoF, Ch. 2-5, Appendix B]
Abstract data types in C++ (slides 1-28) (gzip-ps) (pdf)
[C++ Reference, Ch. 14-15 and 17]
Build control (make) (gzip-ps) (pdf)
7 - 9
No class: Spring Break
14 - 16 Abstract data types in C++ (slides 29-45) (gzip-ps) (pdf)
[C++ Reference, Ch. 14-15 and 17]
Lab 6, Observable Sort (gzip-ps) (pdf)
Source code control (RCS (gzip-ps) (pdf)/CVS (gzip-ps) (pdf))
21 - 23 Abstract data types in C++ (slides 45-98) (gzip-ps) (pdf)
[C++ Reference, Ch. 14-15 and 17]
C++ Inheritance (slides 1-59) (gzip-ps) (pdf)
[C++ Reference, Ch. 16-17]
Static Diagnostic Tools (nm, size, strings, etc.) (gzip-ps) (pdf)
28 - 30 C++ Inheritance (slides 60-76) (gzip-ps) (pdf)
[C++ Reference, Ch. 16-17]
Pattern Case Studies (Bridge, Factory) (gzip-ps) (pdf)
[GoF, Ch. 2-5, Appendix B]
Memento (gzip-ps) (pdf)
Dynamic diagnostic tools (ps, top) (gzip-ps) (pdf)
4 - 6
C++ Performance Issues (gzip-ps) (pdf)

I/O with C++ (gzip-ps) (pdf)
[C++ Reference, Ch. 20 and 32]
Command, Decorator, Composite (gzip-ps) (pdf)
[GoF, Ch. 4]
Scripting: sh (gzip-ps) (pdf)
11 - 13 STL (gzip-ps) (pdf)
[GoF, Ch. 5]
18 - 20 The C++ Preprocessor (gzip-ps) (pdf)
[C++ Reference, Ch. 10]
The ACE Framework: C++ wrappers and Patterns (slides 1-21) (gzip-ps) (pdf) Scripting: Perl (gzip-ps) (pdf)
25 - 27 The ACE Framework: C++ wrappers and Patterns (slides 22-55) (gzip-ps) (pdf) Review for Final Exam (gzip-ps) (pdf)  
9 May
Final Exam: Eliot 102, Tuesday 9 May, 1530 (3:30 pm) - 1730 (5:30 pm)


There will be 8 lab projects. Labs are turned in via email. Each lab assigment contains the procedure for turning in the lab. Labs will be due approximately every two weeks; the exact due date is contained in each lab description.

Each lab requires a short ``lab report''. The report does not have to have great detail. Actually, the shorter the report, the better, as long as it is complete. The actual report will be submitted via email, as well, so it must go into a file. The email turn-in process (via make) also submits your code for grading. Use of this process is required.

The lab report must contain:

  1. Introduction: state the problem and what you expect to find. State how you planned to reach your solution.
  2. Evaluation criteria: state how you will evaluate your solution (this must be done before you implement your solution).
  3. Test results: a brief summary of how your program meets the evaluation criteria.
  4. Conclusions: what did you learn from this lab.
Each student must turn in their own lab report for each project. Even if you don't complete your solution, please prepare your lab report in a timely matter. Late lab reports will not be accepted; wrap it up as best you can and move on.

You may discuss your projects with other students only in the lab, during lab hours. Each student must design and implement their own solution, and prepare their own report.

Coding Standards

Many organizations impose coding standards on programmers. These standards can be very strict. In this class, the most important standard is to be consistent. As the course progresses, we'll suggest (at least :-) specific coding guidelines that must or should be followed.

If you'd like to look at some coding standards, the guidelines that the ACE developers use is a good place to start. It's concise and very relevant to C++ coding activities outside of ACE. Please feel free to submit suggestions for improvement to the ACE developers.

Textbooks and Other Resources

Required texts:

We'll use the required textbooks as references. The lecture schedule contains references to revelant portions of the required texts. Please read them before the class meeting.

Recommended texts:

Other information sources:


The current grade chart shows the grades of everyone in the class, without names of course. Knowing a few of your grades should allow you to find yourself in the chart. As a rough guideline, 90-100 can be considered to be an A, 80-89 a B, and so on.

There will be a short, written quiz the end of each Wednesday's discussion/lecture. The quiz will focus on the material covered the preceding Wednesday (of the previous week) and Monday in class, but may draw upon material covered in previous weeks. The lowest quiz score for the semester will be dropped.

See the Labs section for a discussion of the labs and how they will be graded.

The final exam will be comprehensive, and roughly proportioned to cover each of the three tracks in the course. The best way to study for the final is to keep up with the work during the semester.

The final grading component is an evaluation of your participation in the class, and an evaluation of the application of the tools and techniques discussed in class and labs. This component is separated out to:

  1. broaden the evaluation criteria,
  2. reduce the weight of the final exam a bit, in case you have a bad day, and
  3. encourage active participation in discussions/lectures, labs, and on the newsgroup.

Labs 40 percent
   Lab 1:  2 percent
   Labs 2 through 7:  5 percent each
   Lab 8:  8 percent
Quizzes 35 percent
Final exam 20 percent
Participation; application of tools and techniques   5 percent


Please see the WU Association of Graduate Engineering Students (AGES) statement of Academic Integrity. In addition, we fully support Professor Kwasny's statement on cheating:

Cheating is the willful misrepresentation of someone else's work as your own, and will not be tolerated in this course. Specific examples include, but are not limited to, submitting work identical to someone else's, submitting part or all of a programming assignment identical to someone else's, or using unapproved sources of information, e.g., notes, textbook, your neighbor's exam, etc., during a quiz or exam. This is a serious matter. Anyone found cheating will receive an F for the course. Further action may be taken in extreme cases.

Furthermore, our policy is that we will make the final determination on what constitutes cheating. If you suspect that you may be entering an ambiguous situation, it is your responsibility to clarify it before either the TAs or we detect it. If in doubt, please ask.

Times and Locations

Discussions/Lectures: Eliot 102, Tuesday and Thursday, 10:00 am to 11:30 am.

Lab: Lopata 400 (CEC SparcStation Lab)


Here's a glossary of terms that we use in this course. Contributions and corrections are welcome.