22c:022 Object-Oriented Software Development
Fall 2013

Course introduction and syllabus overview.

The complexity of software systems. The challenges of software development. Features of good software systems.

Decomposition of Complex systems. The role of design in software development

Introduction to Scala. The Scala interpreter. First examples of Scala expressions. Basic types and implicit conversions. Tuple types.

More on Scala. Mutable and immutable variables. Expressions with side effect. Sequential composition. Blocks. Control structures: if and while. Methods. Unit returning methods. Recursive methods. Nesting and variable scoping. Patterns and pattern matching.

More on pattern matching in Scala. Immutable lists. List construction and pattern matching. Recursive functions over lists.

The Object Model of development. Origins and evolution. Major features: abstraction and encapsulation. Design by contract. Examples of abstraction, encapsulation and contracts.

More Scala control structures: for. Iterating over collections.

The Object Model of development. Classes and class hierarchies. Subclassing and inheritance. Single and multiple inheritance. Types and type systems.

Classes and objects in Scala. Class declarations and initialization. Fields and methods. Parameterless methods. Encapsulation and information hiding in OO languages. Separating the interface from implementation. Examples in Scala.

Designing class hierarchies in OO programming languages. Subclassing and inheritance. Abstract and concrete classes. Factorization of methods and fields in superclasses. Overriding of fields and methods in subclasses. Static vs. dynamic type of an object. Composition vs. inheritance. Examples in Scala.

Abstract fields and methods. Motivation and uses.
Defining features of objects: identity, state and behavior. Classes as contracts. Contract inheritance. Behavioral subtyping and the substitution principle. Examples in Scala.

Discussion of Homework 1 grades. Note on the Scala Option type (to be used in Homework 2).

More on the substitution principle. Pitfalls with the is-a relation when modeling mutable objects. Examples with mutable rectangle and square classes.
Parametric polymorphism as a complementary way to promote reuse. Generic methods and classes in Scala. Motivations and examples.

More on generic classes in Scala. Examples.
Functions and closures in Scala. Functions as values. Programming with higher-order methods. Capturing computational patterns with higher-order methods. Examples.

Runtime assertions in Scala. Using assertion to in support of the Design-by-contract methodology. the require, assert and ensures constructs. Examples and exercises. Pros and cons.

Discussion of Homework 2 grades.

More practice with specifying contracts with require, assert and ensure. Sorted queue example.
Introduction to property-based testing with scalacheck. Motivation and advantages of property-based testing.

Using Scalacheck for Scala unit testing. Expressing method specifications as scalacheck properties. Examples and exercises.

Single vs. multiple inheritance. OO modeling exercise: the animal domain. Achieving multiple inheritance in OO languages. Scala traits. Uses and examples.

Midterm

Modules and modularity. Module decomposition vs class decomposition.
Modularity in Scala: singleton classes (objects) and packages. Uses and examples.

Discussion of midterm grading and solutions.
Analysis and design in software development. Iterative and evolutionary approaches. The Unified Process. Unified Modeling Language.

The benefits of iterative development. Pitfalls of the waterfall life cycle. Main phases of the UP.
Introduction to two main cases studies: POS systems and Monopoly game.
The inception phase of the Unified Process. Main goals and artifacts.

Requirements and requirement elicitation. The evolutionary nature of requirements. Main types of requirements and related artifacts. Use cases. Actors and scenarios. Types of actors. Levels of detail in use cases. Main and alternative scenarios. Examples.

More on use cases. Guidelines for writing good use cases. Examples. Granularity tests.
How to work with use cases. Exercise: "Get drink" use case on vending machine application.

Domain modeling using UML class diagrams. Associations vs. attributes. Examples. Cardinality constraints in associations. Special associations: generalization and aggregation. Examples.
Modeling exercise.

More on class diagrams. Examples.
Introduction of the class project. Brief discussion of the Model View Controller pattern and f the Elevator Algorithm.

Thanksgiving break

Thanksgiving break

Examples of object-oriented design with GRASP. Use case realizations for POS system.

Concurrent programming. The actor model.
Actors in Scala. Examples.

Verifying the correctness of Scala program with the Leon verifier.
Brief overview of Leon. Specification and verification examples.

Question and answers session on the course project.