The Tech Behind the Linebreakers

The Linebreakers are the world’s nerdiest party band, with a live show that’s a mixture of music, video, comedy, guitar riffs, and bad jokes about JavaScript.

It goes without saying that everybody in the band loves to geek out about software and technology… and behind the scenes of every Linebreakers show there’s a whole bunch of weird custom software and hardware, from video encoding pipelines, to PowerPoint macros, to modified guitar pedals with Arduino controllers inside them. Come along and find out what we did, why we did it - and how running a live rock show brings a whole new meaning to the idea of “testing in production”.

back to top

There's No Such Thing As Plain Text

Software is complicated. Machine learning, microservice architectures, message queues… every few months there’s another revolutionary idea to consider, another framework to learn. And underneath so many of these amazing ideas and abstractions is text. When you work in software, you spend your life working with text. Some of those text files are source code, some are configuration files, some of them are documentation. Editors, revision control systems, programming languages - everything from C# and HTML to Git and VS Code is based on the idea that we’re working with “plain text” files. But… what if I told you there’s no such thing?

When we say something is a plain text file, we’re relying on a huge number of assumptions - about operating systems, editors, file formats, language, culture, history… and, most of the time, that’s OK. But when it goes wrong, good old plain text can lead to some of the weirdest bugs you’ve ever seen. Why is there Chinese in the SQL event logs? Why has the city of Aarhus disappeared? And why does Magnus Mårtensson always have trouble getting into the USA? Join Dylan Beattie for a fascinating look into the hidden world of text files - from the history of mechanical teletypes, to how emoji skin tones actually work. We’ll look at some memorable bugs, some golden rules for working with plain text, and we’ll find out what the phrase “PIKE MATCHBOX” has to do with driving in the Soviet Union.

back to top

Machines, Learning, and Machine Learning

It wasn’t all that long ago that “learn to code” was failsafe career advice, and whether you were studying for a university degree, enrolling in a coding bootcamp or just hacking on open source, the prospect of a well-paid job at the end of it was all the motivation you needed… well, times change. Whether you’re looking for your first tech job or your next consulting contract, it’s tough out there, and naturally, people are asking “what should I be learning next?”

What if that’s the wrong question? What if the real question isn’t what you learn, but how you learn it - and how to get started? Let’s talk about motivation. Let’s talk about all the wonderful tools and systems out there that make it easier than it’s ever been to start exploring new languages and platforms, from Copilot and ChatGPT, to cloud IDEs and IOT microcontrollers. Let’s talk about the all-important difference between programs and products; about the challenges of going from “hey, it works on my machine” to something customers will actually pay for. We’ll find out why open source projects succeed where well-funded corporate projects fail, why are there so many JavaScript frameworks – and why you’re still sitting up writing code at 3am, even though you know you have work in the morning.

back to top

Algorithms Demystified

Have you ever got stuck on a coding problem? Maybe you’re implementing a feature on one of your projects, maybe you’re solving puzzles for something like Advent of Code, and you get stuck.

You just can’t figure out how to get the result you need. So you head over to Stack Overflow, or Reddit, or ask a colleague for help, and you get an answer like “oh, that’s easy, just use Dijkstra’s algorithm”… and your brain crashes. Use what? So you go and look it up and discover it’s for “finding the shortest paths between nodes in a weighted graph”, and now you’ve got to look up what a “node” is, and what a “weighted graph” is… and then figure out how to turn all that into working code? Nightmare.

Well, it doesn’t have to be like that. Algorithms are the key to all kinds of features and systems, from networks to autocorrect, and understanding how they work will help you build better software, fix subtle bugs - and solve Advent of Code. In this talk, we’ll meet some of my favourite algorithms, explain why they’re important, and help you understand what they do, and how they do it.

back to top

Open Source, Open Mind: The Cost Of Free Software

