Thursday, 9:00, S3 (Lubomír Bulej)
  Monday, 9:00 and 10:40, SU2 (schedule is irregular) (Vojtěch Horký)
Information in SIS: NPRG043
Term: Credit and exam

Programming is not just a matter of writing a program that runs (correctly), or implementing a particular algorithm. Modern programming has become a task in managing structural complexity of computer systems. For small-scale programs, which often serve as a wrapper (handling inputs and outputs) for some algorithm, the (structural) complexity is dominated by the abstractions, operations, and data structures required to implement the algorithm. In medium-sized programs and large-scale software systems, the complexity due to algorithm and the associated data structures stops dominating as the program becomes complex as a result of the number of concepts and their interactions. For such programs, design plays a critical role as the ability to develop and maintain such programs surpasses the capacity of a single person.

In such projects, the ability of team members to communicate effectively becomes extremely important, and the source code of a software system becomes one of the communication channels, which also happens to exactly reflect the current state of the system. While source code quality is (usually) not directly related to correct function of a software system, it does have a significant impact on other important aspects, such as readability, maintainability, and together with design also extensibility and reusability.

The source code quality manifests in many ways, from source code formatting, ordering of statements, choice of variable and function names, decomposition into methods, the content of comments, to design of classes and interfaces. At the lowest level, the goal is to find how to clearly and conveniently capture the executed operations, while at the highest level, the goal is to identify and use good abstractions, which simplify writing and orientation in code, and thus make a program easier to maintain and extend.

Through lectures and lab work during the semester, the course aims to introduce the students to (best) programming practices that lead to better code and program design. The goal is to motivate the students to adopt and use these techniques in practice.

Topics covered

  • Software construction and design, managing essential and accidental complexity.
  • API design, general principles, impact on class and method design.
  • Class design, abstraction & encapsulation, inheritance & composition, polymorphism, immutability.
  • SOLID design principles, design patterns in the context of design principles.
  • Method design, cohesion, naming, parameter passing, returning values, using exceptions, defensive programming.
  • Basic building blocks, variables and constants, general guidelines, naming convetions, fundamental data types.
  • Control structures and primitives, general guidelines, conditional statements, loop statements, code organization.
  • Code formatting, general principles, formatting blocks of code and code elements, formatting aids.
  • Documentation, internal documentation and comments, self-explanatory code.

Contact and office hours

The course has a mailing list which serves as the primary means of communication between the students and the lecturers. Please use the mailing list for any questions or suggestions related to the course, because it will (most probably) be of interest to other students as well.

If there is something that you do not want to discuss in the mailing list, do not hesitate to contact either of us directly or via email:

When sending us an email, please do try to make sure that what you are asking is not already answered elsewhere – either in the mailing list or on the course web page.

E-mail is preferred for brief inquiries and it is generally OK to come to my office without an appointment. However, a consultation is not a private lecture, therefore if you need to discuss a topic at length, it is better to arrange an appointment with a clear goal. This is especially important if you have trouble understanding something, because the first step is to find out what is it that you still understand and what is the next bit which is unclear.

I can be found in office 205 (2nd floor in the Malá strana building), except when I\’m not, which is: on Mondays, when I\’m teaching, when attending the department seminar, or when attending a conference or a project meeting. It is safe to assume that I will be in the office between 10am and 5pm (I often come earlier and stay longer), but if you plan to come outside those hours, it is better to contact me in advance.


The focus of the work during the semester lies in a set of assignments which students are expected to work on outside of class. To compensate, the number of labs is reduced and the labs follow an irregular schedule. The following calendar shows the lab schedule and the deadlines for assignment turn-ins:

Alternative links: XML/RSS, iCal, HTML


Date Title Downloads
Week 1 Introduction Slides
Week 2 API design: general principles, class & method design Slides
Week 3, 4 Class design: abstraction & encapsulation, inheritance & composition, polymorphism, immutability Slides
Week 5 (SOLID) Object-oriented design principles Slides
Week 6, 7 Design patterns meet design principles Slides
Week 8, 9 Method design: cohesion, naming, parameter passing, return values, exceptions Slides
Week 10 Defensive programming: preconditions, asserts, error handling Slides
Week 11 Basic building blocks: variables and constants, naming, data types Slides
Week 12 Structured programming primitives: sequence, selection & iteration Slides
Week 13 Formatting code: principles, formatting aids, formatting blocks of code
Documentation: internal documentation & comments, self-explanatory code
Slides (formatting)Slides (documentation)
Week 14 Lecture cancelled (business trip)
Replacement lecture NOT scheduled.


Date Title Downloads
February 18 Agenda, API Design Slides (agenda)Slides (API)
March 4 API Design Slides
March 11 API Design Review Slides
includes task #2 description
March 25 API Design Presentations, Unit Testing Slides
April 15 Refactoring Slides

Assignments and grading

The core of the work in the course comes from multiple assignments. Some of them are intended for pairs of students (to facilitate discussion about design and to try working with someone else), while others have to be submitted individually. The final grade is mostly determined by the assignments and the course can be passed with flying colors solely on the basis of excellent work during the semester. An optional final test is scheduled for the exam period.

The maximum amount of points that can be awared is 120, out of which 100 can be awarded for the assignments and 20 for an (optional) exam test. The mapping between points and the final grade is shown in the following table:

Grade Points
1 > 96b
2 > 78b
3 > 50b


The course is mostly based on the 2nd edition of the Code Complete book by Steve McConnel (also in Czech):

  • McConnell, S. Code Complete: A Practical Handbook of Software Construction. 2nd edition, Microsoft Press, 2004, ISBN 978-0735619678
  • McConnell, S. Dokonalý kód: Umění programování a techniky tvorby software. 2. vydání, Computer Press, 2006, ISBN 80-251-0849-X

While there are many other books dealing with the software development and maintenance, only a few put such a strong emphasis on writing program code. Another useful source of insight is the 2nd edition of the Effective Java book by Joshua Bloch:

  • Bloch, J. Effective Java. 2nd edition, Addison-Wesley, 2008, ISBN 978-0-321035668-0

With respect to design principles, essays and books by Robert C. Martin are a time-proven classic, and when it comes to design patterns and their connection to design principles, I have found the Head First Design Patterns book by Eric Freeman, Elisabeth Robson, Kathy Sierra, and Bert Bates to be both entertaining and enlightening:

  • Freeman, E., Robson, E., Sierra, K., and Bates, B. Head First Design Patterns. 2nd edition, O\‘Reilly, 2014, ISBN 978-0-59600712-6

Online resources

In addition to books, many interesting essays and articles on software design and good practices can be found on the web. Links to many of those can be found in the notes to lecture slides.

When it comes to design and testing, the online guide on Writing Testable Code by Miško Hevery provides a set of guidelines that help keep certain design malpractices at bay and testers happy: