What is software architecture?

• Software Architect Handbook
  • General Concerns
    • About Architecture
    • About Engineering
  • Design Principles
  • Refactoring
  • Programming Paradigms
    • Structured
    • OOP: Object Oriented Programming
    • Functional
  • Design Patterns
    • Base Patterns
    • General / Architectural
    • Gang of Four Patterns
    • Domain Logic
    • Data Source & Persistence
    • Object Relational
      • Behavioral
      • Structural
      • Metadata Mapping
    • Web Presentation
    • Distribution
    • Offline Concurrency
    • Session State
    • Anti-Patterns
  • Types of Software
  • System Design
    • System Design - Case Studies
  • Architectural Styles & Patterns
    • Three-Layer System (Martin Fowler)
    • Service Oriented Architecture (SOA)
    • Ports & Adapters / Hexagonal
    • Clean Architecture
    • REST: Representational State Transfer
    • Flux & Redux
    • Domain-Driven Design
    • Microservices
  • Data Storage
    • Data Consistency
    • Data partitioning
    • Relational Databases
    • Wide-column store
    • GraphQL
  • Technology specifics
  • Operating Systems
    • Linux
  • Data Science & Big Data
  • Software Engineering Culture
    • Laws & Theorems
    • Working Methodologies
  • Testing
    • E2E Testing
  • Frontend
  • Glossary
  • Tooling - Language Agnostic
  • Z-Index, other repositories

• What is Software Architecture?
• The Software Architect
• The First Derivative
• Evolutionary Design
• Development Overconfidence
• Is Quality Worth the Cost?

• Concurrency
• Developer Struggle
• Distribution Strategies
• Layering
• Mapping to Relational Databases
• Organizing Domain Logic
• Resilience vs Robustness
• Session State
• Technical Debt

• Common Architectural Principles
• OOP Principles
• OO Design Principles
  • Encapsulate what varies
  • Program to an interface, not an implementation
  • Favor object composition over class inheritance
  • Strive for loosely coupled designs between objects that interact
  • Least Knowledge
• DRY
• GRASP
• Hollywood Principle
• SOLID
  • Single Responsibility Principle
  • Open Closed Principle
  • Liskov Substitution Principle
  • Interface Segregation Principle
  • Dependency Inversion Principle
• KISS
• WET
• YAGNI

• Code Smell
• Refactoring Guru

• Imperative and Procedural
• Declarative

• Functional Decomposition
• Structured Tests

• OOP Introduction
  • Objects and Classes
  • Class-based vs Prototype-based languages
• Foundational concepts
  • 4 Pillars of OOP
    • Abstraction
    • Inheritance
    • Encapsulation
    • Polymorphism
  • Abstract Class
  • Mixin Class
  • Traits
  • Interface & Type
• Techniques
  • Subtyping: Interface Inheritance
  • Composition, Aggregation and Delegation
    • Composition vs Inheritance
  • Parameterized Types
  • Dynamic Dispatch / Message Passing
  • OMT Notation & UML
• Advanced concepts
  • Object-Oriented Design Principles
  • Gamma Design Patterns
  • The Power of Polymorphism: Dependency Inversion
  • Prototypal vs Classical Inheritance

• Referentially Transparent (No Side Effects)
• Immutability
• Idempotence

What is a design pattern?

• Gateway
• Mapper
• Layer Supertype
• Separated Interface
• Registry
• Value Object
  • Money
• Special Case
• Plugin
• Service Stub
• Record Set

• Event Sourcing
• CQRS: Command and Query Responsibility Segregation
• Saga: distributed transactions

Please check the this repository for a detailed explanation and examples of each of the following patterns.

• Transaction Script
• Domain Model
• Table Module
• Service Layer

• DAO: Data Access Object
• Active Record
• Data Mapper
• Table Data Gateway
• Row Data Gateway
• Repository

• Unit of Work
• Identity Map
• Lazy Load

