Modern Programming Techniques
A course taught in the master’s programme of the Faculty of Mathematics and Computer Science at Ovidius University. The course material bore the title Design Patterns, which expresses its main focus very well: introducing students to modern object-oriented design techniques through design patterns.
Key facts
- Institution: Ovidius University of Constanța
- Faculty: Faculty of Mathematics and Computer Science
- Programme: master’s programme
- Official title: Modern Programming Techniques
- Title of the course material: Design Patterns
- Language of the material: English
- Course coordinator: Luca Dan Șerbănați
- Year / semester / credits: to be verified
The place of the course in my teaching activity
This course belongs to the stage when, after many years devoted to programming languages, compilers, and software engineering, I tried to convey more directly a mature way of thinking about design. It was no longer only a matter of analysis, syntax, or implementation, but of the recurring forms of good software organization.
Design patterns provide a common vocabulary for solutions already validated in practice. For this reason, the course had a dual function: on the one hand, it brought students into contact with the culture of modern software design; on the other, it trained them to think in terms of responsibilities, collaborations, reuse, and design trade-offs.
Objective of the course
The course aimed to show that software design does not mean merely choosing classes and methods, but identifying recurring solution structures. Patterns provide such structures: they name typical problems, explain the situations in which they occur, and propose generalizable solutions together with their advantages and costs.
From this perspective, the course was also an introduction to the reuse of engineering knowledge. What is reused is not only code, but also design experience, in the form of models for organizing objects and the collaborations among them.
Course structure
1. Introduction to design patterns
The first part of the course material defines design patterns as condensed forms of experience in object-oriented software design. It discusses the meaning of a pattern, its constituent elements — name, problem, solution, consequences — and their role in reusing successful designs and architectures.
A taxonomy of patterns is also introduced here, grouping them into fundamental, creational, partitioning, structural, behavioural, and concurrency patterns.
2. Fundamental patterns
A first substantial section is devoted to fundamental patterns and begins with the problem of code reuse. Inheritance, composition, and delegation are discussed, with emphasis on the classical object-oriented design principle: favour composition over inheritance.
This section explicitly addresses the following patterns: Delegation, Interface, Marker Interface, and Proxy. The emphasis falls on decoupling, preserving encapsulation, and making access to services transparent.
3. Creational patterns
The second part of the material introduces creational patterns, viewed as techniques for organizing decisions concerning object creation. The course explicitly covers Factory Method and Builder.
These patterns are presented as ways of separating the request to create an object from the concrete decision regarding the class to instantiate, or from the process of constructing a complex object.
4. Partitioning patterns
A separate section is reserved for patterns that help partition and organize the system more effectively. This section covers Filter and Composite.
The Filter pattern is presented in both the source filter and sink filter variants, with emphasis on the flexible composition of transformations and analyses of data streams. The Composite pattern appears as a solution for part–whole structures and recursive object hierarchies.
5. Structural patterns
The course then addresses an important group of structural patterns: Adapter, Facade, Decorator, and Iterator.
They are presented as different ways of structuring relationships among objects: adapting incompatible interfaces, simplifying access to a subsystem, dynamically extending functionality, and traversing collections uniformly without exposing their internal representation.
6. Behavioural patterns
The final fully developed section of the material is devoted to the Observer pattern, presented as a mechanism for defining a one-to-many dependency among objects, so that a change in the state of one object can automatically trigger notification and updating of the dependent objects.
Naturally, this section also introduces the notions of publish-subscribe, notification, decoupling between subject and observers, and examples inspired by the Java API.
7. Style of presentation
An important feature of the course is its teaching style. Patterns are not presented as definitions to be memorized, but according to a constant scheme: intent, motivation, applicability, structure, collaborations, consequences, implementation, and sample code. This disciplined presentation required students to see each pattern both as an idea and as an implementable solution.
Teaching approach
The course material is strongly practice-oriented. Each important pattern is accompanied by UML diagrams and Java examples, sometimes quite extensive. This shows that the course was intended not only to provide general knowledge about patterns, but also to develop the actual ability to recognize and use them in a real software project.
Moreover, many of the selected patterns are not only the “classical” ones from the GoF repertoire, but also more elementary or more engineering-oriented patterns — such as Delegation, Interface, or Marker Interface. This gives the course a very sound pedagogical profile: it starts from the foundations and gradually reaches more elaborate repertoires.
Significance of the course
For me, this course was important because it made explicit something that often remains only implicit in software engineering teaching: good design solutions recur and can be learned. Patterns do not replace engineering judgement, but they provide it with a vocabulary and a professional memory.
Viewed retrospectively, the course also had the role of connecting the older experience of software design with the more recent literature on design patterns. In this sense, it represents a bridge between my software engineering tradition and the modern orientation toward reuse, components, and flexible architectures.