Software Architectures
An advanced course taught in English, presented here as part of the broader account of my teaching activity. In the course material it also appears under the title Software Architectures. It is devoted to the architecture of complex software systems viewed at large scale: distribution, middleware, components, architectural styles and patterns, enterprise applications, and service-oriented architectures.
Key facts
- Institution: POLITEHNICA University of Bucharest
- Faculty: FILS – Faculty of Engineering in Foreign Languages
- Language of instruction: English
- Programme: Master’s programme in Software Engineering
- Year / semester: second year, first semester
- Official title: Software Architecture
- Title in the course material: Software Architectures
- Course coordinator: Luca Dan Șerbănați
- Structure: 3 lecture hours + 2 laboratory hours
- Assessment: final examination
- Credits: 5
- Prerequisites: Software Development Methods, UML modelling, and substantial programming experience in Java or C++
The place of the course in my teaching activity
This course represents the point of maturity of my teaching sequence devoted to software engineering. Whereas other courses focused on process, analysis, and object-oriented design, here the emphasis shifts to major structural decisions: how the system is divided into components, how those components communicate, how scalability, integration, fault tolerance, and evolution are supported, and what middleware mechanisms are needed for real distributed systems.
It is, par excellence, a course about software viewed at large scale. It is no longer concerned only with classes and local collaborations, but with architecture as a set of decisions that are difficult to change later, and with the conceptual and technological infrastructure required by enterprise and distributed systems.
Objective of the course
The general objective of the course is to develop a thorough understanding of software architecture: what it is, how it relates to analysis and detailed design, what styles and patterns give it structure, and how it can be used to build systems that are robust, maintainable, extensible, and integrable.
From this perspective, architecture is the level at which distribution, concurrency, persistence, remote communication, component containers, application servers, interoperability, and service-oriented architectures are treated explicitly.
Course structure
1. Introduction to software design and the role of architecture
The course material begins with a review of fundamental software design notions: the life cycle, forward and reverse engineering, the role of models in development, the iterative and incremental process, the relation between analysis and design, and the difference between architectural design and object design.
In this context, the course also discusses software complexity, design as constraint management, design principles such as SOLID, DRY, KISS, and separation of concerns, as well as the idea of model-driven design.
2. Software architecture as a distinct level of design
An important section clarifies the position of architecture among the levels of design: enterprise-wide architecture, application architectural styles, architectural patterns, and design patterns. Architecture is presented as the level at which the distribution of responsibilities among components and technologies is decided and the context is established in which lower-level design can take place.
3. Styles, patterns, and domain-specific architectures
The course distinguishes among architectural styles, architectural patterns, and domain-specific software architectures. Styles define the vocabulary of components and connectors and the way they may be combined, while architectural patterns provide recurring solutions to well-known architectural problems. In parallel, domain-specific architectures are presented as advanced forms of reusing engineering knowledge.
4. Distributed systems
A major block of the course is devoted to distributed systems. Their fundamental characteristics, the transparencies they must provide, and the difficulties introduced by distribution are discussed. Distribution is treated together with concurrency and persistence as one of the central conceptual dimensions of distributed computing.
The course emphasizes that the communication infrastructure is the central problem in the design of distributed systems, and that access, location, migration, replication, concurrency, performance, and scalability transparency are not given automatically, but must be constructed through suitable architectural means.
5. Middleware for remote communication
A substantial part of the course is devoted to middleware. It discusses the services required by distributed computing—naming, security, transaction, persistence, event, and message queuing—and then the major middleware families for remote communication: RPC-based middleware, ORB-based middleware, and Message-Oriented Middleware.
This area explicitly includes communication with remote objects, Java RMI, the role of stubs and skeletons, the RMI registry, and CORBA.
6. Component architectures and component middleware
The course gives an important place to component-based architectures. It presents the ideas of component, container, contract between components and container, and CORBA components with ports such as facets, receptacles, event sources, event sinks, and configurable attributes.
The emphasis is on modifiability and integrability: components are treated as loosely coupled entities with well-defined interfaces, easy to replace and integrate into a larger system.
7. Application servers and Jakarta EE / EJB
Another substantial section is devoted to application servers as an advanced form of middleware. It discusses the runtime environment, the services provided by application servers, the component model, scalability, load balancing, fault tolerance, security, and integration capabilities.
This part explicitly covers Jakarta EE and its containers (Enterprise Bean container, Web container, and Application Client container), as well as Enterprise JavaBeans as a server-side model for encapsulating business logic. The associated Eclipse GlassFish Server tools are also presented.
8. Design patterns as an architectural foundation
Although the main focus of the course is architecture, the material also contains a broad review of design patterns, treated as a conceptual foundation for architectural solutions. Principles for assigning responsibilities and fundamental, creational, structural, and behavioural patterns are discussed.
In this way, the course clearly suggests the continuity between local design decisions and the overall architectural organization of the system.
9. Service-Oriented Architecture
A broad section is devoted to service-oriented architectures. It presents the layers of an SOA, the role of gateways, the technological and data normalization layer, the process composition layer, and the issue of transactions in such architectures.
The course also discusses the ESB, web-service orchestration and choreography, and Service Locator, Service Façade, and Virtual Provider as patterns for service integration and access.
10. Web services, integration, and the API economy
In its final part, the course examines the evolution of integration solutions: from EAI and SOA toward web APIs and API management. It discusses the relation between SOA and web APIs, the evolution of ESB-based solutions, the emergence of gateways, the exposure of APIs outside the enterprise, and the transition toward the API Economy and microservices.
This section gives the course a very contemporary perspective, showing how the principles of services and integration naturally extend into new architectures based on APIs and highly distributed agile systems.
Laboratory work and assignments
The practical component aimed to apply architectural ideas in enterprise and distributed Java contexts. The page already emphasized JavaBeans, NetBeans, Eclipse, and the laboratory component, while the recovered material explicitly confirms the presence of Jakarta EE / EJB technologies, containers, application servers, and GlassFish tools.
From a teaching perspective, this shows that the course was not purely theoretical, but one that related architectural concepts to the effective technological infrastructure required by enterprise and distributed applications.
Assessment
Assessment was based on semester activity and the final examination. From the perspective of the course content, what mattered was not merely memorizing styles or patterns, but understanding how architectural structures are selected, how the use of middleware is justified, and how a coherent, distributed, and integrable system is designed.
Basic bibliography
- M. Shaw, D. Garlan, Software Architecture: Perspectives on an Emerging Discipline, Prentice Hall, 1996.
- F. Buschmann et al., Pattern-Oriented Software Architecture, Wiley, 1996.
- E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns, Addison-Wesley, 1995.
- M. Fowler et al., Patterns of Enterprise Application Architecture, Addison-Wesley, 2002.
- G. Hohpe, B. Woolf, Enterprise Integration Patterns, Addison-Wesley, 2004.
- P. Kuchana, Software Architecture Design Patterns in Java, Auerbach, 2004.
Significance of the course
Viewed retrospectively, this course expresses very well an idea that concerned me throughout my career: large software cannot be understood and built only at the level of code. It requires models, styles, patterns, components, middleware, application servers, and integration mechanisms capable of supporting the operation of the system as a whole.
For this reason, Software Architecture is not merely a course about known architectures or distributed technologies. It is a course about the engineering judgement required to organize complexity, integrate heterogeneous subsystems, and transform a dispersed technological ensemble into a coherent, robust, and evolvable system.