• Identity Field
• Foreign Key Mapping
• Association Table Mapping
• Dependent Mapping
• Embedded Value / Aggregate Mapping
• Serializd LOB
• Single Table Inheritance
• Class Table Inheritance / Root-Leaf Mapping
• Concrete Table Inheritance
• Inheritance Mappers

• Metadata Mapping
• Query Object
• Repository

• Application Model / Presentation Model
• Humble View / Passive View
• MVC: Model View Controller
• MVP: Model View Presenter
• MVVM: Model View View-Model
• Front Controller
• Page Controller
• Supervising Controller
• Template View
• Transform View
• Two Step View

• Remote Facade
• Data Transfer Object

• Optimistic Offline Lock
• Pessimistic Offline Lock
• Coarse-Grained Lock

• Client Session State
• Server Session State
• Database Session State

What is an Anti-Pattern?

• Abstraction Inversion

Altouhgh some techniques and patterns are relevant for all kinds of software, many are relevant for only one particular branch.

• Enterprise Applications
  • EAPPs Challenges
  • Kinds of EAPPs

For a complete System Design study, you should also be familiar with Databases related topics such as CAP Theorem.

• Introduction
• Where to start
• Performance Measures
  • Response time
  • Responsiveness
  • Latency
  • Throughput
  • Load
  • Load sensitivity
  • Capacity
  • Scalability
• Sustainability
• Scalability
  • Vertical Scaling (scale up/down)
  • Horizontal Scaling (scale out/in)
• Load Balancing
• Caching
• RAID
• Consistency
• Availability
  • Fail-over
  • Replication
• Choosing a Database
• CDN: Content Delivery Network
• Stateless web tier
• Multi-data center
• Message Queue/Message Broker
  • Kafka
• Logging, metrics, automation
• Scaling from zero to millions of users
• Back-of-the-envelope Estimation
• A Framework for System Design Interviews
• Hashing
  • The rehashing problem
  • Consistent hashing

Recommended book: https://en.wikipedia.org/wiki/Pattern-Oriented_Software_Architecture

• Three Fundamental Layers
• Narratives summary
• Other layering schemes

• MVC and Hexagonal Architectures as Precursors
• MVC Problems
• Tradeoffs
• What is Architecture
• Keeping options open
• Plugin Architecture - Model Controller Presenter (MCP)
• Request and Response Models
• Screaming Architecture
• Testable Architecture
• Humble Object Pattern
• Services and boundaries
• Test Boundaries
• The Fragile Tests Problem
• Code organization
  • Package by layer
  • Package by feature
  • Package by component
• Target Hardware Bottleneck
• The Missing Advice
• Glossary
  • Details
  • Stable Abstractions Rule
  • Components
    • Concrete Components
    • Component Principles
      • Component Cohesion
        • Reuse/Release Equivalence Principle
        • Common Closure Principle
        • Common Reuse Principle
      • Component Coupling
        • Acyclic Dependencies Principle
        • Stable Dependencies Principle
        • Stable Abstractions Principle
  • Stability
  • Boundaries
  • Objects
    • Entities
    • Use Cases
    • Interactor
    • Interface Adapters
    • Presenter and View
    • Database Gateways
    • Main Component
  • Policy
  • Business Rules
  • Dependency Rule

Recommended reference: restfulapi.net

• Introduction
• History
• Architectural Properties
  • Stateless vs Stateful
• Architectural Constraints
• Five key principles
• Semantics of HTTP APIs

• What the flux?! Let's Redux
• Facebook's MVC Comparison

Overview

• Aggregate
• Bounded Context

Overview

• Benefits and alternatives
• Coupling and Cohesion
• Own their data
• DDD - Mapping aggregates and bounded contexts
• Monolith
• Planning a Migration
• Splitting the Monolith
  • Strangler Fig Application
  • UI Composition
  • Branch by Abstraction
  • Parallel Run
  • Decorating Collaborator
  • Change Data Capture