Free lunch, free speech, free time, free spirit… when we talk about something being “free”, that’s normally a good thing. But as anybody who’s ever given away their software for free will know, it’s not that simple - and sometimes, it’s not clear what “free software” even means.

At one end of the scale, volunteers use free software to resurrect old laptops, turning e-waste into useful tools they can donate to worthy causes. At the other end of the scale, tech giants use free software packages to create products which generate millions of dollars in profits every year - but when the creators of those packages try to recoup even a tiny part of that revenue, social media goes into an angry meltdown.

Join Dylan Beattie for a look at the past, present, and future of free software. We’ll talk about the history of the free software movement, from MIT’s Artificial Intelligence lab, to the shareware and public domain movement of the 1980s, to the era of GitHub and package managers. We’ll explore why people choose to give their code away for free in the first place - and what happens if they change their mind. We’ll talk about licences and legalities, we’ll learn about some of the weird and wonderful edge cases that free software has created over the years, and we’ll ask the question: is a truly sustainable open source ecosystem possible, and if so - what might it look like?

back to top

How To Be a Rockstar Developer

One evening in 2018, Dylan Beattie sat down in a bar, opened a laptop, and wrote a joke: a parody specification for Rockstar, a programming language based on the lyrics to 1980s power ballads. The joke was supposed to end there: a single Markdown file that folks would read, maybe laugh a bit, and then get on with their lives… well, that’s not quite how it worked out.

The internet’s a big place, and a little corner of it took Rockstar to their hearts: they found it, they loved it - and then they implemented it. Six years on, Rockstar has shown up in the most unlikely places, from Classic Rock magazine, to Advent of Code, to Carnegie Mellon University and MIT - and each time, it attracts a new wave of aspiring Rockstar developers, with questions about how it works, and suggestions about how to make it better. And so, one evening in 2024, Dylan sat down in another bar, opened another laptop, and wrote another joke: “Rockstar 2.0: The Difficult Second Album”.

On one level, Rockstar in 2024 is a stupid joke language based on Bon Jovi songs. On another level, it’s packed with things that would have been impossible even just a few years ago: a project that combines .NET, C#, JavaScript, browser APIs, and web assembly, building on decades of research in parser engineering and asynchronous application development. And yes, it’s still based on Bon Jovi songs.

This is the story of Rockstar 2.0. You’ll learn about the history of esoteric programming languages, from INTERCAL, to Piet, to the researcher who taught Perl to speak Latin. You’ll learn what’s involved in creating an entirely new programming language. You’ll see a lot of cool tech, you’ll marvel at just how much engineering can go into one joke, and who knows - you might even qualify as a Certified Rockstar 2.0 Developer.

back to top

From Hot Metal to HTML: The Story of Typography

Arial, Times New Roman, Consolas, Comic Sans… digital typography has turned us all into typesetters. The tools we use, the apps we build, the emails we send: with so much of our lives mediated by technology, something as seemingly innocuous as picking a typeface can end up defining our relationship with the systems we use, and become part of the identity that we project into the world. Typography is a fundamental part of modern information design, with implications for user experience, accessibility, even performance - and when it goes wrong, it can produce some of the most baffling bugs you’ve ever seen.

Join Dylan Beattie for a journey into the weird and wonderful history of digital typography, from the origins of movable type in 8th century Asia, to the world of e-ink displays and web typography. We’ll look at the relationship between technology and typography over the centuries: the Gutenberg Press, Linotype machines, WYSIWYG and the desktop publishing revolution. What was so special about the Apple II? How do you design a pixel font? We’ll learn why they’re called upper and lower case, we’ll talk about why so many developers find CSS counter-intuitive - and we’ll find out why so many emails used to end with the letter J.

back to top

Email vs Capitalism: A Story About Why We Can't Have Nice Things

We’re not quite sure exactly when email was invented. Sometime around 1971. But we know exactly when junk email was invented: May 3rd, 1978, when Gary Thuerk emailed 400 people an advertisement for DEC computers. It made a lot of people very angry… but it also sold a few computers, and so junk email was born.

