Most Active Speaker

David Whitney

David Whitney

Converting rum into code

London, United Kingdom


David is the Director of Architecture for NewDay, and the founder of Electric Head Software. Focusing on iterative software delivery, developer mentoring and cultural change - mostly working with London-based organisations.

He speaks about software design, culture, and ethics in technology - rounded out by an assortment of talks about software that probably doesn't need to exist but makes the world a little more fun. David has previously served as the chief coding technical architect for JustGiving and helped market-leading organisations including JUST-EAT, Trainline and Vodafone improve their technical capabilities.

David is a Microsoft MVP, has been part of the OpenUK Honours list for open-source advocacy, and is a twice bestselling author of children's books about programming.

You can find his open-source projects on NuGet and GitHub, follow him on Twitter @david_whitney, or check out his technical blog at


Area of Expertise

  • Information & Communications Technology


  • Programming
  • Agile
  • .NET
  • JavaScript
  • JavaScript & TypeScript
  • Node
  • NodeJS
  • Agile Testing
  • Test-Driven Development
  • Lean / Agile Leadership
  • Clean Code
  • Continuous Testing
  • API Testing
  • Testing
  • Unit testing
  • Test Driven Design
  • Architecture of Web-Apps
  • Azure Architecture
  • Microservice Architecture
  • Cloud Architecture
  • Software Architecture
  • Frontend
  • Front-End Development
  • Frontend Architecture
  • IoT
  • open source
  • open-source
  • floss
  • Culture & Collaboration
  • react
  • ReactJS
  • reactive programming
  • Realtime communication
  • Real-time communications
  • vue
  • vuejs
  • svelte
  • sveltejs
  • azure
  • microsoft mvp
  • microsoft azure
  • azure static web app
  • Static Site Generators

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.

Can I pass my own interview? How to Tackle Technical Testing

We’ve all experienced excruciating interviews, poorly conceived technical tests, and confirmation bias.

In this session, we'll live-code our way through a real technical interview test, explaining as we go what an evaluator should look for. We’ll explore the secret tells and subtext that interviews reveal and the patterns and anti-patterns of well executed technical evaluation.

For interviewees, we'll talk about the best ways to demonstrate your knowledge without over-designing.

For interviewers, we'll cover how to make sure you're reading the right signals, while keeping the process kind, ethical, and welcoming for everyone.

Clouds, Microservices, and the brittleness of architecture

You've gone through your mid-2010's cloud migration and things are not ok.

Your system is flakey, teams in conflict, and errors transient and temperamental - where did it all go wrong?

In this session, we discuss what being "cloud native" really means, distinct from vendor hype, and middleware sales pitch, covering cloud architectural patterns that make your software resilient in the real world, not just on paper.

The work doesn't stop at the platform - it starts with you.

This is a session about:

- Graceful degradation
- Bulkheading
- Circuit Breaking
- Designing for Failure
- Data replication
- Running partially offline

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!

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!

David Whitney

Converting rum into code

London, United Kingdom


Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.

Jump to top