Software Design Techniques
A course taught at FILS in the English-language section, in the fourth year, first semester. It continues Software Development Methods and shifts the emphasis from analysis and modelling to the actual design of software systems, architectural decisions, and techniques for structuring large applications.
Key facts
- Institution: POLITEHNICA University of Bucharest
- Faculty: FILS – Faculty of Engineering in Foreign Languages
- Specialization: Information Engineering
- Year / semester: fourth year, first semester
- Language of instruction: English
- Official title: Software Design Techniques
- Course coordinator: Luca Dan Șerbănați
- Structure: 2 lecture hours + 2 laboratory hours
- Assessment: two major projects + written examination
- Credits: to be verified
- Prerequisites: Software Development Methods, Object-Oriented Programming
The place of the course in the evolution of my teaching
This course represents one of the most mature forms of the way I understood software engineering teaching at FILS. Whereas Software Development Methods focused on process, requirements, domain modelling, and the gradual construction of the analysis model, here the emphasis shifts to design: how the system is organized, how responsibilities are distributed, how architectural structures are selected, and how design solutions validated by experience are reused.
In addition, the course explicitly opens the way toward distributed systems, middleware, and service-oriented architectures. It therefore does not remain at the level of local object-oriented design, but moves toward the broader problems of enterprise software systems.
Objective of the course
The course aims to develop an engineering view of software design: how to move from the models resulting from analysis to implementable structures, how to separate abstraction from implementation, how to choose suitable styles and patterns, and how to design systems that remain modular, scalable, maintainable, and extensible.
From this perspective, the discipline has a dual character: on the one hand, it clarifies the theoretical principles of design; on the other, it requires students to apply them effectively in projects larger than ordinary programming exercises.
Course profile
The course material presents it as an advanced software design course, intended for the development of large software systems. The emphasis is on the relationship among object-oriented design, systems architecture, and reuse techniques. Thus, the course goes beyond the level of a mere repertoire of UML diagrams and attempts to provide a coherent conceptual framework for designing complex systems.
It can be viewed as a bridge between disciplines devoted to analysis and modelling, on the one hand, and disciplines devoted to software architecture, distributed systems, and application integration, on the other.
Course structure
1. Introduction to software design
The introductory part discusses the place of design in the software development life cycle, the difference between forward engineering and reverse engineering, the role of models in the development process, and the architecture-centric character of the Unified Process. This section also clarifies the distinction between architectural design and object design.
2. Fundamental design concepts and principles
The course introduces the conceptual tools of design: abstraction, reification, deduction, and induction. Against this background, modern design principles are discussed: SOLID, DRY, KISS, YAGNI, as well as the idea of separation of concerns. Classical techniques also appear, including stepwise refinement, levels of abstraction, and structured design.
3. Qualities pursued in design
An important section concerns the vocabulary of engineering quality: modularity, componentization, reuse, performance, scalability, resilience, fault tolerance, and elasticity. The emphasis is on the fact that design is essentially a negotiation between constraints and desired qualities.
4. From analysis to design
The course explicitly explains how the design model is derived from the analysis model: the relationship among the use-case model, domain model, SSDs, operation contracts, and design classes. It emphasizes the traceability of design to analysis and the idea of “reducing the intellectual distance” between the problem domain and the software structure.
5. Reuse and patterns in software development
A central component of the course is devoted to reuse: not only code reuse, but also the reuse of ideas, structures, behaviours, engineering experience, and solution models. In this context, the concepts of pattern, architectural style, architectural pattern, and domain-specific architecture are introduced.
6. Assignment of responsibilities
Before the GoF patterns themselves, the course discusses fundamental principles for assigning responsibilities to classes: Information Expert, Creator, Low Coupling, High Cohesion, and Controller. They serve as general criteria for object-oriented design.
7. Fundamental and creational patterns
Fundamental patterns such as Delegation, Interface, Marker Interface, and Proxy are covered, followed by the creational patterns: Factory Method, Abstract Factory, Builder, Prototype, Singleton, and Object Pool.
In this part, the course emphasizes decoupling the client from concrete classes, controlling the creation process, and reusing structures for constructing complex objects.
8. Structural and behavioural patterns
The course then addresses structural patterns such as Filter, Composite, Adapter, Iterator, Bridge, Facade, Decorator, and Virtual Proxy, as well as the repertoire of behavioural patterns (Command, Observer, State, Strategy, Template Method, Visitor, Mediator, Interpreter, etc.).
The objective is not to memorize them in isolation, but to understand the relationships among them and the way they can be combined in the design of a real application.
9. Architectural styles and patterns
Another important section is devoted to software architecture: the difference among an architectural style, an architectural pattern, and a reference architecture, as well as their role in organizing large systems. Styles discussed include monolithic, client–server, N-tier, layered, component-based, event-driven, message-passing, SOA, REST, microservices, peer-to-peer, and space-based architectures.
Architectural patterns such as Broker, Model-View-Controller, Model-View-ViewModel, Microkernel, Plug-ins, CQRS, and Ports and Adapters are also presented.
10. Distributed systems, middleware, and services
In its advanced part, the course deals with the design of distributed applications: the dimensions of distribution, concurrency, and persistence, the services required by distributed computing, and the middleware infrastructure. Middleware forms for remote communication are introduced: RPC/RMI, ORB, and Message-Oriented Middleware, followed by the role of application servers.
The course then moves toward service-oriented architectures, the SOMA approach, and an introduction to web-services-oriented architectures.
11. Projects
The course material explicitly indicates a substantial applied component: practical exercises and two major design projects. These aimed not merely at the isolated application of patterns, but at integrating them into a coherent design capable of supporting realistic functional and non-functional requirements.
Laboratory and project work
The practical component of the course was intended to transform principles and patterns into effective design decisions. Students were required to choose suitable structures, justify the use of particular patterns, and construct models of collaboration among objects, subsystems, and services.
Projects occupied a central place in assessment. The recovered course material shows that they were conceived as genuine design projects, not merely coding assignments: they had to demonstrate the choice of an architectural style, dominant patterns, and a coherent structure of responsibilities.
Basic bibliography
- Luca Dan Șerbănați, Software Design Techniques, course material.
- L. D. Șerbănați, Integrating Tools for Software Development, Yourdon Press / Prentice Hall, 1992.
- E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns.
- G. Booch, J. Rumbaugh, I. Jacobson, The Unified Modeling Language. User Guide.
- M. Fowler, UML Distilled.
- C. Larman, Applying UML and Patterns.
- R. C. Martin, works on the SOLID principles.
Significance of the course
Viewed retrospectively, this course marks the transition from teaching software modelling to teaching the art of actually designing complex systems. It no longer deals only with “how we describe” a system, but with “how we organize it” so that it can withstand change and remain extensible, distributable, and integrable.
In this sense, it occupies a connecting position between the analysis and modelling learned previously and the disciplines devoted to software architecture, distributed systems, and integration. It sought to accustom students to the idea that design is not simply an extension of analysis, but a distinct activity involving trade-offs, constraints, technological choices, and forms of reuse.