Fast forward half a century, and the relationship between email and commerce has never been more complicated. In one sense, the utopian ideal of free, decentralised, electronic communication has come true… email is the ultimate cross-network, cross-platform communication protocol. In another sense, it’s an arms race: mail providers and ISPs implement ever more stringent checks and policies to prevent junk mail, and if that means the occasional important message gets sent to junk by mistake, then hey, no big deal… until you’re trying to send out e-tickets and discover that every company who uses Mimecast has decided your mail relay is sending junk. Marketing teams want beautiful, colourful, responsive emails, but their customers’ mail clients are still using a subset of HTML 3.2 that doesn’t even support CSS rules. And let’s not even get started on how you design an email when half your readers will be using “dark mode” so everything ends up on a black background.

Email is too big to change, too broken to fix… and too important to ignore. So let’s look at what we need to know to get it right. We’ll learn about DNS, about MX and DKIM and SPF records. We’ll learn about how MIME actually works (and what happens when it doesn’t). We’ll learn about tools like Papercut, Mailtrap, Mailjet, Foundation, and how to incorporate them into your development process. If you’re lucky, you’ll even learn about UTF-7, the most cursed encoding in the history of information systems. Modern email is hacks top of hacks on top of hacks… but, hey, it’s also how you got your ticket to be here today, so why not come along and find out how it actually works?

back to top

Analogue Evolution, Digital Revolution: Tipping Points in Technology

Technological progress is non-linear. Sometimes, innovation is a smooth curve; hundreds of small, incremental improvements over many years – until something comes along that changes the game; something that fundamentally challenges our assumptions around what technology can achieve. Within the last few decades, technology has profoundly and irreversibly changed the shape of human society; how we work, how we relax, how we communicate and collaborate. And, in almost every case, the key has been digitalisation: the ability to take transform part of our reality into a stream of bits.

With the benefit of hindsight, it’s easy to see the tipping points, to identify the moments when a particular technology or idea achieved critical mass, when something went from being an interesting prototype to a viable product – but for people who were there at the time, it often wasn’t nearly so obvious. In an industry that’s perpetually excited about the “next big thing”, how do developers and technologists decide what to focus on? Should we be thinking about augmented reality? Will machine learning replace developers? Is AI a fun toy, a useful tool – or an existential threat to humanity? Join Dylan Beattie for an entertaining look at the innovations that really did change the world (and a few that didn’t!), and how understanding our history can help us make sense of the next digital revolution – whatever that turns out to be.

back to top

WhatsApp, Web3 and Wordle: Evolving a Digital Society

We live in a networked world. Between our laptops, our phones, and the smart gadgets in our kitchen, many of us are online 24/7. We work and play, communicate and collaborate, across digital networks powered by open protocols - the standards and specifications that form the backbone of the modern internet.

But within the last decade, we’ve seen many online interactions move away from open protocols and onto closed platforms. We’ve abandoned SMS for Signal and WhatsApp, we’ve abandoned email in favour of Slack, Teams, and Discord; restaurants use Instagram and Facebook instead of running their own websites. And, most of the time, it works – but as more and more of our digital experiences are mediated by corporations and the platforms they control, what does this mean for the future of the internet? Amidst all the hype about “web 3” and the “metaverse”, let’s take a moment to remind ourselves how we got here, and remember what’s at stake. We’ll look back at the promise of “web 2.0” and what it actually delivered, we’ll talk about digital identity and net neutrality - and we’ll learn what the Apollo/Soyuz space missions have to do with the digital protocols that underlie our connected society.

back to top

Sockets, Sparks and Magic Smoke

