Basic Information

Instructor:Martin Robillard (email like a pro)
Time and place:Tuesdays and Thursdays, 16:05-17:25, ENGTR 0100
Office hours:See on myCourses


Principles, mechanisms, techniques, and tools for software development, with a focus on software design.

Sample Course Topics

Principles: Separation of concerns, encapsulation, substitutablity, interface segregation.
Mechanism: Exception-handling, serialization support, concurrency and synchronization, reflection.
Techniques: Design patterns, design by contract, unit testing, refactoring.
Tools: Integrated software development environment, automatic testing tools, coverage analyzers, static checkers.

Learning Outcomes

The learning outcomes for this course are organized along the four main conceptual axes of the course: principles, mechanisms, techniques, and tools. The following table lists the expected learning outcomes for the course (the table reads by row, from left to right).

After this course, you should be able to...

Name, using the proper terminology The important first principles of object-oriented software developmentThe common programming-language based mechanisms used to build OO software applicationsCommon software development techniquesA number of software development tools
Describe and explainThe purpose of each principle and how it can be appliedHow each mechanism worksHow to apply each technique and when it should be appliedThe theory underlying each tool, and the technique(s) the tool supports
ApplyEach principleEach mechanismEach techniqueEach tool
EvaluateWhether the application of a principle is appropriate to a given situationThe technical consequences of a solution involving the mechanismThe cost and benefits of using the technique in a given situationThe suitability of different tools for a given task
CreateA complete object-oriented application based on the first principles of object-oriented software development, the structured use of programming language mechanisms, the application of software development techniques, and the use of software engineering tools

Reference Material

Required Textbook: Horstmann, Cay. Object-Oriented Design and Patterns, 2nd Edition. Wiley, 2005. Available at the Paragraphe Bookstore.

Complementary Resource: Martin, Robert. Clean Code: A Handbook of Agile Software Craftmanship. Prentice-Hall, 2008. Available on-line from the McGill domain.

Course Work and Evaluation

You will have the opportunity to apply the course material in a series of individual assignments that will culminate in the creation of an interactive card game. The assignments are not formally evaluated. However, they are not optional: assessment of the learning objectives of the assignments will be done through coding questions in all three exams.
Midterm exam 125%
Midterm exam 225%
Final exam50%

Important Notes:

  1. If you miss a midterm exam, the grade of your other midtem will be used. Be sure to retain documentation justifying your absence. You do not need to present this justification unless required (see below).
  2. If you miss both midterm exams, you will need to present original, verifiable documentation justifying your absence for both exams. Valid justification is limited to unforseeable and unpreventable circumstances.
  3. The following material is subject to evaluation: Material presented in class, all material in the mandatory reading, operational knowledge of the tools covered in the course, anything completed to meet the learning objectives of the assignments. The midterm will cover all lectures up to and including the lecture immediately before it. The final will cover everything.

Official Academic Integrity Statement McGill University values academic integrity. Therefore all students must understand the meaning and consequences of cheating, plagiarism and other academic offenses under the Code of Student Conduct and Disciplinary Procedures (see for more information). Note that we reserve the right to run plagiarism detection software on all software submitted as assignments.

Language Policy In accord with McGill University’s Charter of Students’ Rights, students in this course have the right to submit in English or in French any written work that is to be graded.


General philosophy on the value of lectures, and related policies:

  1. Lectures will be designed to complement the course material with demonstrations, examples, discusssions, and class participation (to the extent possible). Lectures will not replace the mandatory readings and assignments, which should be done by the deadline posted.
  2. The lectures will not be Power Pointless. I will occasionally use slides to provide visual support for the material. The slides should not be expected to consitute a self-contained study document. I must emphatically warn anyone against attempting to pass the course by memorizing the slides.
  3. I will try to provide lecture summaries. However, taking notes can also be a good idea.
  4. Although I strongly recommend coming to lectures, attendance is neither mandatory nor monitored.
  5. To ensure that students who want to make the most of lectures can do so without distractions, computing devices of any kind are forbidden in the first four rows of the class. Laptops, mobile phones, and other gadgets can be used in the rest of the lecture room if done in a respectful and non-disruptive manner.
  6. No audio or video recording of any kind is allowed in class without the explicit permission of the instructor.
These policies are subject to revision at any point during the term. See additional background on the in-class use of computing devices at McGill.


This schedule is subject to change. It is strongly recommended to do the readings before class. The list of readings and references to required tools can be found on the myCourses page.

DateLecture Topics
2 SepIntroduction; Software Development Process
4 SepProgramming with APIs
9 SepClass design; Scoping and encapsulation; Cloning
11 SepPolymorphism and the Iterator design pattern
16 SepDesign by contract
18 SepIntroduction to Unit Testing
23 SepObject identity and life-cycle
25 SepComposite and Decorator design patterns
30 SepModeling Object State
2 OctReview for Midterm 1
7 OctMidterm 1
9 OctObserver Design Pattern
14 OctInheritance-based reuse
16 OctAbstract Classes; Template Method Design Pattern
21 OctError Handling
23 OctSoftware Quality Checking
28 OctIntroduction to GUI design with Swing
30 OctReview for Midterm 2
4 NovMidterm 2
6 NovGUI Design and Implementation
11 NovThreads
13 NovSynchronization
18 NovGeneric Types
20 NovInvited Lecture by the TaskNav Team
25 NovVisitor Design Pattern
27 NovReview for the Final