[Mirdin] The Advanced Software Design Course [2024, ENG]

Содержание

Unit 1: The Hidden Layer of Logic
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.
Bonus topic: The defect/infection/failure model of bugs and what Hoare triples have to do with debugging by printouts.
Unit 2: The Embedded Advanced Software 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.
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.
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.
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.
Unit 6: Future-Proofing Code
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.

Скриншоты