For thousands of years, humans have watched in awe as lightning flashed across the sky. Benjamin Franklin studied electricity by flying kites in thunderstorms, Michael Faraday discovered the relationship between electricity, magnetism and motion, and today, our world literally runs on electricity. We’ve built vast power grids that carry hundreds of gigawatts across continents, our cars, phones, and earbuds run on batteries, and we’ve sent radioisotope generators to the furthest reaches of space – and implanted them into our own bodies. And within the last century, we’ve learned to used electricity to represent information; true and false, one and zero, countless electrical bits bouncing all over the planet, carrying news, video, music, games, and the metadata that keeps our society connected.

Join Dylan Beattie for an insightful and entertaining look at how humans have used the power of the electron to build our digital society. We’ll demystify the everyday electrical systems which we all take for granted - what’s really happening when you charge your phone? Why don’t Americans use electric kettles? What’s actually happening inside that 8Gb USB stick you’ve got on your keyring? We’ll dig into some of the most remarkable devices and systems ever built. We’ll look at the fundamental limitations of physics, why we’ll probably never see a 10GHz CPU core, and how quantum computing could be the key to breaking that barrier. Finally, we’ll look at what happens when it goes wrong, and what engineers can do about it – from error correcting RAM chips, to why hospitals run backup power supplies, to what happens when entire countries suddenly need more power than we expected.

back to top

It's So Shiny! Building a Pure JavaScript Ray-Tracer

It’s hard to imagine a world without computer generated imagery. Films, television, games, art, advertising… CGI gives artists, designers, and film-makers the tools to bring fantastic fictional worlds to life. And while it wasn’t all that long ago that rendering photorealistic images required a supercomputer, today we can do it right in our browser.

In this session, Dylan Beattie will explain the principles behind ray-tracing, the technique behind most modern computer graphics. - and then, using modern JavaScript APIs like web workers, clamped arrays and ES modules, we’ll create a pure JavaScript ray tracer that runs directly in your browser. We’ll learn how to simulate lighting, shading, reflection, and visual effects to create photo-realistic scenes, we’ll dust off some gnarly mathematics that you probably haven’t seen since high school and find out that it’s actually pretty useful after all, and we’ll create a whole lot of pictures of shiny things.

back to top

Why Do We Code?

“Learn to code” has become a mantra for the 21st century. From digital literacy initiatives, to boot camps, to innovations like the Raspberry Pi, we’re surrounded by platforms and systems that might be somebody’s first step towards becoming a professional developer. Tools that started out as a side project, in fields as diverse as finance, medicine, and cinema, are becoming successful applications in their own right - and the people who created those tools are realising that there can be a world of difference between writing code for a side project and managing a commercial software application.

One thing that all these scenarios have in common is motivation. What it is that inspires somebody to sit down, fire up a text editor, and start writing code? Motivation is why we started coding in the first place, and it’s why we sit down each day and start work – and understanding motivation can make a huge difference to what we do, how we do it – and how we feel when it’s done.

Join Dylan Beattie for an insightful look at the reasons why we write code - from neuropsychology to Newton’s Laws of Motion; from IDEs to ikigai. We’ll find out why open source projects succeed where well-funded corporate projects fail, why are there so many JavaScript frameworks – and why you’re still sitting up writing code at 3am, even though you know you have work in the morning.

back to top

The Human Touch: Reconnecting with Reality

Modern software is all about abstraction. We ship our code into the cloud, where it runs on virtual machines connected to virtual networks. We talk to our teams over email and Slack, our users’ requests and problems are distilled into tickets and issues and analytics - and, when you stop to think about it, that’s actually amazing! Technology lets us connect and collaborate in unprecedented ways; we can work together across platforms, continents and timezones, in ways that would have been unimaginable a few decades ago. But when everything’s virtual, it’s easy to lose touch with reality. When you stare at the analytics for too long, you forget each of those data points is a real person. You start with conversations, and then you start using “user stories” to capture the conversations, and then one day you realise the user stories are taking over and the conversations don’t happen any more. And, as we’ve seen from the ongoing controversies about the role of social media platforms, the endless appetite for growth at any cost can end up undermining the very things that made those platforms so compelling in the first place.

