Speaking

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.

I’ve been working with SkillsMatter in London since 2008, and have spoken at numerous events they’ve hosted both through my work with the London.NET User Group and as part of various other events – check out my SkillsMatter speaker profile page for more details and videos.

On this page you’ll find details of the talks I’m currently giving, and of talks I’ve given in the past.

Current Talks

Talks that I’m giving at conferences and user groups in 2016. 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.

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


The Rest of REST

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 :)

Level: Everybody


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.

Level: Everybody


Selected talks I’ve given previously

Talks I’ve delivered over the years at conferences and user groups – most of them with accompanying video.

Domain Architecture Isomorphism and the Inverse Conway Manouver

Most of us have come across Conway's Law - the observation that "organisations that design systems are constrained to produce designs which are copies of the communication structures of those organisations". From standalone web applications to open-source projects to large-scale enterprise applications, a project's success (or failure) comes down to the team that's trying to deliver it - so why do so many projects try to impose the right architecture on the wrong team structure?

Presented at NDC Sydney 2016

The Face of Things to Come

A five-minute Ignite-style talk I did at PubConf in January 2016, looking at advances in face recognition technology and the implications it has for our society.

The Face of Things to Come from Dylan Beattie on Vimeo.

 


 

The Rest of REST: Advanced HTTP API Design

I've given variations on this talk at NDC London 2016, NDC Oslo 2015, the Progressive.NET Tutorials 2015, and the Camridge DDD Nights user group – and as long as people keep asking for it, I’ll keep giving it. After all, REST is about software architecture on a scale of decades; there is a timeless quality to the patterns and ideas here that make a refreshing alternative to the “framework-of-the-month club”


The rest of ReST - Dylan Beattie from NDC Conferences on Vimeo.

"So you've built a ReSTful API. You've had lengthy debates with your team about exactly what HTTP POST means, you know your GET from your PUT and you understand why HTTP methods aren't really the same as CRUD operations. So far, so good. But now you're 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's going to happen to your database when one of your API consumers accidentally tries to retrieve the entire customer list?In this talk, we'll look at the challenges of building usable real-world ReST APIs. We'll look at Hypertext Application Language (HAL), and the conventions for extending basic JSON data to include references, cross-resource links and paginated result sets. We'll discuss HTTP PATCH, and how to implement it properly. We'll look at inline resource expansion, and how it can reduce load on your servers AND speed up your client applications. We'll look at how you can implement these techniques in popular .NET API frameworks like WebAPI, ServiceStack and NancyFX. We'll see how tools like Apiary and Swagger can help you design, build and support APIs, and we'll discuss the challenges of API versioning and how you can upgrade your APIs without breaking your client apps and upsetting your customers."




Are Smart Systems Making Us Stupid?

A talk I gave at BuildStuff 2015 in Vilnius (Lithuania) and Kyiv (Ukraine).
video coming soon...

Software and smart devices are changing the world beyond recognition, and all too often, the human beings who create it are struggling to keep up. We create devices that can make crystal-clear hi-def video calls to anywhere in the world, and then laugh at someone who microwaves their iPhone because they read online that it would charge the battery. You spend $800 on a tablet computer that doesn't even include an instruction manual - and then your three-year-old kid finds a shortcut for playing Peppa Pig videos that you didn't know existed. At the other end of the scale, we're building huge distributed systems too complicated for any human to understand. Decisions that affect our lives - the pages that show up in our search results; the people we meet on Tinder; the price we pay for car insurance - are being delegated to algorithms so sophisticated that nobody can explain why a particular result happened, or predict whether it will happen again.

So what can we do about it? As developers, how do we build systems that don't make people feel stupid? How do we empower users to make decisions and apply common sense in a world where tomorrow's technology is indistinguishable from yesterday's magic? In this session, we'll talk about artificial intelligence, waterproof smart phones, cognitive bias, Markov chains, Windows 10, self-driving cars, fractal geometry, the psychology of risk, Monty Hall, user experience design, the Dunning-Kruger effect, and why the "back" button is the greatest invention in the history of computers.





Front-End Fun with Sass and Coffee

Given at NDC Oslo 2015 and the London.NET User Group



Front-end Fun with Sass and Coffee - Dylan Beattie from NDC Conferences on Vimeo.

The web is built on HTML, CSS and Javascript. These core web technologies are the basis of every website and web application, and like it or not, they're here to stay. These days, of course, it's rare to build a website by hand-coding static HTML pages; instead, we use tools and frameworks to build software applications that write our HTML for us. However, it's all too common to see beautiful, elegant, modular web applications deployed alongside monolithic CSS files and handwritten JavaScript code.
In this talk, we're going to look at how tools like SASS and CoffeeScript can help us create dynamic stylesheets and script files based on elegant, expressive source code. We'll look at how you can include these tools in your ASP.NET web applications, with full support for runtime optimisations and HTTP caching, and we'll look at which tools exist to offer first-class support for these abstractions in Visual Studio.



 

Ten Deploys a Day, The .NET Way

A workshop I gave at the SkillsMatter Progressive.NET Tutorials in May 2013.

video available on SkillsMatter's website.

Building the application is only half the problem. Whether you're building a single-page app, an MVC website, a Windows service or a full-blown SOA platform, you'll end up facing the same challenges - how do I make my app available for QA and testing? How do I release it into production with minimal downtime and risk? How do I manage database schema changes? What if I need to roll back a release but my customers are already using the new feature to store their own data?

In this workshop, we'll explore the rich suite of tools that has evolved to support continuous deployment in the .NET ecosystem We'll look at tools including NuGet, msbuild, SlowCheetah, TeamCity, Octopus Deploy and SQL Source Control. We'll discuss hosting options - physical, virtual, cloud-based - and how these choices can affect your release process, maintenance and monitoring requirements, and we'll look at how you can create a pipeline that supports Flickr's famous "ten deployments per day" for your .NET applications.




Front-End Tips for Back-End Devs

From the SkillsMatter Progressive.NET Workshops in 2011. Some of the content here is very, very dated, but the idea of applying SOLID principles to stylesheets and front-end resources is just as relevant (and underutilised!) today as it was when I first gave this talk.

video available on SkillsMatter's website

We all know the value of dependency management, DRY, abstractions and loose coupling when we're building our back-end architectures, but when it comes to writing the UI for our web applications, we often fall back into the habit of copy'n'paste code reuse, invisible dependencies, mixing presentation and behaviour, using inline styles and JavaScript, and other bad habits.

In this workshop, we'll explore how we can apply software engineering principles like SOLID to our front-end development work. How can we implement the single-responsibility principle in our CSS classes? How can we make our CSS open to extension but keep it closed to modification?




5x5: Five Minutes in Five Minutes

A talk I gave at Ignite London 3 in 2010. Ignite uses a fixed format - 20 slides, 15 seconds each, so each speaker speaks for exactly five minutes - and I thought it would be fun to use that five minutes to explore what actually happens in the world during the course of a five-minute talk.


5 x 5: Five Minutes in Five Minutes - by Dylan Beattie from chichard41 on Vimeo.

No comments: