Most Active Speaker

David Whitney

David Whitney

Converting rum into code

London, United Kingdom

David is the founder of Electric Head Software, working as an independent software consultant based in London focusing on iterative software delivery, developer mentoring and cultural change - mostly working with London-based organisations and start-ups.

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.

You can find his open source projects on NuGet and GitHub, follow him on Twitter @david_whitney, or check out his technical blog at http://www.davidwhitney.co.uk/Blog.

http://www.electricheadsoftware.com
http://www.davidwhitney.co.uk

Awards

Area of Expertise

  • Information & Communications Technology

Topics

  • 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

Serverless Azure Static Web Apps with JavaScript and TypeScript

You'll be taken through how you can build super cheap, lightning fast web apps, with continuous delivery from your GitHub repositories, that even include server-side API code that is magically hosted and managed for you.

We'll look at local dev, explaining how the developer experience works, we'll cover configuration and secrets management, CI and deployment.

To finish, we'll look at the layout of your repository, and how you can make Azure manage server-side code for you, from inside your static apps, with almost no configuration.

Reverse Engineering IoT devices with Web Bluetooth

A deep dive into hardware hacking some no-brand wearable tech using Web Bluetooth and TypeScript.

In this session, we'll cover reverse engineering, the bluetooth protocol, web bluetooth, and making things look pretty with coloured lights.

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 APIs with Azure Functions

As serverless computing and functions as a service becomes increasingly popular, we'll run through patterns and practices for building serverless apps on Azure - managing your codebase, your entry points, and understanding the serverless runtime by building a slackbot and a continuous delivery pipeline in .NET Core.

Clouds, Microservices, and the brittleness of architecture

Why your cloud architecture might kill your software.

In this talk, we discuss what cloud native really means for your software - and more specifically why ignorant use of excellent technology can actually damage your application, rather than help it. We’ll discuss some excellent features of the Azure platform, but also dive deep into the things that will definitely go wrong when you use them thoughtlessly - along with exploring some battle tested, cloud native patterns for avoiding certain disaster.

How stuff works – meta-programming in C# 101

We live in a world where our tools, frameworks and libraries are often built for us. Especially in .NET, we rely on ASP.NET MVC, DI Containers, Unit testing tools and IDEs and all of these things sell themselves on hiding complexity and being "hard problems". In this session, David will explain how all these big tools and frameworks aren't really that different, and are built using the same language and practices that you using in your user-land code every day. We'll break down how all that stuff works - MVC, Test frameworks and containers - illustrating how it's all just meta-programming with reflection, and hopefully leave you with practical tips for implementing strong conventions, discovery, and implementing composition in your own code bases.

TDD in TypeScript with Wallaby.js

As TypeScript becomes more and more popular, it's important we approach it with the same rigour as we would other languages and frameworks.

Here's a lap around TDD in TypeScript, using the continuous test runner Wallaby.js - complete with live demos using code katas.

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.

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.

David Whitney

Converting rum into code

London, United Kingdom