I've been speaking at conferences and user groups since 2008. I've done everything from five-minute Ignite-style talks to half-day workshops, and covered subjects including web design, HTTP APIs, user experience, jQuery, ServiceStack, Conway's Law, artificial intelligence, dimensional analysis of music, and the physics of the electric guitar. If you’d like me to come and speak at your conference, event or user group, get in touch and let’s talk.
Current TalksTalks that I’m giving at conferences and user groups in 2017. If you want to request a talk on a different topic, by all means get in touch – I’m always happy exploring and presenting new ideas.
Building Secure Applications with OAuth2 and OpenID Connect
Security is a big deal. Hardly a week goes by without another story in the headlines about some unfortunate organisation whose customer records have ended up for sale on the dark web. But storing and using accurate information about your users is a key part of delivering the kind of rich, intuitive user experiences that people expect from modern web and mobile applications. So what do you do? How can you build apps that store and manage rich customer data without worrying that your company's going to end up on the front page of haveibeenpwned.com?
In this talk, Dylan Beattie will show you how to use modern authentication and authorization protocols to build secure applications in C# and .NET. We'll look at the most common security problems you'll face when building apps and APIs, and how you can use modern security standards like OAuth2 and OpenID Connect to solve those problems. We'll discuss the latest recommendations around password security, two-factor authentication and single sign-on, and look at how you can use open source projects like IdentityServer in your own applications.
Audience level: .NET developers. Intermediate.
Format: Talk, slides, code examples, live demos.
Amdahl to Zipf: Fundamental Laws of the Physics of People
It's all too easy to think software is magic - but it's not. Most of the time, it's not even sufficiently advanced. Like everything else in our world, the people you work with and the products they build are subject to the fundamental laws of nature. Based on an original idea by Pieter Hintjens, this talk explores the laws of our universe - from the fundamental laws of physics to the eponymous laws found in the IT industry. Dylan Beattie shows you how Newton's Laws of Motion can explain why big organizations struggle with agile development; how the Equivalency Principle explains why so many startups fail, and why Heisenberg's Uncertainty Principle makes it so hard to estimate and report on your software projects. Finally, we'll look at three of the oldest laws of software engineering - Moore's Law, Amdahl's Law and Conway's Law - and how they can prove that if you don't stop having meetings, the internet will stop working.Audience level: everyone.
Format: Talk only. No slides, no code, no demos.
Life, Liberty and the Pursuit of APIness : The Secret to Happy Code
We spend our lives working with systems created by other people. From the UI on our phones to the cloud infrastructure that runs so much of the modern internet, these interactions are fundamental to our experience of technology - as engineers, as developers, as users - and user experiences are viral. Great user experiences lead to happy, productive people; bad experiences lead to frustration, inefficiency and misery.
Whether we realise it or not, when we create software, we are creating user experiences. People are going to interact with our code. Maybe those people are end users; maybe they're the other developers on your team. Maybe they're the mobile app team who are working with your API, or the engineers who are on call the night something goes wrong. These may be radically different use cases, but there's one powerful principle that works across all these scenarios and more - and it's called discoverability. In this talk, we'll draw on ideas and insight from user experience, API design, psychology and education to show how you can incorporate discoverability into every layer of your application. We'll look at some real-world systems, and we'll discuss how how discoverability works with different interaction paradigms. Because, whether you're building databases, class libraries, hypermedia APIs or mobile apps, sooner or later somebody else is going to work with your code - and when they do, wouldn't it be great if they went away afterwards with a smile on their face?Audience level: technical, intermediate. Language-agnostic but developer-centric.
Format: talk + slides + code examples
Real World REST and Hands-on Hypermedia
So you've built your HTTP API, and now that it's live, you're suddenly dealing with a whole new set of problems. Do you really need to PUT the entire Customer just to change someone's email address? Why does it take you 25 API calls just to render a shopping cart? How do you find the bottlenecks when just drawing a web page requires fifty HTTP requests? What happens when one of your API consumers accidentally tries to GET your entire customer database?
In this talk, we'll look at the problems of running ReSTful APIs in the real world, and the architectural patterns that exist to help us solve those problems. We'll talk about hypermedia - how does it work and why does it matter. We'll look at resource expansion, and how it can reduce your server workload and speed up your client applications. We'll talk about how to implement PATCH properly, how to handle security and authentication for your APIs, and what tools and services exist to help you design, deliver and debug your HTTP APIs.Target audience: developers, systems architects.
Level: advanced. Assumes familiarity with HTTP, JSON and some experience designing HTTP APIs
Domain Architecture Isomorphism and the Inverse Conway Maneuver
Most of us have heard of Conway's Law - "organisations that design systems are constrained to produce designs which are copies of the communication structures of those organisations". And once you accept that systems end up reflecting the structure of the teams that create them, it's clear why many software projects don't go according to plan. Your architect says you'll use an API instead of direct database access - but then you sit your developers next to your DBA and give them a deadline; what do you think happens to your API? Or you have a DBA in London working with an app developer in Prague and a web team in Kyiv, and then wonder why your system's communication layers are causing performance problems?
In this talk, we'll look at communication structures and how those structures affect the outcome of the systems you're building. We'll discuss how to apply design patterns to your teams as well as your code, and how to sell the idea to your boss before you start moving desks around.Target audience: Anyone who builds systems, really :)
Webmasters, Full Stack Developers, and Other Legendary Creatures
The history of software is rich with extraordinary individuals whose knowledge of their systems was unrivalled. But in 2016, where distributed systems and machine learning are ubiquitous and the average web app uses two frameworks, four languages and six caching layers, does it make any sense to talk about full stack developers? Are we clinging to outdated paradigms, nostalgic for the days when one person really could know all the answers, or does overspecialisation pose a genuine threat to the established conventions of software development? And if it does, should we resist it - or welcome it as a change that's long overdue?
It's 25 years since Tim Berners-Lee created the first web page. In this talk, we'll look at the history of the World Wide Web, exploring what we've learned - and forgotten - along the way. We'll reflect on a quarter-century of writing code, designing systems, building teams and shipping products, and we'll take a speculative look at the next 25 years of the web.Target audience: Web developers, architects, team leaders.