Software Architecture – Cheat Sheet (Part 1)

Architecture is the most important aspect of the software solution that not just determines time and cost required to build the solution, but dictates the long term success of the solution in terms of stability, scalability,  security, cost to change

However, when you start exploring world of software design, architecture and program structure you come across huge number of concepts, principles, design patterns and so on.

When I initially started digging dip, I could make sense of them individually but I felt difficult to see how all these things fit together and which design patterns or programming principles I should focus at which stage of the software development

Architecture and Design Patterns – Difference

In book titled Pattern-Oriented Software Architecture, authors have defined following

 

  • Architecture Pattern expresses a fundamental structural organisation or schema for software systems. It provides a set of predefined subsystems, specifies their responsibilities, and includes rules and guidelines for organising the relationships between them.
  • Design Pattern provides a scheme for refining the subsystems or components of a software system, or the relationships between them. It describes a commonly recurring structure of communicating components that solves a general design problem within a particular context.
  • An Idiom is a low-level pattern specific to a programming language. An idiom describes how to implement particular aspects of components or the relationships between them using the features of the given language.

 

Following is my cheat sheet of my opinion about how these various concepts fit together, I have found it useful to re-visit them time and again and I hope you find the same use out of this 🙂

Please note: The purpose of this blog series is to have handy list of various architecture, design and programming principles, patterns and standards as well as their short summary; not to describe the them (no arguments over pattern in the comments please 🙂

There’s NO definitive list of architecture/design patterns or principles but following is the list of commonly known patterns that I have come across and found useful in majority of general purpose object oriented programming languages like Java, C#, C++ etc.

Software Architecture

Software Architecture Patterns

    • Layered Pattern
    • SOA (Service Oriented Architecture)
    • Broker Pattern
    • Event-driven Architecture
    • Peer-to-peer
    • Microservices
    • Model-View-Controller
    • Model-View-View-Model
    • Pipe and Filter Architecture

Programming Principles

Irrespective of the programming language used, the basic principles should remain the same, it is essential for development team to discuss these and have consensus around which principles are important and which ones the team must adhere to

    • SOLID – Mnemonic, not short form
    • KISS (Keep It Simple, Stupid)
    • DRY (Don’t Repeat Yourself)
    • Separation of Concerns
    • Avoid Premature Optimisation
    • IoC (Inversion of Control)

Software Design Patterns

Design patterns described in book by Gangs of Four is considered to be authoritative list of patterns, but they are just the structured ideas, you normally would come across various other patterns which could be conceptually similar to one of the GoF patterns or are just at the higher abstraction level.

Below is not the complete list of design patterns defined by GoF, but these are the ones I have mostly found being used. For full list of design patterns, please refer to the Wiki page

Creational Pattern
    • Abstract Factory
    • Factory Method
    • Singleton
Structural Patterns
    • Adapter
    • Composite
    • Facade
    • Proxy
    • Decorator
Behavioral Patterns
    • Observer
    • Command
    • Iterator
    • Strategy
    • Template Method

In the next posts in this blog series, I will explore each of above concepts at high level that will work as a next level of cheat sheet 🙂