Course of Applied SOLID Principles

💸 First lesson available without registration!

The SOLID principles are a set of conventions and practices widely accepted in the software development industry. The purpose of these software design principles is to achieve more maintainable, robust, and change-tolerant code. With high cohesion in our classes, but low coupling between them.

If you already know how to develop, but you are worried about how to do your job better, you are in the right course 🙂

What you will learn in this course:

• **🦄 What are the SOLID principles:
  Identify coupled code and design patterns like Singleton, detrimental to the maintainability of your code.
• ****🤕 UML: "The good parts"**:
  We will see why UML is so stigmatized today, and we will do a quick review to learn just enough about UML to better understand the code examples we will see in the following lessons.
• 🕺 Single Responsibility Principle:
  The first of the SOLID principles: SRP. What does "One class = One responsibility" mean? How do we apply it in The Real World™️?
• 🤯 Open/Closed Principle:
  We analyze OCP at various levels of our software. Both with the classic example at the class level and at the use case level thanks to events.
• 🔁 Liskov Substitution Principle:
  Perhaps one of the most difficult principles to understand. We see examples of LSP both from an introductory perspective (classic rectangle vs. square) and from the real world. #keepItReal
• 💥 Interface Segregation Principle:
  ISP is one of the principles easiest to misinterpret and think that it is straightforward. Nothing could be further from the truth. It is one of the most interesting at a conceptual level.
• 🤹‍♀️ Dependency Inversion Principle:
  AKA: Holy Grail of the Hexagonal Architecture. We analyze it step by step differentiating between dependency injection and inversion. What benefits does each step provide?
• 🏭 Practicing SOLID with the GildedRose kata:
  Now that we have seen examples of each SOLID principle... let's put them all into practice! We solve the GildedRose exercise applying a SOLIDification™️.
• 📃 SOLID applied in The Real World™️: Specification pattern:
  We have a back office where we can manage the list of registered users in our app. This list has filters for each field. How do we implement a repository avoiding having 20 methods while adhering to SOLID?
• 👮‍♂️ Composition over inheritance:
  Composition over Inheritance: We have already applied it in the examples of the course, but now we pause to analyze the benefits of this software design principle.
• ƛ Functional Programming vs SOLID?:
  How do SOLID principles fit into functional programming paradigms? Are they really opposing concepts? How could we apply them?
• ⚡️ Conclusions and next steps:
  Brief review and the most important part: Where to continue, and how to apply them in our day-to-day work.

This course is programming language agnostic; however, to avoid it being pure theory, we will see implementation examples in PHP, Java, and Scala.

Once you complete this course, you will be fully prepared to keep learning with the following courses in the Software Architecture series. All included in your subscription price 🙂:

• 🎯 Hexagonal Architecture
• 🚎 CQRS: Command Query Responsibility Segregation
• 🕋 Communication between microservices: Event-Driven Architecture
• 📄 CQRS and Event Sourcing with Kotlin and Axon Framework

Here the first lesson of the course so you can get an idea of the quality of the content without even needing to register 😬

We await you!