Programming like your life depends on it: a reliability masterclass

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 can we 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?

Click here to register

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 deep dive is for developers who want to eliminate not just 95% of their bugs, but all of them.

Sample Video

If you'd like to see Jules May in action, you can view the full video of the following session at our main conference held in May 2022.

(1 hour 8 mins)

Here’s what we’ll cover:

Day 1

Preliminaries

  • Good code – what it is and why it matters
    • What, exactly, is software quality?
    • The attitudes and approaches that make great code
    • How to conduct a code review
  • What good code looks like
    • Future-proof code
    • Instant expertise
    • How to protect the happy path (and how to ignore the unhappy ones)
    • The concepts of failsafety and anti-fragility
    • How to eradicate null pointer errors
    • Making typing work for you

Principles

  • 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
  • Classes and Objects
    • The myth of reusability
    • 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

Day 2

Practicalities

  • Isolation: intra-program firewalls
    • Fly-by-wire
    • Layering
    • Publish and be damned
  • Concurrency made ridiculously simple
    • Down with multi-threading!
    • Immutability
  • Resilient architectures
    • The concept of emergence
    • The fundamental role of interfaces
    • Microlanguages

Day 3

Progression

  • 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
  • Exception quarantine

Delegates will be invited to attempt a simple programming exercise in the week before SDD Deep Dive starts, and during the three-day workshop we will use the principles covered to refactor some or all of the submissions. Come prepared to pair-program, both in your code and in someone else’s.

Jules May

Jules May

Jules is a freelance consultant specialising in safety-critical systems, mathematical software, and compilers and languages. He has been writing, teaching and speaking about software development for 25 years, and conducts frequent lectures and workshops. He is the author of Programming Like Your Life Depends On It, and is the originator of Problem Space Analysis. Recently he has become particularly interested in the emerging field of quantum computing.

Click here to register

Interested in registering for this workshop?
Click here for details of the current price, which includes a substantial early-bird discount.