Dylan Beattie has been creating and thinking about software since before the world wide web was invented. Over the course of his career, he’s built real systems, that real people use to solve real problems; he’s used technology to create art, and music, and comedy… and, like many developers, he’s worked on a lot of things that turned out to be completely pointless, even though they seemed like a great idea at the time. Join Dylan for an entertaining and insightful look at the relationship between technology and the real world, from the industrial revolution to the information revolution and beyond. We’ll talk about human ingenuity, and how smart people end up using tech to solve their own problems in all sorts of unexpected ways. We’ll look at the future, and how technology is going to shape the world in the decades to come. And we’ll talk about how you, and your teams, can embrace the potential of the virtual world without losing touch with reality.

back to top

iPuzzler: Building a Pure JavaScript Web Component

From time to time, I create cryptic crossword puzzles, just for fun. I wanted a way to publish interactive puzzles on the web, and although there’s an open data format, iPuz, for crossword puzzles, when I looked around last year, I couldn’t find an easy way to publish iPuz puzzles on the web - so I created one.

iPuzzler is a pure JS web component that renders iPuz puzzles in a browser. In this talk I’ll explain how I built it - from working with JS modules and the shadow DOM, to simulating events, unit testing, inlining CSS, and why I chose to create it using pure JavaScript instead of using a framework. You might even learn a thing or two about cryptic crosswords along the way.

back to top

From ACK to ZOI: The Story of Software in Three Letter Acronyms

Developers love inventing acronyms almost as much as we love writing code. From APL to BFFs, from WWW to XML, new acronyms are popping up all the time. But if we want to understand developer culture, we need to embrace the language: the jargon and the acronyms that technology uses to describe itself.

Join Dylan Beattie for an alphabetical journey through the history - and future - of technology and software development, from the everyday acronyms that have become so ubiquitous we’ve forgotten they were ever acronyms in the first place, to the emerging jargon of quantum computing, cryptocurrency and augmented reality. Hardware, software, frameworks, algorithms, languages… acronyms are everywhere, and they’re not going away any time soon, so let’s get to know them all a little better.

back to top

Friends, Facts and FaceTime: Which Bits Can We Trust?

People are social creatures; from the moment we’re born, we begin to recognise faces and voices - who is this person? Have I met them before? Are they friendly? Can I trust them? Human interaction is informed by a rich vocabulary of body language, vocal inflections, and subconscious behaviour; it’s how we can tell when somebody is upset, or distracted; maybe even tell whether somebody is telling the truth or not. These concepts - identity, integrity, honesty - are the fundamental building blocks of the communities and societies which empower us to communicate and collaborate. But, as more and more human interaction moves online, we find ourselves communicating across a bewildering array of different channels and platforms: email, instant messages, video calls. The coronavirus pandemic has caused a revolution in remote working, but even before the pandemic, we were increasingly using digital services as an alternative to in-person contact. And yes, most of the time, doing things online is faster, easier, more convenient… right up until something goes wrong.

In this talk, Dylan Beattie will explore the history of digital identity, the evolution of remote working, and the future of online collaboration. We’ll look at social engineering, biometric authentication, blockchains, Slack chats, and internet poker. We’ll talk about neurodiversity and inclusivity, and how communication protocols can apply to humans as well as hardware. And we’ll discuss the fundamental challenges of digital communication: how do we know who we’re talking to? How do we know if they’re telling the truth? And if they’re not - what can we do about it?

back to top

Fractals, Factories and Fast Food

We live in a fractal world. Communications, transportation, utilities; from the devices on our wi-fi, to our homes themselves, to the towns and cities where we live and work, our world is built of networks within networks. Some networks are conceptual; models designed to capture one particular dimension of a system or a problem. Some networks are physical; the street outside our front door, the cables and pipes that bring power, water and data into our homes - even the human body is a set of networks, a constant flow of material and information from where it’s available to where it’s needed. And whenever we order a pizza, stream a movie, or even just switch on a light, we’re tapping into an unbelievably complex network of systems and connections that make these everyday conveniences possible.

