Software Architecture and Clean Code Design in OOP

From this lecture you will learn:

• What are SOLID principles

• SOLID principles in OOP

• Single responsibility principle

From this lecture you will learn:

• Open / closed principle

• Code examples

From this lecture you will learn:

• Liskov substitution principle

• Code examples

From this lecture you will learn:

• Interface segregation principle

• Code examples

From this lecture you will learn:

• Dependency inversion principle

• Code examples

The Quiz covers content from the following lessons:

• SOLID principles overview & Single Responsibility Principle

• Open / Closed principle

• Liskov substitution principle

• Interface segregation principle

• Dependency inversion principle

• What is a clean architecture

• What is a coupling

• Types of a coupling

• What is a cohesion

• Types of a cohesion

• Benefits of Clean Architecture

• Plugin concept

• Why do we need clean architecture

• Advantages and disadvantages of clean architecture

• Tell, don’t ask principle

• How to apply ‘Tell don’t ask’ in real life

• What is data structures

• Objects VS Data structures

• Getters and Setters in objects

• When to use data structures

• What is Law of Demeter

• Goals

• Exception from law

• Pros & Cons

• Code Examples

• KISS Principle - Definition

• Variants of KISS in Software Development

• Key Concepts of KISS

• Why Use KISS Principle / Benefits

• How to Apply KISS Principle

• Case Studies of KISS Principle

• Code Examples of KISS Principle

• YAGNI Principle - Definition

• Why Use YAGNI Principle / Benefits

• How to Apply YAGNI

• Case Studies of YAGNI Principle

• Code Examples of YAGNI Principle

• YAGNI Principle VS KISS Principle - Key Differences

• DRY Principle - Definition

• Why Use DRY Principle / Benefits

• How to Apply DRY

• Contrasting Concepts - WET & AHA

• Case Studies of DRY Principle

• Code Examples of DRY Principle

• Problem statement

• Why do we need a good structure

• How to establish good code structure

• Factors to consider during the code grouping

• Cohesion Principles

• Common closure principle

• Common reuse principle

• Reuse-release equivalence principle

• Coupling principles

• Acyclic dependencies principle

• Stable dependencies principle

• Stable abstractions principle

• Package by layer

• Package by feature

• Conway's law

• How technical factors impact code structure

• Tools for code analysis

• What GRASP Is

• Purpose of GRASP in OOP and Architecture

• GRASP vs SOLID

• GRASP vs Design Patterns

• GRASP and UML

• When GRASP Provides Maximum Value

• Typical Misconceptions About GRASP

• Summary and Lesson Transition

• Introduction to the Information Expert Principle

• Core Idea: Assigning Responsibilities Based on Domain Data

• Identifying True Experts in a Domain Model

• Conflicts Between Information Expert and Low Coupling

• Anti-Patterns: Fake Experts and Misused Data Classes

• Practical Example: Applying the Information Expert Principle

  • Anti-Patterns demo

  • Information Expert in action demo

• Introduction to the Creator Principle

• Rules for Assigning Object Creation Responsibility

• Linking Creator with Information Expert

• When to Avoid Creator (Factory vs Domain Rules)

• Common Mistakes with Creator

• Practical Example: Applying the Creator Principle

  • Anti-Patterns demo

  • Creator Principle in action demo

• Introduction to the Controller Principle

• Types of Controllers: Façade Controller vs Use Case Controller

• Mapping System Events to Controllers

• Avoiding Bloated Controllers and the God Class Anti-Pattern

• When Not to Use a Controller

• Practical Example: Applying the Controller Principle

• Introduction to Low Coupling

• Techniques for Reducing Coupling

• Coupling Metrics and Red Flags

• Low Coupling vs Performance Trade-Offs

• Relationship with Patterns: Adapter, Facade

• Practical Example: Identifying and Reducing Coupling

• Introduction to High Cohesion

• Identifying Cohesive Responsibilities

• Splitting Responsibilities in Feature Rich Classes

• Cohesion Metrics: Understanding LCOM Basics

• Anti-Patterns: Utility Classes and Swiss Army Knife Classes

• Practical Example: Improving Cohesion in Real Code

• Introduction to Polymorphism

• When to Replace Conditionals with Polymorphism

• Using Interfaces and Abstract Classes in GRASP

• Linking Polymorphism with Strategy and State Patterns

• Pitfalls of Polymorphism

• Practical Example: Refactoring Conditionals into Polymorphism

• Introduction to Pure Fabrication

• When Domain Model Entities Should Not Take Responsibility

• Service Objects, Repositories, Managers – Allowed or Not

• Balancing Pure Fabrication vs Cohesion

• Typical Mistake: Moving All Logic to Services

• Practical Example: Applying Pure Fabrication Correctly

• Introduction to Indirection

• How Indirection Reduces Coupling

• Common Use Cases for Indirection

• Indirection in Event Bus, Mediator, and Controller Layers

• When Indirection Becomes Too Much

• Patterns That Rely on Indirection: Observer and Mediator

• Practical Example: Applying Indirection in System Design

• Introduction to Protected Variations

• Identifying Unstable Points in a System

