No matter how much advancement we see in programming tools and hardware technology, software development remains resolutely difficult. The preoccupation of today’s developers is exactly what it was fifty years ago: how can we create software which works reliably, and how we can extend it without breaking it? We just accept that software is inherently flawed, that all software contains bugs like original sin, and we design our processes around that.

But what if it were possible to write software correctly? What if we could create bug-free, maintainable code? And what if it were cheaper, faster and easier to write correct code than to write the buggy variety? What then?

It turns out that it is possible to write perfect code. In fact, perfect code is not that uncommon - we have been entrusting our lives to it for decades. What do they do, these perfect programmers, that the rest of us don’t? What research backs up their practices? Can we all do what they do?

This course is for developers who want to eliminate not just 95% of their bugs, but all of them. What we’ll cover:

Good code
- Why it matters.
- What, exactly, is software quality?
- What does good code look like?
Exceptions
- How exceptions got this way;
- Why exceptions turn a drama into a crisis;
- What exceptions should have been;
- The (only) valid use of an exception;
- Exception quarantine
Classes and Objects
- The myth of resuability
- Getaway classes (better than flat-pack classes)
- Better living through immutability
- Algebraic groups
- Nullary objects
If considered harmful
- The if anti-pattern, and why debugging makes bugs worse
- Decision trees
- Down-converting factories
Closure
- Exception quarantine redux
- Closures beat dependency injection
Isolation: intra-program firewalls
- Fly-by-wire
- Layering
- Publish and be damned
Concurrency
- Down with multi-threading!
- Immutability redux
Testing
- Why we test
- Why testing doesn't find bugs
- How to do automated testing right
- How to do manual testing right
Working with legacy code
- Debug the roots, not the leaves
- String-typing is non-typing
Toolmaking: Getting emergence on your side.

(Naturally, we won't be able to cover all these. But I have material for all these, and I can pick and choose to suit the audience.)