Dylan Beattie is a nerd. He’s the kind of nerd who invents programming languages for fun. Dylan loves pizza and tech, he doesn’t like phone calls or washing up, and he thinks online food delivery is one of the coolest things we humans have ever invented. But in the grander scheme of things, the journey of a slice of pepperoni pizza - from the app, to the restaurant, to your door - is just a tiny part of a much bigger story. Join Dylan for an entertaining and enlightening look at the technical and social innovations that keep our networked world running: how did we get here? What happens when one of those networks fails? And what does our networked future look like?

back to top

Failure is Always an Option

Software runs the world. We use software to manage our calendars, talk to our friends, run our businesses - and, as our societies inevitably try to replace people and paperwork with apps and algorithms, we find ourselves facing some vital questions about the reliability of that software. If you take the time to actually read the terms and conditions, you’ll find that just about every system we rely on comes with no warranties and no safeguards - you use it at your own risk, and if it doesn’t work, that’s your problem.

But there’s more to building reliable systems than just writing good code. Reliability isn’t just about software engineering, it’s about systems engineering; about taking a holistic view of services that includes software, hardware, networks, and people. Join Dylan Beattie for an insightful look at the history of systems engineering, at some of the strategies and design patterns that we can use to build reliability into our systems, and at what happens when the software that runs the world has a bad day.

back to top

The Problem with Little Programs

The world runs on code. Here in 2020, you can’t watch a movie, book a train ticket, or see a doctor without your details passing through all sorts of programs and services. From websites, to email, to cloud databases and mobile apps, code has become a vital part of the infrastructure that runs our society. Maintaining and managing these vast, complex codebases is a huge challenge for our industry - but whenever we talk about innovation in the field of software development, we talk about writing new code, new platforms, new frameworks. Courses, exams, and interviews are all about writing code - about writing small, standalone programs to demonstrate a particular algorithm or pattern - and then developers land their first professional role and suddenly they’re expected to maintain a few hundred thousand lines of code they’ve never seen before. Join Dylan Beattie for an enlightening discussion about the problem of managing legacy code, the role of education in the world of modern software development – and the very nature of what it means to be a software engineer.

back to top

Keep Talking

We live in interesting times. The global lockdown of 2020 triggered a revolution in how people use digital communication technology. In April 2020, Microsoft CEO Satya Nadella said the firm had seen “two years’ worth of digital transformation in two months” – but the astonishing changes we’ve all been part of are just the latest thread in a rich tapestry of communication revolutions stretching back throughout human history.

As we all adapted to new ways of working, conferences and meetups become completely online events, often with hundreds of developers from around the world connecting digitally to be part of something remarkable. Join Dylan Beattie for a look at the technology that has made this possible – from the origins of language and writing, to the psychology of storytelling, to Starlink, WhatsApp and virtual pub nights. We’ll look at the innovations that got us here and their impact on society, and we’ll see how we as developers can use our voices and skills to make things better. We’ll talk about how our teams and companies have adapted in the face of the COVID-19 pandemic. We’ll talk about the future of our tech communities, and how technology can make them bigger, better and more inclusive. Finally, we’ll look into the deep future, to a time when humans have colonised the Solar System and are on our way to the stars – and find out why talking to your friends on Mars will never be as easy as it looks in the movies.

back to top

Computational Creativity

It wasn’t all that long ago that “computers” weren’t machines - they were people; humans working with pencils and slide rules to calculate taxes, artillery tables, even the mathematics that landed human beings on the moon. The advent of the microprocessor consigned these human computers to a footnote in history, and in the intervening decades, digital technology has revolutionised countless fields that were once considered too complex for automation - from mathematics and finance to music and movies. Now, as machine learning ushers in a new era of automation, we find ourselves confronting some deep questions about creativity, credit - and culpability. It’s all too easy to get sidetracked into hypothetical discussions about self-driving cars being programmed to choose which pedestrians they should kill - but there are real scenarios already happening all around us that raise exactly these kinds of questions.

