This catalogue shows some tools of my ever-growing toolbox.
You will find hammers, chisels, brushes, rulers and measuring tape in here: Some are used to scrutinize and identify initial shapes, some help with getting those into form. Others help with precisely carving out finer details.
An Actor is an entity that interacts with a system.
An Aggregate is an abstraction for an object that is important and of value to the business of its domain. It is often referred to as a "cluster" of objects, because it is modelled as a whole/parts-relationship holding between and .
An Aggregation is a form of an with extended notation to emphasize on whole/part-relationships.
Aliasing in Object-Oriented Programming is a synonym for two (or more) variables referencing the same instance.
📄️ Anemic Domain Model
An Anemic Domain Model is a domain model that contains little or no business logic, and whose mainly consists of getters and setters. Specification and invariants regarding the domain logic are controlled through layers and upstream components.
📄️ Application Layer
The Application Layer is an abstract functional division in a that serves as the interface between the client and layers beneath the Application Layer, primarily the software system's Domain and Infrastructure Layer.
An Association between entities can be illustrated in UML with a solid line connecting the entities that are related.
📄️ Big Ball of Mud
A "Big Ball of Mud" is a historically grown software system (or a part of it) often characterized through lack of modularization, missing , redundant code and information leaking through various levels of abstractions.
A Bounded Context is a part of a software system that contains the semantics of a
A Composition is an and designates a special form of an . It is used in cases where the abstraction of a model requires a strong emphasis on the whole/part-relationship, approximately corresponding to denoting a parent/child-relationship of the elements within the Composition.
📄️ Core Domain
In a software system, a Core Domain is the part of the software that holds all functionality innate to the
A Dependency between a client (dependent) and a supplier (dependee) can be illustrated with a dashed line with its tail starting at the client and an open arrowhead ending at the supplier.
📄️ Dependency Injection
Dependency Injection (DI) is a design pattern that helps with decoupling dependencies.
📄️ Dependency-Inversion Principle
The Dependency Inversion Principle (DIP) is a principle in Agile Software Development that helps with
The term Domain in Software Design stands for a business which processes are implemented in a software system
📄️ Domain Driven Design
Domain Driven Design [DDD] is a software development methodology that focuses on
📄️ Domain Layer
The Domain Layer is a layer in a and holds all implementation related to the business of the software, such as rules and concepts, manifesting in , expressed through a and bounded by .
📄️ Domain Model
A Domain Model is an abstraction of a (part of a) in a software system.
An Entity is a specification of a uniquely identifiable (abstract) object and its properties and behavior in a
📄️ Eventual Consistency
An Eventual Consistency is a consistency model that guarantees the consistent state of data.
A Facade is an object based Structural Pattern .
📄️ Factory Method
A Factory Method is a method for creating a new object for a given type.
📄️ First-Class Citizen
In programming, an entity is called First-Class Citizen if all of the following apply:
📄️ Higher-Order Function
In programming, a function is called a Higher-Order Function, if any of the following applies:
A Keyword in UML is a predefined and reserved word available with the meta-model of UML.
📄️ λ Calculus
Lambda Calculus is a formal definition for expressing functional computational operations based on variable binding and substitution.
📄️ Layered Architecture
A Layered Architecture is a design paradigm for creating abstract divisions from related functionality in a software system.
📄️ Liskov Substitution Principle
The Liskov Substitution Principle (LSP) governs design rules for object oriented languages and states that "subtypes must be substitutable for their base types." :
A Metaclass in Object-oriented programming is a class whose instances contain class-definitions. Metaclasses can
📄️ Pure Function
A function is considered a Pure Function if
📄️ Referential Transparency
If an expression can be substituted for a value without changing the program's computational result, the expression is referential transparent.
A Repository provides an interface for persisting and retrieving data, while hiding the implementation details of
📄️ Separate Query From Modifier
Separate Query From Modifier is a refactoring that helps with creating side effect free functions.
📄️ Separation of Concerns
Separation of Concerns is a design principle in software development and can be considered fundamental for creating
📄️ Single Responsibility Principle
The Single Responsibility Principle (SRP) is a Software Design Principle that states that there should never be
A Singleton is an object that uniquely exists for a class: Creating new instances of this class always restrict to this one object.
SOLID is an acronym for five principles in Software Development and Software Design. They were introduced by
📄️ Spanning Tree
If $G$ is a connected graph, then the Spanning Tree $T \sube G$ is a minimal connected graph with $V(T) = V(G)$.
📄️ Symptoms of Poor Design
The Symptoms of Poor Design are a collection of symptoms that appear in software systems where poor design choices - or none at all -
📄️ Table Data Gateway
A Table Data Gateway provides an interface to the table of a database.
📄️ Ubiquitous Language
A Ubiquitous Language is a vocabulary established by (software development) teams that provides semantic contexts
📄️ Use Case
A Use Case represents a description of a functionality or requirement of a software system.
📄️ Value Object
In Object-Oriented Programming, a Value Object is an abstraction of a value belonging to a particular domain.