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. I can give you that experience in an hour.
Software Design Courses
Master Software Design
Increase your market value
Create Solid Code
Join one of our offerings
Podcast apperance
Sign up to our newsletter Arch-Engineer
Lessons on how to write better code directly in your inbox.
Sign up and receive a free copy of 7 Mistakes That Cause Fragile Code.
Our teachings and principles
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
Testimonials
Jimmy has a wizardly knowledge around software design. There were several instances in which I asked him questions that I didn’t expect would have a nicely packaged answer, and he somehow was able to arrive at one. He’s able to take the ambiguity of how to “design a software system” and be very explicit and clear about how things should or shouldn’t be done, and the reasons behind them. There really isn’t another place or person I know of that’s able to teach software design as uniquely and effectively as Jimmy. I frequently see many of the topics I’ve learned come up in practice and now know what to do in those situations.
Jimmy took me from being that coder that people tolerated because of “potential” and taught me so much that I had Google and Facebook fighting over me, then had all the hottest teams at Facebook fighting over me.
Oh, and my salary increased 67%.