• Protecting Variations with Interfaces and Abstractions

• Adapters and Anti Corruption Layers

• Aligning Protected Variations with Dependency Inversion

• Real World Examples of Protected Variations by Domain

• Practical Example: Protecting a System from Change

• Introduction: Why GRASP Patterns Must Be Considered Together

• Conflicts Between GRASP Patterns: Information Expert vs Low Coupling

• Synergies Between GRASP Patterns: Polymorphism and Protected Variations

• How the Controller Pattern Impacts Cohesion and Coupling

• Understanding Trade offs Between Competing GRASP Principles

• Choosing the Dominant Pattern in Design Decisions

• Practical Guidelines for Balancing GRASP Patterns in Real Systems

• Introduction: GRASP Across Architectural Layers

• Applying GRASP in the Domain Layer

• Applying GRASP in the Application Layer

• Applying GRASP in the Infrastructure Layer

• Where GRASP Does Not Apply

• Common Misunderstandings When Applying GRASP by Layer

• Practical Guidelines for Using GRASP in Layered Architectures

• Introduction: Why Compare GRASP, SOLID, and GoF

• What Problems GRASP Solves

• What Problems SOLID Solves

• What Problems GoF Design Patterns Solve

• Why GRASP Is Earlier and More Foundational

• How GRASP Influences SOLID Principles

• Mapping GRASP to SOLID and GoF Patterns

• Why do we need design patterns

• What are GoF patterns

• Key points of GoF patterns

• Creational Patterns: Overview

• Structural Patterns: Overview

• Behavioral Patterns: Overview

• Class & Object Patterns

• What patterns we are going to learn in this course

• Answers to most common questions of my students

• Singleton

• Prototype

• Factory Method

• Builder

• Abstract Factory

• Factory Method VS Abstract Factory

• Proxy

• Decorator

• Adapter

• Façade

• Comparative Analysis

• Bridge

• Flyweight

• Composite

• Strategy Pattern

• Command Pattern

• Strategy VS Command

• Template Method

• Iterator

• Chain of responsibility

• Visitor

• Visitor VS Decorator

• State

• Observer

• Memento

• Interpreter

• Mediator

• Why This Course Exists

• What SOA Means Today (Not the SOAP Era)

• Why Event Driven Architecture Became the Default

• SOA, EDA, and Microservices - Clarifying the Relationship

• Course Structure and Learning Approach

• Sample Domain Overview

• Practical Walkthrough: High-Level Architecture

• Common Anti-Patterns to Watch For

• Lesson Summary and Transition

• What a Service Really Is

• Service Boundaries and Responsibility

• Ownership: Data, Behavior, and Lifecycle

• Contracts as the Real API

• High Cohesion Inside, Low Coupling Outside

• Practical Example: Boundary Discovery

• Practical Example: Plain Java Implementation

• Common Boundary and Contract Anti-Patterns

• Service Autonomy as a Non Negotiable Principle

• Control of Data and State

• Stateless vs Stateful Services - What Actually Matters

• Idempotency in Distributed Systems

• Safe Retries and Failure Scenarios

• Service Contract Versioning Principles

• Practical Example: Designing a Stable Service Contract

• Practical Example: Contract Evolution and Versioning

• Common SOA Design Anti Patterns

• Why Communication Style Is an Architectural Decision

• Request/Response Communication

• Asynchronous Messaging Fundamentals

• Latency, Availability, and Cascading Failures

• Tradeoffs Between Sync and Async

• Choosing Communication Per Use Case

• Practical Example: Synchronous Flow Analysis

• Practical Example: Refactoring to Async Event Flow

• Common Communication Anti Patterns

• Why Event Driven Architecture Exists

• Events as Facts, Not Commands

• Domain Events

• Integration Events

• Domain Events vs Integration Events

• Event Granularity

• Event Naming Conventions

• Event Schema Basics

• Practical Example: Defining Domain Events

• Practical Example: Mapping to Integration Events

• Common EDA Anti Patterns

• Why Delivery Guarantees Matter in Event Driven Systems

• Delivery Semantics Explained

• The Reality of Event Delivery

• Consumer Responsibility in Event Driven Systems

• Idempotency as the Core Consumer Pattern

• Retry Strategies and Failure Handling

• Dead Letter Queues and Poison Messages

• Practical Example: Idempotent Consumer Design

• Practical Example: Failure Scenarios Walkthrough

• Common Anti Patterns in Delivery Handling

• Why Coordination Style Matters

• Event Choreography Fundamentals

• Hidden Traps of Event Choreography

• Orchestration Fundamentals

• Tradeoffs: Choreography vs Orchestration

• Avoiding the Distributed Big Ball of Mud

• Choosing the Right Model Per Business Flow

• Practical Example: Business Flow with Event Choreography

• Practical Example: Business Flow with Orchestration

• Comparison and Architectural Takeaways

• Common Coordination Anti Patterns

• Why Event Contracts Matter

• Understanding Compatibility

• Safe Schema Evolution

• Versioning Strategies

• Anti Patterns in Event Versioning

• Compatibility Testing Mindset

