Software Architecture & Design of Modern Scalable Systems

Learn object oriented modeling to break down requirements into objects with attributes and behaviors, improving code organization, flexibility, and reuse, and map objects to real world concepts.

Design in software development frames building a solution as a process from understanding requirements to architectural design, using CRC cards and UML diagrams before coding.

Define and elicit requirements before coding, clarifying what the product must and must not do. Establish trade-offs and ask follow-up questions to reveal edge cases and guide design.

Explore the design phase after requirements by developing conceptual designs with mockups and CRC cards, and technical diagrams such as class, package, deployment, activity, and sequence diagrams.

Identify components, connections, and responsibilities from requirements, translate them into conceptual mock-ups and wireframes, and discuss with clients using diagrams and CRC cards to lay the foundation for software architecture.

Learn and apply crc cards, a conceptual design technique that records classes, assigns responsibilities, and identifies collaborators to refine software architecture, with e-commerce examples.

Turn conceptual designs into technical design by breaking large components into smaller parts with a single responsibility. Use technical diagrams to remove ambiguity and coordinate structure and behavior before coding.

Embrace compromise between client desires and technical constraints to design scalable systems. Balance performance, maintainability, and security by modular design and early revision to enable feasible, reusable components.

Balance quality attributes in software design by weighing performance, security, and convenience. Consider context, from public chaos to corporate fortress, and prototype to reveal trade-offs and avoid consequences.

Explore how functional requirements define end user tasks such as playing a song, downloading a file, and creating a playlist, while non-functional requirements govern performance, speed, security, and usability.

Design object oriented models by translating requirements into a flexible, maintainable system using entity, control, and boundary objects, guided by abstraction, encapsulation, decomposition, and generalization.

Explore abstraction in object-oriented design, focusing on essential attributes and behaviors, context dependent, with live Java code examples and practical illustrations from cars, ATMs, and e-commerce.

Demonstrate implementing abstraction in Java by defining an abstract class with an abstract sound method, extending it with cat and dog subclasses, and overriding sound to run from main.

Encapsulate data and behaviors into a class, exposing only parts through interfaces. Protect sensitive data, reduce complexity, and keep objects modular, secure, and easy to modify.

Master encapsulation in Java with live code demonstrations, creating a private balance field and public getters and setters to safely manage deposits and withdrawals.

Decomposition breaks a system into smaller parts, assigns each part a single responsibility, and defines interfaces to connect them into a secure, maintainable, and scalable architecture.

Explore how decomposition makes the system more maintainable and scalable by splitting the microwave oven into independent parts and reducing repetition, avoiding god classes.

Generalization reduces redundancy by factoring common attributes and behaviors into a base class and using inheritance to reuse code across subclasses, as shown in university example with lecturer and student.

Generalization in Java demonstrates how to minimize code duplication by extracting common attributes and behaviors into a general student class and inheriting into undergraduate, graduate, and diploma classes.

Explore inheritance and generalization in Java, where a general superclass like vehicle provides shared attributes and methods to a subclass such as car via extends, with constructors and method overriding.

Explore Java interfaces as contracts that define behavior with only method signatures, enabling multiple inheritance-like flexibility, polymorphism, and consistent implementation across classes through the implements keyword.

Explore how to translate conceptual CRC card design into UML class diagrams and Java code, using abstraction, encapsulation, and decomposition with association, aggregation, and composition.

Explore the UML sequence diagram as a tool for modeling time-based interactions with lifelines, activations, and messages, illustrated by real-world examples like restaurants and television remote controls.

Explore how UML state diagrams model object behavior by showing states and transitions driven by events, with starting points, state variables, and entry/do/exit activities; illustrated by vending machines and cars.

Identify essential complexity as the inherent difficulty from real-world rules and user needs. Distinguish it from accidental complexity caused by tools, then reduce it with better languages and design practices.

Evaluate design complexity by keeping modules simple, each with one clear job, to reduce bugs and enable low coupling and high cohesion across the system.

Learn how coupling and cohesion shape software design: aim for low coupling and high cohesion to keep modules independent, testable, and flexible, while avoiding tight coupling and multi-purpose modules.

Explore information hiding through encapsulation by exposing only what a module must reveal and hiding changing algorithms behind stable interfaces. Use private fields and APIs to protect core logic.

Apply the decomposition principle to determine when to use inheritance versus composition, ensuring true specialization and adherence to the Liskov substitution principle.

Explore separation of concerns through system decomposition, creating modular, reusable components like call, camera, and power modules, to maintain high cohesion and flexible, scalable software.

Emphasize conceptual integrity to create a system that feels designed by one mind. Maintain consistency in names, patterns, architectures, and rules to reduce mental effort and enable scalable software.

Discover model checking, a verification technique that explores all possible system states to uncover deadlocks and unsafe scenarios, using modeling, running, and analysis phases to guarantee correct behavior.

Identify essential complexities, avoid accidental complexity, and design for maintainability and modularity using solid principles such as single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion.

Apply the single responsibility principle to keep classes focused, reducing changes and bugs. Learn through live code examples that split file processing, error handling, and logging for clean architecture.

Explore the open closed principle (OCP) within software architecture, showing how to extend behavior without modifying existing code, with Java examples of tag post and mention post.

Apply the Liskov substitution principle to ensure subtypes replace supertypes without breaking programs, highlighting inheritance, polymorphism, and robust design while illustrating user and payment method hierarchies and violations.

Apply the interface segregation principle by splitting fat interfaces into smaller, specific interfaces, ensuring clients implement only requested methods and achieving flexible, maintainable, scalable software.

Apply the dependency inversion principle by ensuring high-level modules depend on abstractions, not concrete low-level implementations; use interfaces to swap payment methods or databases without modifying core logic.