When Hollywood uses digital technology to create digital characters that look uncannily like real actors, who gets the royalties? If a programmer creates an algorithm that uses Markov chains to generate song lyrics, who actually wrote the song? In a world where algorithms tell us what to watch, what to read and who to hire, can social networks still claim that they’re just platforms - or should they be treated as publishers?

Join Dylan Beattie - developer, musician, and creator of the Rockstar programming language - for a fascinating journey along the border between human innovation and digital automation, from mathematics to music and beyond.

back to top

The Cost of Code

Coders code. That’s what we do. We write functions and classes and modules, and we conjure amazing systems out of thin air. Electrons dance at our command; with a few keystrokes we can solve the most complex calculations, find hidden patterns in the data of our everyday lives, and send information flying around the planet at the speed of light.

The world uses our code to book flights, pay taxes, talk to friends and family… and before too long, our code might be driving cars, diagnosing illnesses and convicting criminals. Code runs the world. And when our code goes wrong, the solution is almost always… more code. We ship millions of lines of code every day – and, in these days of smartphones and networks and IOT, a single line of code could be running on millions of devices within minutes of us deploying it to production. But have you ever stopped to consider the real cost of those lines of code? Your code might end up running in production for years, maybe decades.

It’ll become one small part of a giant global codebase that’s using literally trillions of processor cycles and hundreds of billions of kilowatt-hours of electricity every year. A codebase that’s hiding countless vulnerabilities, flaws and dependencies. A codebase that’s driving users to buy millions of new laptops and smartphones and tablets every year because the old ones are too slow, or won’t run the latest apps. A codebase that is literally changing the world we live in - and not always for the better. In this talk, we’ll take a stark, sobering look at the real cost of the code we’re shipping every day. What’s the real cost of code - to our organisations, to our society, to our environment? How can we help our teams and users understand that cost? And what can we do to reduce it?

back to top

The Art of Code

Software and technology have changed every aspect of the world we live in. At one extreme are the ‘mission critical’ applications - the code that runs our banks, our hospitals, our airports and phone networks. Then there’s the code we all use every day to browse the web, watch movies, create spreadsheets… not quite so critical, but still code that solves problems and delivers services.

But what about the code that only exists because somebody wanted to write it? Code created just to make people smile, laugh, maybe even dance? Maybe even code that does nothing at all? Code that was created just to see if it was possible?

Join Dylan Beattie - programmer, musician, and creator of the Rockstar programming language - for an entertaining look at the art of code. We’ll look at the origins of programming as an art form, from Conway’s Game of Life to the 1970s demoscene and the earliest Obfuscated C competitions. We’ll learn about esoteric languages and quines - how DO you create a program that prints its own source code? We’ll discover quine relays, code golf and generative art, and we’ll explore the phenomenon of live coding as performance - from the pioneers of electronic music to modern algoraves and live coding platforms like Sonic Pi.

back to top

Architecture: The Stuff That's Hard to Change

We’ve all heard of the idea of ‘software architecture’. We’ve read books about domain-driven design and event sourcing, we’ve been to conferences and learned about micro services and REST APIs. Some of us remember working with n-tiers and stored procedures; some of us are still using them. But the role of a systems architect is still one of the most misunderstood things about the software development process. What does an architect actually do? If you’re working with a systems architect, what can you expect from them? And if you are a systems architect, what is your team expecting from you?

In this talk, Dylan Beattie will share his own insights into the idea of architecture as part of a software development process. We’ll explore some popular architectural patterns and processes – and a couple of obscure ones as well – and look at how, and when, you can incorporate those patterns into your own projects. We’ll talk about how the idea of software architecture has changed over time, and share some tips and advice for developers who find themselves working with architecture as part of their role.

back to top

Apps, Algorithms and Abstractions: Decoding our Digital World

