CS E71 342S: Object-Oriented Software Development Laboratory

Douglas C. Schmidt   David L. Levine
schmidt@cs.wustl.edu   levine@cs.wustl.edu
Bryan 502   Bryan 502C
935-4215   935-7538
Office hours: by appointment   Office hours: Tuesday, 12:00 pm - 2:00 pm
Department of Computer Science
School of Engineering and Applied Science
Washington University in St. Louis

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


Final exam: Monday 13 December, 1800-2000 McDonnell 361
(Click here for review slides.)


  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.


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
25 August
Course Introduction, C++ overview
[C++ Reference, Ch. 1-4, 6-7, and 11]
30 Aug - 1
A Tour of C++
[C++ Reference, Ch. 1-9 and 11]
(slides 1-24)
A Tour of C++
[C++ Reference, Ch. 1-9 and 11]
(slides 25-34)
(no class Monday)
A Tour of C++
[C++ Reference, Ch. 1-9 and 11]
(slides 35-37)
Introduction to Tools and Techniques
Unix High-Level Overview
13 - 15 C++ Objects
[C++ Reference, Ch. 12-13](slides 1-16)
C++ Objects
[C++ Reference, Ch. 12-13](slides 17-27)
20 - 22 A Tour of C++, (cont'd)
[C++ Reference, Ch. 1-9 and 11]
(slides 39-70)
A Tour of C++, (cont'd)
[C++ Reference, Ch. 1-9 and 11]
(slides 71-89,94)
27 - 29
Introduction to Patterns
[GoF, Ch. 1](slides 1-15)
Introduction to Patterns
[GoF, Ch. 1]
(slides 16-23)
4 - 6
Introduction to Patterns
[GoF, Ch. 1]
(slides 24-48)
Abstract data types in C++
[C++ Reference, Ch. 14-15 and 17]
(slizes 1-26)
11 - 13 Abstract data types in C++
[C++ Reference, Ch. 14-15 and 17]
(slides 27-61)
Abstract data types in C++
[C++ Reference, Ch. 14-15 and 17]
(slides 62-73)
18 - 20 Abstract data types in C++
[C++ Reference, Ch. 14-15 and 17]
(slides 74-105)
Pattern Case Studies
[GoF, Ch. 2-5, Appendix B]
(slides 1-12)
Problem Solving and Reporting
25 - 27 Pattern Case Studies
[GoF, Ch. 2-5, Appendix B]
(slides 13-38: Factory, Bridge, Adapter)
Pattern Case Studies
[GoF, Ch. 2-5, Appendix B]
(slides 39-50)
Build control (make)
CS 241 Using Simple Makefiles
01 - 03
I/O with C++
[C++ Reference, Ch. 20 and 32]
(slides 1-20)
Pattern Case Studies (cont'd)
[GoF, Ch. 2-5, Appendix B]
(slides 51-71)
Source code control (RCS)
Source code control (CVS)
08 - 10 Pattern Case Studies (cont'd)
[GoF, Ch. 2-5, Appendix B]
(slides 72-123: Strategy, Facade, Singleton)
Pattern Case Studies (cont'd)
[GoF, Ch. 2-5, Appendix B]
(slides 124-134: Factory Method)
Static Diagnostic Tools (nm, size, strings, etc.)
15 - 17 Pattern Case Studies (cont'd)
[GoF, Ch. 2-5, Appendix B]
(slides 135-151)
C++ Inheritance
[C++ Reference, Ch. 16-17]
Dynamic diagnostic tools (ps, top)
(no class Wednesday)
C++ Inheritance
[C++ Reference, Ch. 16-17]
29 - 01
More patterns: Observer, Memento, Command, Template Method, Composite
[GoF, Ch. 5]
Dynamic Binding and RTTI The C++ Preprocessor
[C++ Reference, Ch. 10]
06 - 08 Software design principles and concepts The ACE Framework: C++ wrappers and Patterns Scripting: sh
Scripting: Perl
13 - 20
Final Exam: Monday 13 December 6 pm -- 8 pm, McDonnell 361
Review slides


There will be 7 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 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 35 percent
Quizzes 35 percent
Final exam 20 percent
Participation; application of tools and techniques 10 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: McDonnell 361, Monday and Wednesday, 5:30 pm to 7:00 pm.

Lab: Lopata 400 (CEC SparcStation Lab)


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