Skip to main content
Department of Information Technology

Note that the individual lecture topics are tentative. They may change as the course develops.

Lecture notes

  1. Introduction
    This lecture introduces the course and discusses assignments, exams and grades. The second half of the lecture revisits some of the philosophical and technical aspects of object-orientation, its origin, and discusses claims about the virtues of the paradigm.
    Lecture slides
  2. Object-oriented analysis
    The first half of this lecture introduces approaches to object-oriented analysis - object modelling for functional requirements - and discusses its relation to object-oriented design. Object-oriented design models a system as a collection of interacting objects. Objects with shared behaviour and properties are grouped into classes of objects, and classes with shared behaviour and properties are grouped into class hierarchies. The second half exemplifies analysis and design thought processes with Class-Responsibility-Collaboration cards for washing out what classes are needed for a system and their interaction.
    Lecture slides
  3. Software architecture
    This lecture introduces the concept of software architecture, which is the high-level design of a system, and only tangentially related to object-orientation (the same questions apply regardless of implementation paradigm). Software architecture is to a large extent about dealing with non-functional requirements (i.e., not the system's functions but their constraints and circumstances, e.g., memory requirements, maintainability, etc.). The lecture will discuss architecting to cater for specific such requirements, and survey a number of high-level patterns for overall system structure.
    Lecture slides
  4. Design principles
    This lecture introduces and discusses object-oriented design principles applicable to most OO designs. Over the years, researchers and practitioners have developed an understanding of design practises for avoiding "software rot," which is what happens, for example when extensions to a software does not fit into its existing design and consequently requires special solutions and/or modifications to existing code with propagating consequences. The lecture also sets the stage for Lecture 6's discussion of design patterns.
    Lecture slides
  5. Modelling notations (UML)
    This lecture introduces notations for describing models of various aspects of a system. We will use the industry standard UML language, although any consistent notation is feasible in practise. The UML language is a amalgamation of efforts by James Rumbaugh, Grady Booch and Ivar Jacobson and encompasses a wealth of diagram notations. We will focus on a subset of these, namely class diagrams, state machine diagrams, sequence diagrams, and communication diagrams. Remaining UML notation is simple and straightforward to pick up on your own if required.
    Good description of all diagrams and their components can be found at [1]
    Lecture slides
  6. Design patterns
    Just as the lecture on software architecture exemplified the development of standard architectural patterns with known properties, this lecture focuses on patterns for lower-level design. We will focus on a subset of the so-called "Gang of Four Patterns," such as the factory method pattern for creating objects without explicitly specifying the class to create, the adapter pattern for converting an interface of one class to clients' expectations, and the strategy pattern for deferring selection of object behaviour to run-time.
    Lecture slides
  7. Design-by-contract
    This lecture introduces design-by-contract, the notion of programming with explicit pre and post conditions, for object-oriented languages with examples, and relates it to UML's OCL extension. OCL, "Object Constraint Language," is useful in a class diagram to express e.g., preconditions and class invariants with support for object query expressions.
    Lecture slides (corrected on Oct 1, after the lecture)
  8. Stateful modelling
    This lecture discusses modelling of a system as a statechart.
    Lecture slides (corrected on Oct 6, after the lecture)
  9. (Supplementary) Object-Oriented programming is more than Java and C++
    This lecture takes a look at less mainstream object-oriented languages and discusses how their use affect low-level design. For example, prototype-based languages (e.g., Self and JavaScript) do not have classes, languages of the Beta family uses inner calls rather than a super calls which makes subclassing for polymorphism quite different, and untyped languages like Python and Smalltalk can make great use of double dispatch patterns to implement flexible and pluggable overloading, etc.
    Lecture slides
  10. Odds and Ends
    Parts of previous classes left out, or moved, or parts that we've gotten a lot of questions about. We'll cover Deployment, Refactoring, and API design, plus some unanswered questions from earlier in the course, including a concrete example of the Visitor pattern.
    Lecture slides

Updated  2012-10-10 23:00:04 by Kent Saxin Hammarström.