Explore what design patterns are and why they matter, and learn how observer, singleton, factory, strategy, and decorator patterns provide proven, reusable solutions for scalable, maintainable software.

Design patterns act as proven recipes to create reliable, maintainable software. Live Java examples show how to choose and combine patterns like factory, observer, and strategy for real problems.

Explore how design patterns provide expert-tested solutions, a shared vocabulary, and flexible, reusable architectures; learn when to apply patterns like factory, observer, and strategy to avoid reinventing the wheel.

Explore the origin of design patterns from the gang of four and the elements of reusable object-oriented software, applying their catalog and pattern language to build maintainable software.

Explore the three main categories of design patterns—creational, structural, and behavioral—and learn how patterns like singleton, adapter, observer, and strategy guide scalable, maintainable object creation and collaboration.

Learn the singleton design pattern, a creational pattern ensuring one globally accessible instance to prevent conflicts, with lazy creation, private constructors, and use cases like preferences and logging.

Explore the singleton design pattern in Java with a live code example, using a private constructor and static getInstance to ensure a single setting instance (font size and theme).

Explore the factory design pattern, a creational approach that separates object creation from business logic, with simple factory, factory method, and abstract factory, illustrated by a knife store example.

Explore the simple factory pattern by creating specific knife objects (chef knife, stick knife) through a KnifeFactory, moving object creation from order logic to a dedicated factory.

Explore the simple factory pattern in Java with a static factory method that returns Knife implementations (Shift Knife and Stick Knife) implementing identify, sharpening, and packaging, with downloadable code.

Explore the factory method pattern, contrasting it with the simple factory, using an interface knife factory where concrete factories decide which low or high budget knives to instantiate.

The lecture demonstrates a Java factory method with budget and naive types, guiding object creation via high or low budget factories and chef or stick naive implementations.

Understand the abstract factory method, which creates families of objects like high and low budget sheaths for knives via an interface, centralizing changes and reducing redundant creation.

Explore the abstract factory pattern in Java with a live code example that creates knives and sheets, selecting low or high budget factories.

Explore how the facade design pattern provides a single simplified interface to a complex subsystem, delegating heavy work behind the scenes to make systems easier to use.

Explore the facade design pattern, where a facade class hides subsystem complexity, reduces coupling, and provides a simplified interface, while noting limits on full functionality and potential maintenance burden.

Implement the facade design pattern in Java by wrapping saving, current, and checking accounts behind a single facade that handles create, deposit, withdraw, and check balance through iAccount.

The adopter design pattern acts as a bridge between legacy or third-party systems and your code, translating requests via adopter, adoptee, and a target interface.

Explore the adapter design pattern with a live Java code example that bridges a legacy media player to a modern media player, implementing play, pause, and play with 2x.

Learn how the composite design pattern enables leaf and composite objects to be treated uniformly via a common interface, supporting recursive composition and tree-like structures such as folders and files.

Explore the composite design pattern in Java by implementing a revenue component interface, concrete employee and department classes, and aggregating salaries to show details and total revenue.

Explore how the proxy design pattern uses a lightweight proxy to control access to heavy or remote objects, validating requests before delegating to the real subject.

Explore the proxy design pattern in Java through three scenarios: lazy loading of heavy images, proxy routing remote warehouse orders by location, and role-based access control on a secure server.

Explore the decorator design pattern, wrapping a base object with authentication, authorization, and caching at runtime to avoid inheritance explosion and enable modular, open for extension design.

learn how to implement the decorator design pattern in Java by wrapping an existing object to add authentication, logging, authorization, and other features at runtime without changing the original class.

Explore the template design pattern and how the template method enforces a fixed execution order: load data, pre-processed data, build model, train, evaluate, via abstract steps in subclasses.

Demonstrates the template design pattern in Java by enforcing a fixed sequence in an AI model trainer: load data, pre-processed data, build model, train model, evaluate model, and save model.

Explore the chain of responsibility design pattern, a behavioral pattern in which a request passes through a chain of handler objects until one processes it, decoupling sender from receiver.

Watch a live Java implementation of the chain of responsibility pattern, where managers, directors, and a CEO forward requests based on amount thresholds to grant or reject budgets.

Explain the state design pattern, where an object changes states like idle and dispensing via specific methods. Illustrate a vending machine example with UML and Java code.

Demonstrates implementing the state design pattern in Java with a vending machine, using a vending state interface and concrete states for no coin, has coin, dispense, and sold out.

Explore the command design pattern, a behavioral pattern that decouples sender and receiver, using invoker and command objects to queue, undo, and redo actions in software with two queues.

Implement the command design pattern in Java. Create a command interface with execute and unexecute, a concrete command with a receiver, and an invoker to set, execute, and undo.

The observer design pattern links a subject with observers, notifying updates when changes occur; subscribe or unsubscribe flows apply to blogs and social media platforms.

Learn how to implement the observer design pattern in Java, with interfaces for Observer and Subject, a blog example, and live code showing registration, notification, and state updates.

Explore the strategy design pattern, a behavioral approach that encapsulates multiple routing algorithms as interchangeable strategies and swaps them at runtime to compute fastest, shortest, and walking routes.

Live Java code implements the strategy design pattern with concrete payment strategies: credit card payment, PayPal, Google payment, and crypto payment, and a runtime switchable payment processor.

Explore composing objects to reduce coupling and favor has-a relationships over inheritance for flexible, maintainable systems. Use delegation and patterns like composite and decorator to change behavior at runtime.

Apply the principle of least knowledge, the law of Demeter, to reduce coupling by ensuring methods interact only with their own class, parameters, and instance variables, improving maintainability and reusability.

Law of Demeter with live Java code, showing four rules for method calls and common violations like chained calls and tight coupling.