The Unbearable Weight of Architecture

Most of modern software design and programming is characterised by tension and trade-offs. Making the wrong decisions often casts long shadows over a system and dooms it's maintainers to endless toil and strife. This leaves us stuck in a pendulum swing of system design techniques that are reduced to conversations about monoliths and microservices, rather than about the characteristics of the systems we're really building.

In this session, we'll cover techniques for understanding context, designing with trade-offs in mind, and building software that survives inevitable change, in non-controlled environments.

With examples from real-world systems, we will learn language that we can use to talk about design, so that we can design systems with Intentionality that are sympathetic to the humans that need to build them.

Finally, we'll cover the eternal relationship between design, architecture and programming - along with the different aesthetic viewpoints you need to help them coexist and evolve together.

"Intentional Code part 2: This time for architecture and design!"

Decades in the Machine - Meaning and Purpose in Technology

In this keynote session we'll talk about finding your own identity set against the backdrop of a career in technology.

Ways to cope with the eternal tug of war between the work we do for money and the work we do for ourselves.

We'll talk about keeping your identity intact in an unstable job market, and crafting a path focused on doing things you love with computers.

There will be practical career advice, points of reflection, and an optimistic conclusion that helps folks grow through their careers.

Open-Source Exploitation

In this session we'll do a deep dive into the history of open-source software, it's ethical issues in the modern, hyper-capitalised development landscape, and how we can survive, as humans in a world where the hobbyist computer clubs of the early microcomputing era founded practices that are being weaponised against the individual in the 2020s.

A vital, rollercoaster session about something that effects the livelihood of every developer - and is about finding the humanity in the centre of our software.

Intentional Code - Minimalism in a World of Dogmatic Design

A brief history of Design in software, reflecting on the history of the design patterns movement, clean code, and the long shadow they have cast over software development in the 2010s and beyond.

In this session we'll talk about intentionality in software design - and how you can radically simplify the way you build applications today to make them more meaningful to the humans that maintain them.

A radical look into why *every single character matters*, and why you should probably burn your copies of Clean Code.

Rendering 3D Worlds in C#

Ever wondered how Wolfenstein managed to render almost convincing 3D worlds in the 90s?

In this session, you'll learn about ray casting, the fun hack that'll let you build a 3D renderer from scratch all of your own, only using C#.

We'll cover the (not) scary maths bits, rendering things at a distance and basic texture mapping in this 1 hour deep dive, along with looking at the history of 3D in games, and a short lesson in artistic perspective.

Let The Computers Do The REST

The late 00s and early 2010s saw an explosion in the availability of HTTP APIs, driven by the rise of mobile apps. This explosion led to rich API ecosystems of varying quality and consistency across the web.

In this session we'll cover how to design RESTful APIs that are comprehensible to humans, while being friendly to the machines that have to integrate with them, looking back on 15 years of building APIs that were used by everyone.

We'll cover how to design resources, how to respect HTTP, ensuring that your APIs are consistent and efficient, the perils of versioning and the joys of hypermedia. This talk is for anyone that wants to make their APIs a pleasure to use.

Writing Tests That Don’t Suck - Test Driven Development in JavaScript

In this session we’ll talk about TDD in JavaScript, without the dogma, without the buzzwords, in simple clear examples, using Visual Studio Code, Jest and Wallaby.js We’ll cover tooling, the TDD mindset, organisational patterns, naming, data driven tests, refactoring tests, and the one most important skill in testing – learning to test the characteristics of your code, not your implementations.

This talk is perfect for people who have never done TDD before, struggle to understand it’s value, or feel held back by brittle tests that feel like mud.

It’s the summation of 15 years of teaching testing across static and dynamically typed languages, and I promise, even if you think you know testing there’s something in here for you. Live coding included!

Meditations on Code As Art

Code can be beautiful, elegant and performant, but can it deliberately be artistic?

Despite how important and prolific software and programming have become over the last 50 years the general public still have a very loose understanding of what software actually is.

This hasn't been lost of the people that build the software, who often slowly try and capture themselves in the work that they do.

In this talk we'll take a look at some examples through history of seeing the humans behind the code they write as they imprint themselves on their work and we'll consider if it's possible to deliberately make art by manipulating the form and design of software itself.

A talk for everyone wanting to be seen in the work, or understand their own creative urge.

A very weird, introspective intersection of art theory and a slavish obsession with the form of software. New talk for 2025.

Sight Reading Code

A cerebral dive into why code is like music, and literature - a primer to the text and the subtext in software design. You don’t write code for a living - you read it.

We’ll take a look at the different ways you can interpret code-bases to discover authorial intent in software. We’ll look at what I learn about you from the style of your programming. We’ll look at the breadcrumbs to meaning that exist in the odd and unexpected corners of a codebase.

Ever wondered what your code organisation, your patterns, your commit history and other subtle tells in your code tell someone else about you? Ever wonder if subtext truly exists in software? Let’s look at how it does.

Hopefully we’ll learn what makes code subjectively and objectively beautiful, and useful.

Building a Game Boy emulator in .NET Core!

A teardown of building and porting Game Boy emulators, written in cross-platform C# running in .NET Core.

We'll deal with how machine code really works, how it's translated to opcodes, and how real time emulation works, all in this hour-long deep dive into emulation in .NET.

Expect to learn about low level emulation, software porting, building debuggers and why you should always do things for fun.

Build Your Own Game Engine in the Browser. No experience necessary, all experience welcome!

Ever wondered how games of the 8- and 16-bit era would work if they were built today?

In this talk, we'll build a retro inspired, asynchronous multiplayer platform game using modern web technology. We'll cover building a basic game engine from first principles including rendering, cameras, collision detection, physics, game AIs and entity component systems.

We'll cover how web technology has changed over the last decade allowing for some surprisingly high-fidelity results like full sound and controller support right in your browser.

This is a talk for developers who have never made a game, but have always been curious. We'll learn how your regular web dev skills can be used for something a little more fun!

Making Sense of the Dissonance in AI

It's a tough time to be a technology professional. We're simultaneously being told that AI will change everything we know about the world, while simultaneously being told that the bubble is going to burst.

Everyone is going to be redundant! AI will fail! AI will ruin the internet! AI can't do anything!

It's disorienting and stressful trying to work out what a reasonable strategy should be to move forwards with this technology that appears to shift it's goalposts almost daily.

In this session, we'll talk about understanding what AI really is, how to form a reasonable, governance friendly strategy around it, and what the sensible bets for the future are in the space.

We'll do a deep dive into ethics, the human cost of content moderation, and having to be confronted by the reality of technical change in real-time.

A survival guide to getting the most from the most controversial technology in a decade.

An AI moderates warts and all deep dive into surviving as technology changes, without giving in to the hype during times of technology innovation and change.