Professional programming

Lecture notes

1. The module's contract, and the map of notions : What is expected, how it is marked, what the assistant is allowed to do, and the twenty-eight notions of the module with the exam question for each of the thirteen certified ones.
2. Why Java, and why this module : The context of the module, what Java brings to companies, and what “professional programming” means here. Nothing certified in this chapter.
3. Summary of the first lecture: relationships, inheritance and interfaces : The three notions of the first lecture, and two common mistakes that go with them, checked by running the code.
4. The class struggle : The four relationships between classes (association, aggregation, composition, inheritance) and the criterion that tells them apart, the lifetime of the objects.
5. Inherit or compose : Inheritance is the strongest relationship between two classes. This chapter presents what it brings, what it costs, and the cases where composition is the better choice.
6. Depending on an interface : Declaring an interface is not enough to reduce coupling: the class must receive the object it depends on instead of creating it itself.
7. The declared type and the actual type : The compiler relies on the declared type, execution on the actual object. This chapter distinguishes the two, a frequent source of errors in the start-of-year audit.
8. Encapsulation and invariants : Making an attribute private is not enough to protect an object. Encapsulation serves to guarantee invariants, that is, properties that must remain true.
9. Coupling, cohesion, God Object : Coupling and cohesion, two criteria for assessing a design, and the God Object, which satisfies neither.
10. Exceptions : What happens to execution when an operation fails, the difference between checked and unchecked exceptions, and the common ways of hiding an error unintentionally.
11. Design patterns : Three patterns to be able to recognise, eleven others presented for reference, and the question to ask before using one: which problem needs solving?
12. The contract of Object : The methods every class inherits from Object and that often need overriding, the contract linking equals and hashCode, and what happens when it is not respected.
13. Generics and enumerations : Two typing tools that make it possible to detect some errors at compile time rather than at run time. A chapter to read, not certified.
14. The limits of OOP and other paradigms : The weaknesses of object-oriented programming, other paradigms, and a few questions to ask before adding an abstraction. A chapter to read.
15. The CanardFactory audit : A production code file with flaws from beginning to end. Note them, then look at the answers. An exercise chapter.