The course learning objective is to understand modern software design and practice design and modeling methods in a team project

1. Course introduction. Software quality and requirements. Why do we need good architecture?
2. Software requirements primer. Functional/non-functional. Elicitation and specification. Methods: structured text, scenarios, features/jobs. Overview of testing approaches
3. Object oriented design. Type systems. Abstract data types. UML2 basic class models. Reminder: data modeling and database design. ER diagrams (crow-foot) vs. UML2 data modeling.
4. Introducing Domain Driven Design. How to find classes? Checklists, noun phrases, language concepts. Domain modeling: ubiquitous lang, bounded context. Elements: entities, value objs, aggregates, services
5. Explain Responsibility Driven Design as a method to decompose behavior among objects. Collaborations, roles and interfaces. Interface implementation. UML2 behavior modeling. Basic activities. Interactions.
6. Introduce basic UML2 state diagrams, package models. Describe UML2 Big Picture for logical modeling

1. General structured design approach (contrast with e.g. tuning). Decomposition principles. Modularization. Cohesion and coupling. Structure charts and dataflow modeling. Define software architecture, reference architecture, 4+1 views or C4 model and basic styles
2. Definition of resources and microservices. Microservices identification in bounded contexts. Conway's Law. Domain integrations in DDD. Sync/async APIs
3. Hexagonal and microservices architecture (MSA). API patterns: BFF, API GW, Client Integration. Implementation of RESTful HTTP service. Basic internet tech: DNS, TCP/IP, HTTP/1.1, WebSockets. How to select and evaluate COTS. Licensing.
4. How to implement a microservice using frameworks OO languages. SOLID principles. Frameworks. Define design patterns. Classification of patterns.
5. Data storage in applications and MSA. Reminder: relational and NoSQL DBMSs. Transactions and state management. ACID and BASE. Data access patterns.
6. Detailed design for microservices and MSA. Applications of object-oriented patterns (GoF). Microservices patterns.
7. What is good/bad design? Coherence/coupling metrics. OOP metrics Chidamber/Kemerer. MSA metrics

Students analyse and design a microservices or monolithic application in teams of 3-4 persons. This includes elaboration of the initial problem, requirements specification, architectural and detailed design using modeling languages.

Students may switch teams once during each Module. Teams may switch project topics before Module 2 starts.

In companion to the team projects, students solve software design problems and study design of existing open source systems.

Individual assignments also include writing a short essay on a research topic in software design from a list provided by instructors.

Module grade = 0.1 * Attendance + 0.45 * Team Project + 0.1 * Essay + 0.35 * Practice

Module grade cannot exceed 10. The final grade is an average of Module 1 and Module 2 grades rounded up.

Attendance is 0..10 and covers lectures and practice sessions, 10 is all but one week of absence.

Team Project is 0, 4..12 is proportional to project score achieved by the team, score includes completed project assignments during the practice and the final project report in each Module. Score 10 is given for a project well-done, a greater score may be achieved for larger projects, more detailed solutions or more complex project topics.

Team Project scores less than 4 are rounded down to 0 (failed).

Essay is 0..5. Grading details for the essay are provided along with the topics.

Practice is 0..10 is proportional to individual activity during the practice sessions, including reporting for the team, reports at the blackboard etc.

1. Sam Newman. Building microservices
2. Vaughn Vernon. Implementing domain driven design
3. Head-first design patterns
4. Sommerville. Software Engineering 10th ed.
5. K. Wiegers, D. Beatty. Software requirements engineering, 3rd Ed.

1. Tackle Business Complexity in a Microservice with DDD and CQRS Patterns
2. Getting Started with Domain-Driven Design

Prof. Anton S. Khritankov, Ph.D.

Assist. Prof. Sofia Yakusheva, 2022-curr.

TA Azamat Ismagulov, 2023-curr.

In the past years

Assist. Prof. Igor. Y. Mezhuev, Ph.D., 2021-2022