Stanford University
Computer Science 349: Winter 2006 - 2007

Advanced Object-Oriented Programming

Overview | Details | Materials | Assignments | Exams | Project | Policies

Announcements

• Final exam now available here.
• Class on Wednesday 3/7/07 will be from 1:45pm to 3:00pm.
• Due dates for final project and final exam posted.
• Class on Wednesday 2/7/07 will be from 1:45pm to 3:00pm.
• Source code for Assignment 1 now available here.
• Course Reader for CS249 now listed in optional readings (you may find it a useful reference)
• Class meets MW from 1:15 pm to 2:30 pm in Gates 260.

Overview

This course examines the grand challenge of producing "perfect software systems" or more modestly stated, how to produce really, really, good software. The next stage of evolution of software engineering is producing large-scale systems that handle often life-critical systems. How do we produce really high-quality software at a reasonable cost, software that does what it is supposed to do at a reasonable cost.

The objectives of the course are to:

• identify the key issues involved in developing large-scale software systems;
• explore the areas of software engineering, attempting to identify best practice; and
• provide a framework for understanding the challenges of large-scale software and trade-offs in evaluating approaches to determine best practice

Students are expected carry out a project that explores some aspect of the course. One possibility is developing a software system that explores some aspect of the structuring and practice discussed in the course. Another would be to study literature and software regarding some issue. The project will include a report. There will also be an midterm and a final exam. Students are also expected to attend and participate in class.

The following is the basic syllabus:

1. Introduction to Part II: Process, People and Practice
2. Audit: Integrating Invariant Checks with Production Software
3. Collection Implementation: How to Achieve Predictable Performance
4. Generic Programming and Templates
5. The Software Development Process
6. Design of Value Types
7. Named Descriptions: Implementing Large Value Types
8. Memory Management: Controlling Placement, Locality and Consumption
9. Concurrency with Modular Object-oriented Programming
10. Inheritance: When and Why Multiple Inheritance
11. Naming, Directories and the Manager Pattern

Details

Lectures:

Monday and Wednesday 1:15 pm to 2:30 pm Gates 260

Instructor:

Evan Greenberg <first name dot last name at cs.stanford.edu>
Gates 440
(650) 723-9437
Office hours: Monday and Wednesday 3:00-4:00 PM or by arrangement through email, Gates 440

Teaching assistants:

none

Knowledge of CS 249 is recommended.

Units:

3 units

Course email list:

I was not planning to use one.

Grading:

45% project, 20% midterm exam, 20% final exam, 15% attendance & participation

Materials

Required reading

The course reader will be provided in PDF online in advance of the lectures. These are chapters that continue on from the CS 249 chapters.

Chapter 10 - Introduction to CS349 pdf and postscript

Chapter 11 - Auditing pdf and postscript

Chapter 12 - Collection and Iterator Implementationpdf and postscript

Chapter 13 - Genericity, Templates and Generic Programming pdf and postscript

Chapter 14 - Process pdf and postscript

Chapter 15 - Value-Oriented Programming pdf and postscript

Chapter 16 - Type Structure of Programs pdf and postscript

Chapter 17 - Named Descriptions pdf and postscript

Chapter 18 - Concurrency pdf and postscript

Cheriton 19 - Memory Management pdf and postscript

Optional readings

