Best Practices in Programming

News

About

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 is no longer the dominating factor, because 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 uses a GitLab issue tracker in a dedicated Forum project repository as the primary means of communication. Please use the Forum 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 needs to be discussed in private, please create a confidential issue on the Forum.

Using the issues has the advantage providing a view of the state of a particular issue (for the issue creators) and also a view of outstanding issues (for the course instructor).

Even though occassional (time-critical) announcements may be made via e-mail (using the one you have in SIS), you should either check the forum periodically or subscribe to the repository notifications.

Please use e-mail only if you feel that the Forum (confidential) issue tracker is not fit for the purpose. If you need to discuss something in person, make sure to check my teaching schedule to avoid coming just before my lectures. If you need to discuss something at length, I suggest to arrange an appointment — preferably over Zoom (I can host it).

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 get used to 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.

The final grade is determined by the percentage of points gained from all assignments as shown in the following table:

Please keep in mind that no assignments can be skipped (or turned in empty). You will be providing other teams with feedback for their design and tests for their code. Likewise, your team will be receiving tests and feedback from other students. Skipping assignments would be grossly unfair to other students.