Advanced Software Design Course by Mirdin

Course Description

Unit 1 | Hidden Level of Logic

Discover the key difference between design and implementation in our first module. Master Hoare's triples to understand code complexity and lay the foundation for software development expertise.

• Why design is fundamentally different from implementation and what this means for creating reliable code.
• How code that never fails can still contain errors.
• Understanding that code that looks simple can be complex, and how to avoid writing vulnerable code.
• Hoare's triples - a simple specification method that allows you to see complexity as clearly as the code itself.

Unit 2 | Principle of Embedded Design

Dive into the deepest and most far-reaching principle. How to embed program design directly into its code?

• Understanding that code can be mechanically derived from design documentation, and how this perspective simplifies system design.
• Using the principle of embedded design for better code structuring.
• Understanding the most general forms of connections between parts of code. How to find and eliminate hidden dependencies, preventing simple tasks from becoming complex.

Unit 3 | Principle of Representable and Allowable States

Learn to constrain program states so that only allowable states can be represented.

• Understanding how to partition the state space of a program and reduce the likelihood of failures.
• Designing data structures and API interfaces that cannot be misused.
• Developing code without error checks that is more reliable than the most "defensive" approach.

Unit 4 | Principle of Data over Code

Learn how a data-focused approach contributes to better modularity and information hiding.

• Parnas's secret of information hiding, which has been used for over 40 years.
• How using the principle of information hiding makes code more modular and extensible.
• Organizing a program around data structures to increase its clarity and readability.
• How extreme application of this principle allows for faster understanding of complex systems.

Unit 5 | Algebraic Refactoring

Use the power of algebra to discover that what seems different might actually be the same.

• Understanding sums and products of data types, and that most data structures are special cases of these two fundamental constructs.
• How most common refactorings are special cases of a few rules.
• How refactoring a program is analogous to factoring polynomials in algebra.

Unit 6 | Code Longevity

When is it worth spending time on thoughtful design, and when can it be deferred?

• Identifying and isolating assumptions embedded in individual lines of code.
• Using the Liskov substitution principle to ensure code compatibility with future versions.
• Applying subtype theory to predict and prevent "complexity buildup," which can make code difficult to modify and clean up in the future.