Software Construction - HS 17



Instructor: Prof. Bertrand Meyer
Course Assistant: Jürgen Cito
Teaching Assistants: Raphael Matile, Livio Sgier

Tuesday/Wednesday, 08:00-09:45

Wednesday, 14:00-18:00 (only 20.09, 11.10, 08.11, 13.12)

Language: English
AP (ECTS): 6.0
Target audience: Students in BSc Informatik
Requirements: BSc Informatik: Assessmentstufe
Registration: UZH Buchungstool
VVZ: organizational details in UZH online course catalog (VVZ)


Knowing how to program does not make you a software engineer. The next step is to learn and practice the principles and techniques of professional software development. This course helps you climb it. It is an introduction to both:

Software architecture: methods for designing the structure of software systems, small or large, that will stand the test of time.

Software engineering: methods and tools, including non-programming aspects (project management, requirements analysis, human factors, metrics, software processes including agile methods) necessary for producing successful systems. The course relies on object technology and focuses on techniques that will scale up for large systems, with a strong emphasis on software quality.


The goal is to equip students with fundamental concepts and practices that will help them become professional software engineers, support them throughout their career, and make them stand away from ordinary programmers. The course includes a software project, emphasizing architectural and engineering skills.

The working programming language for most of the examples and for the project is Eiffel, a pure object-oriented language with a focus on software quality. Eiffel is easy to learn for anyone knowing, for example, C++, Java or C#, and the lessons of this course can be applied to those and any other programming language.



The course consists of lectures and laboratory sessions. The laboratory sessions take place every week during the semester. The lectures will take place in four blocks.  The themes of the four blocks are:  

1. Block: Key software engineering practices: requirements analysis; software testing and verification; basics of configuration management

2. Block: Object-oriented design: abstract data types, information hiding, the class concept, the role of inheritance, open-closed principle, command-query separation principle, open-closed principle, single-choice principle, and others.

3. Block: Software architecture: Design by Contract; classical design patterns; Architectural styles.  

4. Block: Software process: software process models; CMMI; agile methods.

Lecture Timetable

Date Topic Documents
Block 1 Key software engineering practices  


Kickoff and Introduction to software engineering and architecture

Slides (PDF, 468 KB)

20.09.2017 (morning)

OO Trailer

Slides (PDF, 903 KB)



Software engineering: requirements
Design Patterns 1 (Undo-Redo Pattern)

Slides (PDF, 667 KB) (Requirements)

Slides (Undo-Redo)

Block 2 Object-oriented Design  

Software process models, CMMI, introduction to agility


Further material

CMMI Blog Post

Agile EdX course





Further material

Parnas (1972) paper



Abstract Data Types (ADTs)

Introduction to Design Patterns

Slides (ADT)

Further material:

Guttag (1976) paper

Slides (Design Patterns)

Block 3  Software architecture  

Design by Contract




Software testing and verification




Design patterns 2 (final) and architectural styles

Block 4 Software process  

Agile development




Clever Algorithm: Levenshtein




(Levenshtein cont'd)



Exercise sessions review the course contents and illustrate its concepts in smaller exercises. Additionally, these sessions can be used to clarify questions on the course project. They are held by the teaching assistants at the morning sessions (Tuesday and Wednesday, 8:00-9:45) outside of the block lectures.

Date Topic Documents

26. and 27.09.2017

Git and Eiffel Tutorial + Project Q&A


Project Q&A (PDF, 111 KB)

03. and 04.10.2017 

Design Pattern: State and Application (cf. OO Trailer lecture slides)


24.10.2017 Design Patterns: Overview



21. and 22.11.2017 From Requirements to Automated Testing Slides
28. and 29.11.2017 Version Control in Git (Commits, Branches, Merging/Conflicts, Interactive Rebase)

No slides, interactive demonstration

"What's wrong with Git paper"

Good Commit Messages

Rewriting Git History

Grading ("Leistungsnachweis")

The overall grade will be composed of the final, written exam (50%) and the group project (50%).


The principles and techniques learned in the course will be applied in a project consisting of 4 team members. If you want to participate in the course, please form a team and send an email to Jürgen Cito until September 24th, including the GitHub usernames of all 4 team members.

The description of the project and milestones 1 to 4 are online: Project Description (PDF, 115 KB) (November 19th)


When you work in a group of students we expect that everyone does his or her fair share. Not necessarily equal contributions (which would be difficult to define anyway), but simply making sure that the result includes significant work by all group members.

If a problem arises in this respect, it’s OK to bring it up explicitly; this is better than accumulating frustration. If you have the impression that one of your teammates is under-contributing, the procedure is:

  • Discuss it within the group. The teaching team will not consider complaints unless there has been such an internal discussion first.
  • If possible, resolve the question within the group and take any necessary corrective actions. This resolves the matter.
  • If not, bring it up with your assistant. The teaching team will examine the matter, getting information from all those concerned.


The requirement for taking the `Software Construction` exam is to be part of a team that delivers a project which runs and has supporting documents including as a minimum:

  • Requirements document or user manual
  • Design document

We provide a few sample exam questions: Exam Samples



The following are the two recommended textbooks for the course:

  • Bertrand Meyer: Object-Oriented Software Construction, Second Edition, Prentice Hall 1997, ISBN 0-13-629155-4
  • Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides: Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley 1995, ISBN 0201634988

It is also recommended that you use a good software engineering textbook, such as:

Additional reference on patterns:


We list additional documents that can be of use during the course.

SRS templates and example documents: