Sign Up Today
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 350 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
 
I Want To
2x My Skills
Today!
Join the Course. No risk. 14-day refund policy
View Course Content

Testimonials

Software Design Quiz

99% of software engineers can’t answer these questions 

TAKE OUR QUIZ

Follow in the footsteps of Professionals from Top-tier Companies!

Stripe
Jane Street
Snap
Amazon
Airbnb
Dropbox
Github
Apple
Adobe
Meta
Google
Uber
Offchain Labs
Tiktok
T-Mobile
Toptal
Microsoft
Nvidia
Two Sigma
Twitter
Vimeo
OpenAI
Discovery
Intel

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.

-- Mirdin
 
I'm Ready To Take The Leap
No risk. 14-day refund policy

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.

Unit 2 | The Embedded Design Principle

Dive into our deepest and furthest-reaching principle. How do you capture the design of the program in the code ?

  • 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.

Unit 3 | The Representable/Valid Principle

Learn how to constrain your state so only valid states can be represented.

  • 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.

Unit 4 | The Data Over Code Principle

Learn how thinking about data structures first leads to better modularization and information-hiding.

  • 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.

Unit 5 | Algebraic Refactoring

Harness the power of algebra and see that what first appears vastly different, can actually be the same.

  • 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.

Unit 6 | Future-Proofing

When should you spend time on upfront design, and when can you leave it for later?

  • 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.
I Want To 2x My Skills Today
No risk. 14-day refund policy

Frequently Asked Questions