Grokking SOLID Design Principles

What the course covers

The course page lists seven chapters, 30 lessons, 51 playgrounds and 45 assessments, taking about five hours:

• An introduction to why design principles matter.
• Single Responsibility: one reason to change per class.
• Open/Closed: extending behaviour without editing existing code.
• Liskov Substitution: subclasses that do not break the code using their parent.
• Interface Segregation: small, focused interfaces instead of one large one.
• Dependency Inversion: depending on abstractions so parts can be swapped and tested.
• Practical application, including when not to apply a principle and a set of common design discussion questions with model answers.

At the time of checking the course was listed at $50 as a one-time purchase with lifetime access, rated 4.4 out of 5 from 5,186 reviews with 15,557 learners.

Why it is worth an afternoon or two

These principles are quoted constantly and understood rarely. Most engineers can expand the acronym and cannot say what the Liskov substitution principle actually forbids. Seeing the failure each principle prevents, in code you might have written yourself, is what turns it from trivia into judgement. The section on when not to apply them matters too: over-applied SOLID produces a maze of tiny interfaces.

How to use it

• Run the broken example before reading the fix, and try to spot the problem yourself.
• After each principle, find one violation in your own code or a project you know.
• Take a class that is hard to unit test and identify which principle it breaks. Difficulty testing is usually the symptom; these five are usually the cause.
• Revisit the practical chapter before a design review or low level design discussion.

Before you start

You should be comfortable with classes, interfaces and inheritance in at least one object oriented language. If those are new, learn them first; the principles make little sense without them.

What you will be able to do afterwards

• Spot the usual SOLID violations in a code review: a class that changes for three reasons, a subclass that throws on a method its parent supports, a constructor that creates its own dependencies.
• Refactor a hard to test class so its dependencies can be replaced in tests.
• Explain each principle with an example from your own code, which is what design discussions look for.
• Judge when applying a principle would add complexity without benefit.

Common questions

How long does it take? About five hours, so a weekend or a few evenings.

Which languages are the examples in? Java, Python, C++, C# and JavaScript, so you can follow along in the language you use.

Should I learn this before design patterns? Yes. SOLID explains why many patterns exist.

Best for: developers in their first few years, and anyone whose classes are hard to test or change.