• Decomposing the Database
  • Shared Database
  • Database View
  • Database Wrapping Service
  • Database-as-a-Service Interface
  • Aggregate Exposing Monolith
  • Change Data Ownership
  • Synchronize Data in Application
  • Tracer Write
• Splitting Apart the Database
  • Split the Database First
    • Repository per Bounded Context
    • Database per Bounded Context
  • Split the Code First
    • Monolith as Data Access Layer
    • Multischema Storage
  • Schema Separation
    • Split Table
    • Move Foreign-Key Relationship to Code
  • Shared Static Data
  • Dealing with Transactions
    • Sagas
• Growing Pains
• Trade-Offs
• When to avoid

Tools

• CAP/Brewer's Theorem

• BASE

• Object-oriented databases

• Database Scaling

  • Vertical Scaling (Scaling Up)
  • Horizontal Scaling (Sharding)

• Data Replication

• Consistency Models

  • Strong Consistency vs Weak Consistency
  • Eventual Consistency
  • Strong Eventual Consistency (SEC)

• Synchronization techniques

  • Quorum consensus

• Handling failures

  • Failure detection
    • All-to-all multicasting
    • Gossip protocol
  • Handling temporary failures
    • Sloppy quorum
    • Hinted handoff
  • Handling performance failures
    • Anti-entropy protocol
  • Handling data center outage

• Data consistency primer
• Strong consistency
• Eventual consistency
• Inconsistency resolution
  • Versioning

• Data partitionioning primer
• Horizontal partitioning (sharding)
  • Consistent hashing
• Vertical partitioning
• Fuctional partitioning

• ACID: Atomicity, Consistency, Isolation, Durability
• Isolation Levels
• Transactions
• Read Phenomena
• 2PC Protocol / XA Transactions
• Views
• Joins
• Stored Procedures
• Indexing
• ORM: Object-relational Mapping
• Object-relational impedance mismatch

• Overview
• HBase
  • Overview
  • Vs Relational Databases
  • Architectural Components
  • Write Mechanism
  • Interacting with Shell
  • ACID in HBase
  • HBase Shell Interaction
  • HBase Interaction
  • HBase for Java Developers

• Overview
• Why use GraphQL?

Specifics that should be considered while developing a software solution relying on a particular technology.

• Golang Handbook
• Go In Practice
• Java Handbook
• JS Handbook
• React
  • Thinking in React
• Redux
  • When and when not to reach for Redux
  • Redux must know
  • Three Fundamental Principles
  • Best Practices
  • Reducers: Immutable Update Patterns
  • Redux Ecosystem Links
  • Flux Comparison
  • MVC Comparison

• Multithreading
• Parallelism & Concurrency
• Process & Thread
• Models of Computation
  • Finite State Machine

• Core principles
• Components
• File system

• Batch Processing
• ETL

• Unix Philosophy
• Software Engineering at Google
• Success stories
• Quotes

• 80/20 Rule
• Beyoncé Rule: If you liked it, put a CI test
• Churn Rule: Teams should internalize deprecation
• Constantine's law: Favor high cohesion
• Conway's law: Systems reflect organization's communication structure
• Hyrum's Law: The Law of Implicit Dependencies
• Occam's Razor: The simplest explanation
• Pareto principle: The 80/20 rule

• XP: Extreme Programming

• Anti Patterns
• Best Practices

Frontend developer roadmap.

• Atomic design
• Design system
• Legacy lifecycle of frontend
• Areas of frontend
  • Backbone goals and OKRs
• Accessibility testing
• CSR vs SSR

• Abstract Syntax Tree
• CRUD
• First-class citizen
• Leaky Abstraction
• Modularization
• Side Effect
• SPOF: Single Point of Failure
• Web API

• Telepresence: tool that is aiming to make a hybrid local/remote developer workflow easier for Kubernetes users.
• Pact: customer-driven contracts.

• Cybersecurity Handbook
  • Networking
  • Telecommunications
  • Encryption
  • etc.