COS ST3: Syllabus

Abstraction (4.5 weeks): In this segment of the course, we will focus on the concept of abstraction in software design. What do abstractions give us? What types of abstractions can be used or created? Advanced types of abstractions will be covered.

• Week 1.1
  • Introduction: abstractions we already take for granted.
    • Virtual memory
    • File system
  • Trade-off analysis: what do we pay to enforce or abide by a certain abstraction? We will consider this throughout the discussions.
  • Levels of abstraction
    • Procedural abstraction: separating the interface from the implementation.
    • Data abstraction: separating the data from the interface.
    • User-defined types: flat class hierarchies.
• Week 1.2 & 2.1
  • Object Oriented Programming:
    • Polymorphism and runtime type-checking.
    • An object's levels of abstraction.
• Week 2.2
  • Abstraction is other programming models
    • Functional programming
  • Using and creating useful abstractions
    • Building on lower-level abstractions to create a higher-level abstraction
    • Case study: Windows API versus MFC
• Week 3.1
  • Multiple inheritance
• Week 3.2
  • Strong abstractions: hiding the fact that there is any class hierarchy at all, hiding memory management in C++.
• Week 4.1
  • Algorithmic and object abstractions: creating algorithms that don't depend on the type of object being manipulated
    • Java's Object class
    • C++ templates.
• Week 5.1
  • Bidirectional abstraction and the protected interface.
• Week 5.2
  • Discussion of possible better abstractions
  • A wrap-up of the trade-offs in creating abstractions.

Modularity (3 weeks): Here, we will discuss making programs modular, and breaking problems into smaller pieces.

• Week 5.2
  • Motivation: Why make my program modular?
    • Different people writing different code and different places and different times.
    • Code re-use.
    • Testability issues.
    • Porting: modular code is (almost) portable code.
    • What are the trade-offs in development time and flexibility?
  • Class-level modularity
    • Separating subsystems into classes
    • Example: 3-D simulations; rendering and simulation components.
    • Removing the User-interface from the application code. We will discuss various techniques for removing user interface code from code that manipulates and creates application data.
      • UI-contains-application model
      • Application-inherits-from-UI model
      • Multiple inheritance: abstracting away the user interface.
• Weeks 6.1 & 6.2
  • Component Object Models: ways to abstract away more than just a function call.
    • Motivation: why aren't classes enough?
      • Separating a very large program into software sub-components
      • Re-using large blocks of code: example: a .gif or .jpg renderer.
      • Inter-language communication.
    • Current technologies:
      • Java Beans
      • COM
    • What lies ahead?
• Week 7.1
  • Scripting Languages and scripting support
    • Motivation: remote-controlling entire applications to build functionality.
    • JavaScript
    • VBScript
    • Visual Basic
• Week 7.2
  • A Modularity Example: a web-browser
  • A wrap-up of the trade-offs in creating abstractions

Expandability (3 weeks): In this final segment, we will discuss how and why applications are made expandable.

• Week 8.1
  • Motivation:
    • Code grows in initial development
    • Code will grow later.
    • Code will be modified by others.
    • Your application will do things you never imagined, and will run longer than you ever thought possible.
    • Expandibility and development time are often at odds. What are the trade-offs?
  • Structuring for Incremental Development
    • Motivation: an application structure that allows writing code once and not modifying it again.
    • Making the engine code flexible.
    • Examples of solid structures.
    • Testing incrementally: being able to mark features "complete."
• Weeks 8.2 & 9.1
  • Structuring for future expansion
    • Structuring for obvious expansion: things you've already thought of, but won't get to implement.
    • Structuring for non-obvious expansion: the application will do things you never imagined.
      • Tension between flexible code and strong abstractions.
    • When does planning for expansion stop? When does expansion stop?
• Week 9.2
  • Modification of code by others
    • Readability, clarity, efficiency.
• Weeks 10.1 & 10.2
  • Advanced Topics and Examples
    • Versioning
      • Backwards compatibility?
      • Forwards compatibility?
      • Flexibility?
      • Example: data file format.
    • Scripting
      • Making the scripting interface extensible.
  • Final word on trade-offs.

Weeks 11 & 12 will be spent on guest lectures and project presentations.