• N. Leveson, High-pressure Steam Engines and Software Engineering
• Software Bug Contributed to Blackout
• Course Reader for CS249
  • Chapter 1 - Software Husbandry and Software Development (pdf and ps)
  • Chapter 2 - Attribute-based Interface Design (pdf and ps)
  • Chapter 3 - Objects: Entities, Values and Descriptions (pdf and ps)
  • Chapter 4 - Object-Oriented Programming and Object Model (pdf and ps)
  • Chapter 5 - Events, Notifications and Callbacks (pdf and ps)
  • Chapter 6 - Exceptions and Exception Handling (pdf and ps)
  • Chapter 7-8 - Pointers and Garbage Collection (pdf and ps)
  • Chapter 9 - Inter-Object Relationships: Components to Collisions (pdf and ps)
  • Appendix A - Introduction to C++ (pdf and ps)
  • Appendix B - C++ Programming Style (pdf and ps)

  Interesting articles

  • They Write the Right Stuff: a look at how software is designed at NASA

  
  Project

  The project should undertake a serious study of some area of software engineering, either a literature study, a study of some non-trivial software or the development of some software to explore some aspect.

  Please contact the instructor to discuss project ideas.

  A Few Project Ideas

  Audit Implementation/Evaluation

  Take an existing non-trivial software system or program and add an integrated audit capability to it, evaluating its cost in LOC, etc. and its impact on the software design, i.e. what you would like to change to support better audit, if anything.

  STL: Pluses and Minuses

  STL was developed as a higherly generic yet type-safe library supporting ease of programming of collections and other common programming paradigms. It has been out and in use for several years. How it is used, how much reduction in code size does it provide, what are its problems, etc.

  Unit Testing vs Statistics/Counters

  We consider in the course the possibility of providing more extensive statistics and counters in a software system, and relying on tests checking the correctness of these counters reduce the amount of direct test output checking. A project could look at evaluating this approach using some existing software system, considering additional counters and statistics to add, how they would be tested and some sense of how they contribute to the actual testing of the system.

  Collision Paradigm

  CS249 talked about the collision paradigm as a means to support dynamic discovery of relationships and to reduce the burden of maintaining references as part of relationships. Develop a general-purpose framework that supports this approach, ideally evaluating cost to help with making good trade-off decisions.

  Alternatively, explore the collision model within the context of some game or simulation.

  Physical Simulation Value Types

  In physical simulation, there is scalar, coordinates, velocities, accelerations plus their angular equivalents. Moreover, these are formed into 3-D vectors that need to support various operations. Explore how to model these various types and their operators such that the appropriate operators and conversions are allowed and inappropriate ones are precluded.

  Collection Support

  Develop an improved collection foundation for programming, perhaps building the work in various programming languages for group operations as well as addressing the deficiencies of STL, if you believe these are some.

  More specifically, consider the implementation of a string class or other variable-sized type, e.g. a sparse bitmap. How should it be designed so that its space requirements and processing requirements can be predicted in terms of overall application data demands?

  Concurrency

  The course proposes a particular approach to concurrency based on non-blocking synchronization and notifications. A project could develop a parallel or concurrency application in this structure to evaluate this approach. Alternatively, there could be an effort to compare this approach to other alternatives.

  Open Router Platform

  Click and XORP are two efforts to develop a framework for network/router components to provide an open, extensible platform. Evaluate these, or else develop some portion of your own.

  You could also focus on one particular aspect, such as packet buffering.

  The instructor will try to come up with more thoughts, plus you are invited to develop your own ideas.

  Spec Languages vs. C++/Java

  Programming languages have improved a lot since the early days, providing a higher-level representation of the design. What role, if any, can a separate specification language play. The use of such languages seems to be negligible in industrial except for very high-reliability systems. Can we understand the issues here better?

  Semantics

  Can we get a better handle on semantics. For instance, develop a class library that allows representing semantics as properties and testing objects and classes for specified properties.

  Exams

  
  Note change: All exams are take home and open book.
  
  

  Midterm Exam

  Date:Wed Feb 7, 2007
  Due:Mon Feb 12, 2007 by 1:15 pm
  Location: In the comfort of your own home.
  Previous Exam: 2006 midterm
  Previous Solutions: 2006 Midterm solutions
  

  Final Exam

  Date:Mon March 19, 2007 (available at 12:00pm)
  Due:Thu March 22, 2007 by 11:59 pm
  Previous Exam:2006 final
  Location: In the comfort of your own home.
  Exam: FINAL EXAM FOR 2007
  

  Final Project

  Proposal Due:Wed Feb 7, 2007
  Due:Mon March 19, 2007 by 11:59pm
  Location: Email the instructor the final report and source code.
  

  Policies

  The honor code is to be followed and shall be enforced. In particular:

  The Stanford honor code applies to all work done in this course. All work you submit must be your own. Suspected violations of the honor code will be investigated and referred to the Office of Judicial Affairs.

  Honor code violations are a serious matter, and being found guilty of one can ruin your academic career. Review the honor code. If you ever find yourself uncertain about how it applies to your situation, ask. Asking what you might think is a silly question is better than risking your career.

  Incomplete policy

  No incompletes will be given in this course, so make sure you determine before the drop deadline whether you can complete it satisfactorily.

  
  
  Last updated: 3/5/07