• Practical Example: Schema Evolution Walkthrough

• Architectural Takeaways

• Why Consistency Becomes a Problem in Distributed Systems

• Why Distributed Transactions Don’t Scale

• Eventual Consistency Explained

• Eventual Consistency in Real Business Scenarios

• Sagas: The Core Pattern for Business Transactions

• Saga Variants

• Compensations and Business Reversals

• Failure Scenarios in Sagas

• Practical Example: Order Payment Shipping Saga

• Plain Java Implementation Overview

• Common Anti Patterns in Business Transactions

• Why Dual Write Breaks Systems

• Outbox Pattern: Concept and Benefits

• Polling vs Transactional Outbox

• Practical Example: Outbox Simulation

• Architectural Takeaways

• Event Notification vs Event Carried State Transfer

• Change Data Capture (CDC) as an Integration Approach

• Anti Corruption Layer for Integrations

• Practical Example: Introducing an Anti Corruption Layer

• Shared Database Across Services

• Chatty Services and Synchronous Chains

• God Events and Event Dumping

• Tight Coupling via Shared Libraries and Shared Models

• Practical Example: Refactoring a Broken Design

• Architectural Takeaways

• Why Observability Is Hard in Event Driven Architectures

• Traceability Across Asynchronous Flows

• Correlation IDs and Causation IDs

• Observability Tooling in Java and Spring Boot

• Tracing Event Driven Systems with OpenTelemetry

• Monitoring Consumers and Event Lag

• Operational Anti Patterns in Event Systems

• Architectural Takeaways

• Why Security Is Different in Event Driven Systems

• Trust Boundaries Between Services

• Authentication and Authorization in Messaging Systems

• Authorization of Event Consumption

• Event Payload Minimization

• Handling Sensitive Data in Event Driven Architectures

• Secure Lookup Pattern

• Common Security Anti Patterns in Messaging

• Architectural Takeaways

From this lecture you will learn:
• What is TDD

• TDD Cycle - main steps of TDD iteration

• Three laws of TDD

• Test-first approach VS TDD

• Testing pyramid and TDD

• Defect cost increase

• Pros of using TDD

From this lecture you will learn:

• BDD and its history.

• TDD VS BDD

• Gherkin DSL

• How to create BDD scenarios

• How to apply BDD knowledge on practice for software developer

• Advantages and Disadvantages of BDD

• Acceptance test-driven development

• ATTD VS TDD VS BDD

In this lesson we will implement application with the help of TDD approach.

• Why we need databases

• Purposes & Advantages of databases

• Database VS DBMS

• Types of databases

• Relational databases

• Non-Relational databases

• Examples of relational, NoSQL and other databases

• Document-oriented databases

• Key-value storages

• Graph databases

• Wide column databases

• Object-oriented databases

• Hierarchical databases

• Time series databases

• Column-oriented databases

• Cloud databases

• Centralized and Distributed Databases

• Pros and cons of different types of database

• Overview of the most popular relational database management systems

• MySQL Overview

• Main Features of MySQL

• MySQL Server installation

• MySQL Workbench Installation

• MySQL Shell installation

• Creation of root user in MySQL

• Connecting MySQL Server to MySQL Workbench

• Windows Service for MySQL

• Basic terms (table, entity, attribute, tuple, record, etc)

• Database VS Schema

• Primary key

• How to choose primary key

• Simple VS compound primary key

• Natural VS surrogate primary key

• Alternate key

• Foreign key

• Relationship

• Types of relationships

• One-to-many relationship

• Many-to-many relationship

• One-to-one relationship

• MySQL Workbench interface

• Create schema

• Naming convention

• Character set

• Collation

• Create table

• Singular VS Plural for table names

• MySQL Storage Engines

• Which storage engine to choose

• Data types

• Column Properties

• Data model

• Database model

• Why data modelling is important

• Database design

• Data context

• Conceptual data model

• Logical data model

• Physical data model

• Referential Integrity

• Consequences of broken referential integrity

• Cascade Operations

• Foreign key constraint

• Remove foreign key constraint

• Data consistency

• Data integrity

• Data quality

• Data validity

• What are indexes

• Lookup table

• Why we need indexes

• What does indexing do

• Index types

• Primary index (dense and sparse)

• Secondary index

• Clustering index

• Multilevel index

• B-tree

• How to create and remove indexes in database

• Advantages of indexing

• Disadvantages of indexing

• Data Anomalies

• Insertion anomaly

• Update anomaly

• Deletion anomaly

• Dependency theory

• Normalization

• Normal forms with Examples

• Denormalization

• Problem statement

• What is DAO pattern

• DAO pattern elements

• DAO pattern sequence diagram

• What is DTO

• DAO live demo example

• MVC Pattern: Overview

• Controller

• Model

• View

• Advantages and Disadvantages

• MVC code examples

• Layered Architecture overview

• Why we need Layered Architecture

• Closed Layer concept

• Layers of Isolation

• Open Layer concept

• Code example of Layered Architecture

• Sinkhole anti-pattern

• Layered Architecture and Monolithic Architecture

• Advantages and Disadvantages of Layered Architecture