Software Engineering Study Notes

Adapter and Decorator Patterns

See how Adapter bridges incompatible interfaces and how Decorator adds behavior to objects dynamically without subclassing.

Agile and Scrum

An introduction to the Agile Manifesto's core values and the Scrum framework's roles, ceremonies, and artifacts.

API Design Basics

Covers REST principles, resource-oriented URLs, HTTP verbs mapped to CRUD, statelessness, and accurate use of HTTP status codes.

Branching Strategies

Compare Git Flow, GitHub Flow, and trunk-based development to choose the right branching model for your team.

Builder and Prototype Patterns

Understand how Builder constructs complex objects step by step and how Prototype creates new objects by cloning existing ones.

CI/CD Basics

Understand Continuous Integration, Continuous Delivery, and Continuous Deployment, and how a typical pipeline works.

Classes and Objects

How classes act as blueprints for objects, and the difference between class attributes and instance attributes.

Code Quality and Refactoring

Learn how to measure code quality and use refactoring to improve internal structure without changing external behavior.

Code Review Best Practices

Practical techniques for writing reviewable pull requests and giving constructive, effective code review feedback.

Common Software Engineering Pitfalls

Frequent mistakes and misconceptions engineers make, framed as questions you might face and how to avoid them.

Dependency Inversion

Distinguish the Dependency Inversion Principle from Dependency Injection and apply constructor injection against an abstraction.

Design Patterns Overview

An introduction to the Gang of Four design patterns and their three categories: Creational, Structural, and Behavioral.

Encapsulation

How Python conventions for protected and private attributes, plus properties, let classes control access to their internal state.

Facade and Proxy Patterns

Learn how Facade simplifies access to a complex subsystem and how Proxy controls access to another object via a shared interface.

Git Fundamentals

Learn Git's three-tree model and the core commands for tracking, staging, and committing changes.

Inheritance

How single inheritance, `super().__init__()`, and method overriding let subclasses reuse and specialize parent class behavior.

Integration and System Testing

Understand how integration testing checks components working together and system testing validates the whole application end-to-end.

Liskov Substitution and Interface Segregation

Understand why subtypes must honor their base type's contract and why fat interfaces should be split into focused ones.

Mocking and Test Doubles

Learn the five canonical test double types—dummy, stub, spy, mock, and fake—and how to use unittest.mock in Python.

Monolith vs Microservices

Compares monolithic and microservices architectures across deployment, scaling, communication, complexity, and failure isolation.

MVC Architecture Pattern

An architectural pattern that separates an application into Model (data), View (presentation), and Controller (input mediation) layers.

Observer Pattern

A behavioral pattern where a subject maintains a list of observers and notifies them automatically of any state changes.

OOP Core Concepts

An introduction to the four pillars of object-oriented programming: encapsulation, abstraction, inheritance, and polymorphism.

Polymorphism and Abstraction

Distinguishing polymorphism (same interface, different implementations) from abstraction (hiding implementation details) using Python's abc module.