Achieve Engineering Mastery In Weeks With The
Advanced Software Design Course
by Mirdin
Unleash your full potential as a software engineer:
- Make yourself stand out from the crowd
- Eliminate impostor syndrome today
- Guaranteed transformational results in hours
- Rise above subjective debates. Give concrete suggestions your team will understand and respect
- Escape software influencer dogma. Get your own compass.
- Join a buzzing community of over 450 top-level engineers who love to help you with your latest design challenge.
- We will help you towards your goals with 1-on-1 sessions.
- Curriculum developed based on learning science that works.
- Over 100 hours of content 100% at your own pace
Testimonials
Software Design Quiz
99% of software engineers can’t answer these questions
Follow in the footsteps of Professionals from Top-tier Companies!
























Programmers learn by making bad design decisions, working on the codebase for a year, and then find themselves wishing they could go back and do things differently. We can give you that experience in an hour.
INSIDE THE COURSE
Six core units aimed to refine your coding approach, enhance your design skills, and elevate your competency to meet the industry's urgent needs.
Unit 1 | The Hidden Layer of Logic
Discover the key distinction between design and implementation in our first unit. Master Hoare triples to unveil code complexity, laying a solid foundation for software design mastery.
- Why design is conceptually different from implementation, and what this means for building robust code.
- How it’s possible for code that never fails to still contain a bug.
- Understanding how code that looks simple may actually be complex, and how to avoid writing code likely to break in the future.
- Hoare triples, a simple method of specification that lets you see complexity as concretely as the code itself.
The Hidden Layer of Logic |> View Lessons
Unit 2 | The Embedded Design Principle
- Understanding that code can be mechanically derived from a design, and how this perspective de-mystifies system design.
- Using the Embedded Design principle to better structure your code.
- Understand the most general forms of couplings. Learn to to spot and eliminate hidden coupling, and prevent 10-minute tasks from becoming 100-hour tasks.
The Embedded Design Principle |> View Lessons
Unit 3 | The Representable/Valid Principle
- Understanding how to partition the state space of code and reduce the possibility of failure
- How to design data structures and APIs that cannot be misused.
- How to design code that contains zero error-checking, but is less likely to fail than even the most defensively-written code.
The Representable/Valid Principle |> View Lessons
Unit 4 | The Data Over Code Principle
- Parnas’s 40 year-old “secret” of information hiding.
- How to use information hiding to make your code more modular and easier to extend.
- How organizing your program around data structures can make your code cleaner.
- How an extreme application of this principle can help you understand systems 3x more quickly.
The Data Over Code Principle |> View Lessons
Unit 5 | Algebraic Refactoring
- Understanding sum and product types, and how common data structure patterns in most languages are just special cases of these two fundamental constructs.
- How most common refactorings are special cases of a handful of rules.
- How refactoring a program can be isomorphic to factoring polynomials in algebra.
Algebraic Refactoring |> View Lessons
Unit 6 | Future-Proofing
- Learning to spot and sequester the assumptions in individual lines of code.
- Using the Liskov substitution principle to make your code compatible with future versions of itself.
- Using the theory of subtyping to anticipate and avoid “complexity ratchets” that could make your code treacherous to modify in the future, and impossible to clean up.