It’s a familiar scenario. You’re on the train, your phone goes ‘ping’, you take it out of your pocket and hey — someone sent you a message! Awww… it’s a picture of a cat doing something funny. You send back ‘LOL’, you put your phone back in your pocket – but have you ever stopped to think about what’s actually involved in making that happen? Inside even the most basic smartphone there are literally hundreds of innovations, algorithms and inventions — but how do they really work? How were they developed? And what’s the next generation of algorithms and applications going to look like?

In this talk, we’ll take a deep dive into the technology behind those everyday experiences, and demystify the algorithms and abstractions that make our digital world go round. We’ll talk about cellular data networks, signal processing, the fundamental principles of filesystem design, compression algorithms, and even a bit of quantum physics. Whether you’re a programmer, a product owner or just somebody who loves using the latest tech, after watching this talk you’ll never look at your phone in quite the same way again.

back to top

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?

back to top

Ctrl-Alt-Del: Learning to Love Legacy Code

The world runs on legacy code. For every greenfield progressive web app with 100% test coverage, there are literally hundreds of archaic line-of-business applications running in production - systems with no tests, no documentation, built using out-of-date tools, languages and platforms. It’s the code developers love to hate - it’s not exciting, it’s not shiny, and it won’t look good on your CV - but the world runs on legacy code, and, as developers, if we’re going to work on anything that actually matters, we’re going to end up dealing with legacy. To work effectively with this kind of system, we need to answer some fundamental questions. Why was it built this way in the first place? What’s happened over the years it’s been running in production? And, most importantly, how can we develop our understanding of legacy codebases to the point where we’re confident that we can add features, fix bugs and improve performance without making things worse?

Dylan Beattie worked on the web application stack at Spotlight (www.spotlight.com) from 2000 until 2018 - first as a supplier,then as webmaster, then as systems architect. Working on the same codebase for nearly two decades has given him an unusual perspective on how applications go from being cutting-edge to being ‘legacy’. In this talk, he’ll share tips, patterns and techniques that he’s learned from helping new developers work with a large and unfamiliar codebase. We’ll talk about virtualisation, refactoring tools, and how to bring legacy code under control using continuous integration and managed deployments. We’ll explore creative ways to use common technologies like DNS to create more productive development environments. We’ll talk about how to bridge the gap between automated testing and systems monitoring, how to improve visibility and transparency of your production systems - and why good old Ctrl-Alt-Del might be the secret to unlocking the potential of your legacy codebase.

back to top

Domain Architecture Isomorphism and the Inverse Conway Manouevre

Most of us have heard of Conway’s Law: ‘Organizations which design systems … are constrained to produce designs which are copies of the communication structures of these organizations’. 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.

back to top

From 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 organisations 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.

back to top

The Web That Never Was

The story of the web is a story about freedom. It’s a story about information, breaking down barriers, and creating new ways for people to communicate, collaborate and share their ideas. It’s also a story that has as much do with marketing, money and meetings as it does with research and innovation. It’s a story of mediocre ideas that succeeded where brilliant ideas failed, a story of compromises, rushed deadlines and last-minute decisions. And it could so easily have been very, very different.

What if IBM had hired Digital Research instead of Microsoft to develop the operating system for their first PC, way back in 1980? What if Marc Andreessen and Jim Clark had gone to work for Nintendo in 1993 and never founded Netscape? What if one of the team at CERN had said ‘Tim, won’t it sound a bit silly if everyone spends the next 50 years saying double-you-double-you-double-you all the time’?

In this talk, Dylan Beattie will explore alternative history of the world wide web - a web with no Microsoft, no Windows, no Firefox, no Google and no JavaScript. A software industry from another timeline, a world of platforms, protocols and programming languages that are unmistakably alien - and yet strangely familiar.

So strap in, hold tight, and join us on a journey through… the web that never was.

back to top

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 object 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 50 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 it works and why it matters. 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.

back to top