ACID

The acronym ACID in programming - and more specifically in the context of relational databases - stands for four basic properties that guarantee correct and reliable transaction processing:

• A – Atomicity
  A transaction is indivisible: it will either execute in its entirety or it will not execute at all. If any part of the transaction fails, the whole transaction is withdrawn (rollback).
• C – Consistency
  When a transaction is completed, the database transitions from a consistent state to another consistent state. This means that transactions must respect all integrity rules (e.g. uniqueness, foreign keys).
• I – Isolation
  Simultaneously executed transactions should not affect each other. The effects of one transaction are not visible to others until it is approved (committed).
• D – Durability
  Once a transaction is approved, its effects are permanent - stored in the database even in the event of a system failure, such as a power failure.

BDD

Behavior-Driven Development is an approach to software development that focuses on the behaviour of a system from an end-user perspective. It combines testing and requirements specification techniques, enabling better collaboration between developers, testers and non-technical people. In BDD, system behaviour scenarios are described in simple natural language, most often in a Given-When-Then format, making it easier to understand what is expected of the system. The aim of this methodology is to ensure that the software being developed meets real business needs, and to increase the transparency of the development process.

CI

Continuous Integration is a practice in programming that involves automatically and regularly merging code changes into a common repository. After each change, automatic tests and application builds are run to quickly detect bugs.

CD

Continuous Integration is the practice in software development of frequently (usually daily, or even with every commit) integrating code changes into a main branch (e.g. master or develop) in a version control system (such as Git).

CRUD

CRUD is the basic set of operations that an application performs on data. Most IT systems (e.g. admin panel, online shop, booking system) boil down to:

• C - Create
  Adding a new record to the database.
• R - Read
  Retrieving data from the database.
• U - Update
  Modification of existing data.
• D - Delete
  Deletion of data from the database.

DDD

Domain-Driven Design is an approach to software development in which a thorough understanding of the business domain and close collaboration between developers and domain experts is crucial. All application logic is based on a well-designed domain model that maps real business processes and rules. The aim is to create systems that are easy to develop, in line with business needs and logically structured.

SOLID

The acronym SOLID in object-oriented programming stands for a set of five design principles that help create code that is easy to maintain, extend and test. Each letter represents one principle:

• S – Single Responsibility Principle
  A class should have only one reason to change. In other words, a class should only perform one task or be responsible for one aspect of system functionality.
• O – Open/Closed Principle
  The code should be open to extension but closed to modification. We should be able to add new functionality without changing the existing code.
• L – Liskov Substitution Principle
  Objects of descendant classes should be usable wherever the base class is used - without altering the correctness of the programme.
• I – Interface Segregation Principle
  Do not force classes to implement interfaces they do not use. It is better to have several small interfaces than one large one.
• D – Dependency Inversion Principle
  High-level modules should not depend on low-level modules. Both should depend on abstractions. That is, dependencies should be reversed - program to interfaces, not to specific classes.

TDD

Test-Driven Development is an approach to software development in which unit tests are written first and only then is the production code to pass those tests. TDD is one of the practices of agile programming (Agile), particularly popular in methodologies such as Extreme Programming (XP).