Dependency Inversion Principle – DIP
Published:
This is the last article in the series about the SOLID principles! So, it’s time to discuss the Dependency Inversion Principle (DIP).
Blog posts
2021
Interface Segregation Principle – ISP
Published:
We’ve reached the penultimate principle in the SOLID group! This time, we’ll focus on the Interface Segregation Principle.
Liskov Substitution Principle – LSP
Published:
We’ve reached the third principle from the SOLID group – the Liskov Substitution Principle (LSP).
Open/Closed Principle - OCP
Published:
This time, let’s discuss another principle from the SOLID group – the Open/Closed principle (OCP). Let’s start with the definition:
Single Responsibility Principle - SRP
Published:
In this post, we’ll discuss the first principle from the SOLID group - the Single Responsibility Principle (SRP).
Test Driven Development
Published:
Test Driven Development (TDD), a methodology in programming, which falls under the agile methodologies.
Builder pattern
Published:
Every programmer sooner or later encounters a class that requires passing multiple parameters to create its object. Creating such classes can be significantly streamlined by using the pattern we’ll discuss today.
Decorator pattern
Published:
Today, we’ll discuss another design pattern! This time it’ll be the Decorator Pattern. But before we delve into it, let’s try to write a simple program (code written in Java).
Strategy pattern
Published:
Before we begin discussing the pattern itself, let’s create a simple model of a player that could be used in a game. The player needs to have the ability to attack and defend. The outcome of these actions will depend on the currently held weapon. Of course, this will be just a very simple example to focus our attention on the problem and solve it using the Strategy pattern (The code will be written in Java). Let’s start by creating a class representing the player: