Short Description

The course teaches the underlying ideas and principles behind OO, compares how these ideas and principles have been realised in different languages (e.g., Smalltalk, Eiffel, Java and Python) and gives an orientation in new and neighbouring areas such as Aspect-Oriented Programming. Finally, the course briefly looks at how OO features such as message passing, polymorphism, dynamic binding, etc. can be implemented in a programming language.

Aim

While this course focuses on object-orientation and programming languages, this is not a course in programming. Students are required to have at least moderate programming skills beforehand. Our goal is to further the understanding of object-orientation, not to introduce it. Having successfully completed the course, the student should be able to:

• explain the differences between a language (syntax, libraries, IDE:s, etc.), its implementation of object-orientation and the concept of object-orientation
• use less widely known object-oriented features like prototype-based programming, multi-methods and metaclasses to solve programming problems
• easily adapt to various languages’ implementations of object-orientation
• write non-trivial programs in at least 3 object-oriented languages (preferably languages that she didn’t know beforehand and excluding Java)
• reason about the effects of choosing a specific language over another for a given task
• solve problems in an object-oriented fashion in languages without explicit support for object-orientation
• reason about the inner workings of object-oriented mechanisms and use that understanding in her programming (for example, to perform optimisation or avoid subtle bugs due to dynamic binding)
• identify functions that should be modelled as aspects and implement simpler aspects in an aspect-oriented programming language

The course will also overview some current research trends or problems in the area. The goal is to inspire the students to further their studies of the field, for example on a master level.

Syllabus

• OO and its underlying principles
• Class-based OO and object-based OO
• Classes and metaclasses
• Inheritance (single, multiple, implementation inheritance, multiple implementation and mixin) and delegation
• Subclasses and subtyping
• Static and dynamic binding and multi-methods
• Static and dynamic linking
• Polymorphism, overloading, overriding
• Generics (a.k.a. templates)
• Type systems, static typing and dynamic typing
• Encapsulation and information hiding
• OO-design patterns
• Reflection and introspection
• How OO languages are implemented
• Aspect-oriented programming
• Different OO languages and their implementation of OO
• Current research on OO

Prerequsites

Required prior knowledge: OO and programming in an OO language, preferably with an imperative core, such as Java is required. Moderate programming skills. It is good to know at least one procedure-oriented language such as Pascal or C, but it is not necessary.

You should be able to install programs on a computer, or at least be able to find the proper guidelines for installing a piece of software and follow them. You should also be able to learn the absolute basics of a few object-oriented programming languages on your own aided by manuals and tutorials, but with little or no teacher assistance.

Follow-up

AGILE, MOOG, TEME, DYPL, CISS.

Requirements

Assignments, individual and in group, 4 credits; Take-home exam 1 credit.

Required reading

Either or both of these books:

• Timothy Budd, an Introduction to Object-Oriented Programming
• Iain Craig, The Interpretation of Object-Oriented Programming Languages

Additional papers and compendium.