PHP UK Conference 2022

Software developers all know: continual learning is part of the job. And that's what so many of us love about it. Innovation is constant, and it's an exciting challenge to keep up with so many new technologies. But where do all these new concepts, frameworks, and patterns come from? Let’s take a journey through the history of innovation to explore how different worlds collided to inspire new, radical ideas. Let’s discover how cross-pollination has helped our community grow into what it is now, and can help us think of new ways to solve complex problems. Join us for a session of inspirational stories that illustrate how cross-pollination has helped form some of history’s most profound innovations, and will hopefully inspire you to conjure up your own radical new ideas.

Never stop learning, how curiosity and cross pollination drives innovation-Pauline Vos - PHP UK 2022

During this presentation, we are going to look at the new features that were introduced in PHP 8.1. Join me to have a look at how the type system is strengthened with Enumerations and “never”, Fibers, a new closure syntax, the First Class Callable Syntax, intersection types, and other new smaller features. At the end you will have a good understanding about all the new and exciting features that are part of the PHP 8.1 release.

What's New in PHP 8.1 - Derick Rethans - PHP UK 2022

As developers, we want to work in a modern way, to get fast feedback on what we are building to make sure that we are building the right things in the right way. However, many companies are still at the start of their journey. Things take longer than we would like to get moving, sometimes change can seem to happen at a glacial pace and whilst you are ready to try and run, others are finding their feet - or even digging in their heels! In this talk, Stacy will go over some of the pitfalls that have happened to her, and the lessons that she has learned from them. Unfortunately, there are no magic solutions to make the problems go away, but hopefully, you can look at the mistakes she has made and go away to make your own new ones to learn from!

Embrace the Pitfalls (Our stop start journey to Change) - Stacy Cashmore - PHP UK 2022

When building Covie, Ian got to pick his tech stack, including where and how to run it. The choice was containerised on ECS with AWS, starting on Fargate…and so far, so good. He walks through how to set this stack up, with some tips and tricks along the way.

Container-native without k8s: PHP in ECS on AWS - Ian Littman - PHP UK 2022

OpenAPI is the standard way to describe your HTTP API, adopted by most modern APIs. With the spec at the centre of your workflow, you can improve the quality of your API and development practices, and make integrations painless. With standardisation comes tooling and in this session, I will show you to leverage this to your advantage. In this talk, Rob covers what OpenAPI is, why it’s interesting and then how to use it. He also looks at how the OpenAPI specification enables you to create documentation, use mock servers and improve the robustness of our API with validation. This session is ideal for anyone who wants to write an API specification once and use it everywhere.

Improve your API and OpenAPI - Rob Allen - PHP UK 2022

Well written instructions, informative comments throughout code, clearly scripted screencasts, and smart information architecture can take complex code and make it accessible to new developers. In the age of code sharing, this can be imperative to teaching the next generation of developers, passing along your code to successors, and help you better understand your own work.

Technically speaking: Improve Your Code With Documentation - Alexandra White - PHP UK 2022

Learn how to build and deploy serverless PHP applications. During the workshop Mike explores Bref, a way to run PHP functions and HTTP APIs on AWS Lambda. He deploys and plays with a pre-built application, as well as explore how you can migrate your existing workloads. AWS DynamoDB is a highly scalable document/key-value store, which offers a lot of flexibility for developers with a steep learning curve. He covers the basics of this platform, and set you up to learn and develop more, whilst avoiding potential pitfalls that might hurt your production applications.

Going serverless with PHP and Bref.sh - Mike Lehan - PHP UK 2022

Confused by JavaScript’s weird object model? Getting it, but still missing some details? You’re a JS master and you want to see your favourite object model in PHP land? In this talk, Milko digs into the JS object model and try to recreate it using PHP magic! He explores the JavaScript object model and recreate it in PHP.

Make me a JS Object Model - Milko Kosturkov - PHP UK 2022

In this talk Sam gives a quick overview of the past, present and future of authentication. From basic authentication to passwordless biometric authentication using the web authentication API, and everything in between.

Passwords are so 1990 - Sam Bellen - PHP UK 2022

We sometimes talk about businesses contributing to open source as a philanthropic act, it’s much more than that. Business is an important part of a healthy open source ecosystem, and the benefits flow in both directions. In this talk we’ll discuss how open source participation can be rewarding for staff and for the bottom line. Lorna covers ways to get started without impacting delivery of the projects you’re already working on, ways to pitch this to higher-ups, and times when it might be better to ask for forgiveness rather than permission. PHP is in every organisation, and it’s a great example of a thriving Open Source ecosystem. This talk is for everyone who wants to see a bright future for technology, open source, individuals and businesses alike.

Open Source is Good for Business - Lorna Jane Mitchell - PHP UK 2022

Fibers give us the stepping stone for more sane (looking) and modern async programming. But on their own, they don’t seem to offer much, so how does it work? Well, in this talk, Milko shows us how we do our own async Proof-Of-Concept framework using them and find out!

PHP Fibers - Milko Kosturkov - PHP UK 2022

Nowadays Kubernetes can run anywhere. On a developer machine, on premise, in a public cloud as well as on the edge. The common Kubernetes API makes it faster and easier to deploy workloads and manage network connectivity, storage, load balancing, security or service discovery. This allows you to leverage the best of all worlds and combine on-premise, private and public clouds to a hybrid environment that distributes your workloads as efficiently as possible. On the other hand, you quickly end up running not only one or two clusters, but dozens, or in edge and IOT scenarios even thousands or millions. In this talk Bastian will show how Rancher can help you to successful provision, manage and monitor these clusters, as well as the workloads running in them, regardless of the underlying infrastructure.

Managing from 1 to 1 million Kubernetes Clusters - Bastian Hofmann - PHP UK 2022

Over the past 16 years as a web developer Chandeep has seen his fair share of car crashes in projects. He's been lucky to move up the ranks to Senior Dev, Lead Dev, Tech Lead and now Solutions Architect. In this talk he shares some of the things he wish he knew to avoid the problems, stresses & late nights and deliver successful technical projects and delight your clients.

Technical scoping like a pro to build the right thing & be a superhero- Chandeep Khosa - PHP UK 2022

Blockchain is innovative and guarantees the fidelity and security of data and generates trust without the need for a trusted third party. The core lies in its ability to be secure, eliminate trust, being reliable and decentralized. It gives ‘POWER’ to all equally and creates transparency. In this talk Drishti shows us how to transform and become a blockchain developer with PHP. She talks about Digital Signature transaction encryption, avoiding counterfeit using node agreement. The core basis of blockchain and cryptography lies in the Cryptographic hash function.  She showcases what it is, how to choose and develop the hash function and all about cryptography, covering end-of-chain ambiguity, blockchain mining and mining pools. So, gear up and fuel your excitement for blockchain using PHP through her talk.

Hop on the PHP Blockchain rocket to the MOON! - Drishti Jain - PHP UK 2022

All developers know that bugs are bad and finding them can be difficult. The good news is tools to help us find and prevent bugs are becoming more powerful… Modern static analysis tools (e.g. IDEs like PHPStorm and tools like Psalm, Phan and PHPStan) are far more advanced than their predecessors. They can find a whole range of bugs whilst keeping the false positive rate low. Dave's talk introduces more advanced static analysis. It will show the kinds of bugs that the more advanced static analysis tools can find. He will then look at how they can be added to your current development work flow and he'll finally look at how we can write our code in such a way to get the most out of static analysis.

Practical Advanced Static Analysis - Dave Liddament - PHP UK 2022

Sometimes you need to get information from a website or mobile app and there isn’t a clean, well-documented API providing it. Enter web scraping. Ian goes through some tips and tricks to speed you along your journey.

Levelling Up Your Web Scraping Game - Ian Littman - PHP UK 2022

This talk comes from inheriting a complete, widely used open source PHP API library. It’s complete in that it has a full test suite, but problems arise from the approach of mocking JSON responses to assert tests on. The responses have to be maintained, and that can inevitably lead to false positives if the underlying API changes without the maintainer being notified. You can be clever and use a git submodule to bring in a standardised response that can be used by the same library in other languages, but then you need someone to maintain that across various departments of engineering.

From Betamax to VCR: harden your API integration testing - James Seconde - PHP UK 2022

In tech there are a lot of different people who 'lead' on different things. A mentor when you're joining a new company showing you the ropes of what exists and why thing are the way they are. A CTO responsible for your team's engineering function. A principal engineer working with you on some of the most complex problems. A team's tech lead who might organise some projects and focus on the team's technical direction & execution. An individual in the community who publishes content you find helpful or is responsible for a library you use. An engineering manager who supports you through your development. In this talk Michael will look at what good leadership in tech really means, the different kinds of leaders, how to become a leader in tech, and what great leaders can give you.

Leading in Tech - Michael Cullum - PHP UK 2022

So many people think that pair programming is a boring waste of time and effort. Stacy Cashmore is  here to explain how her team made it work, and what benefits they got out of it! She loves working in a team, bouncing ideas off each other and using their combined strengths to produce something that as individuals they wouldn't be able to come up with. One way she likes to do this is pair programming. Stacy shows you how they went from this sleepy type of pair programming to being super productive when working with multiple developers at one machine! Not the one person working, one person staring into space type of pair programming, but actually providing value to each other, making the extra effort worthwhile, and bringing extra benefits to the team as a whole.

How to really work as a team- from sleepy to strong pair programming - Stacy Cashmore - PHP UK 2022

PHP UK Conference 2023

If an autopilot fails, or a weapon system malfunctions, lives can and will be lost. As a result, significant checks, practices, and concepts go into designing the software for such systems. But the code we, as developers in a wide range of jobs and fields, write can be just as critical - a delayed benefits submission because of a server error causes somebody to become homeless; a mistake on an immigration system causes a family to be deported; a misrouting of a delivery driver causes a car crash.

As developers we should explore the culture around what we build - move fast and break things doesn't work if you're dealing with real people's real lives. Are there lessons of software development, design, project management, that we can learn from "mission critical" software production, and apply to our "normal" development projects that can ultimately save frustration, jobs and even lives in the process?

Your Software is Mission Critical - Mike Lehan

During this presentation, we are going to look at the new features that were introduced in PHP 8.1 and 8.2. Join me to have a look at how the type system is strengthened with Enumerations and "never", Fibers, a new closure syntax, the First Class Callable Syntax, intersection, and disjunctive normal form types, read-only classes, and other smaller features. At the end, you will have a good understanding about all the new and exciting features that are new in PHP 8.1 and PHP 8.2.

What's New in PHP 8.1 and 8.2 - Derick Rethans

Many Git users tend to use Git as a save point, like in a video game; chronologically making checkpoint commits as they go. This spreads out changes to the same areas in the code over several commits, necessitates merging and resolving conflicts, and generally just making an incomprehensible jumble of your history. This talk makes a case for atomic commits and how to use them while only minimally affecting your workflow. Using pre-recorded demos, you’ll learn how to properly interactively rebase, fix up, reset, bisect, and more. By the end of the talk, you’ll have seen how this Git flow will make your life easier and how it will affect your ability to cherry pick, drop unwanted commits, and most importantly: not spend hours resolving conflicts in rebase hell. A little change in habits can go a very long way!

IS NOW Git Legit - Pauline Vos

You've started a new job. As you dig deeper into the codebase, the WTFs per minute rate rapidly increases, and you're left wondering... 'Where do I start?!'. In this talk, I'll draw on my own experiences of joining several different teams to help maintain their legacy codebase. You'll come out of this talk with a better understanding of when you should or should not refactor existing code, the importance of communication, documentation, testing, and ideas for automated tests and checks.

Living the Best Life on a Legacy Project - James Titcumb

In this session Paul is going to share with you his tips & tricks learned when building top quality CI pipelines for large organizations such as the UK Government, banks and the private sector. Using Continuous Integration already? Whether you're a beginner or CI ninja, you'll gain value from this session as we cover a broad range of topics. We'll look at how we can leverage tools like Docker, Jenkins, AWS to truly push CI pipelines to the limit. After this session you'll walk away with new ideas, new tools and lots of real-world experience, to set you on your way.

Continuous Integration: Tips & Tricks - Paul Dragoonis

There are so many benefits from code review; lower development costs, increased code quality, quick up-skilling, and onboarding of team members. Despite these benefits, many teams don’t have code review as part of their process at all. Others don’t get the gains they should from it.

This talk first outlines the business case for code review. It then explores how to make code review effective, specifically looking at:
- Expectations of what can be achieved with code review.
- What should be covered by code review (including example code)
- What should not be covered by code review
- How to write code that makes code review easy
- What makes good code review comments
- What makes good responses to code review comments

Finally, to wrap up you'll be shown how to enable a code review with Github. Spoiler alert: It can be done in under 5 mins!

Effective Code Review - Dave Liddament

Kubernetes makes it easy to deploy, manage and monitor your cloud native applications. Security can be a challenge in such a dynamic, containerised environment, though. Ensuring that your containers are not containing vulnerabilities is vital throughout the complete supply chain, from development and CI through deployment and admission controls to security at runtime. 

In this talk you will see how NeuVector, the first Open-Source Cloud Native Security solution can secure the complete software development lifecycle and even protects against unknown or unpatched vulnerabilities with its zero-trust runtime security model.

Protect against unknown security vulnerabilities - Bastian Hofmann

What happens when you just ride the wave? How productive can we be when we smother our project in all that Symfony goodness? Let's explore some Rapid Application Development practices that Symfony has to offer. We'll acquire the mindset needed and get ourselves familiar with a Symfony setup by the book. We will develop an MVP using the MakerBundle and we'll close the gap towards an MLP using Symfony UX. Live demo included.

Symfony is RAD - Rick Kuipers

APIs are everywhere. Some companies sell theirs and publish documentation alongside it. Others expose just enough APIs to provide value to the end users through a website or app without ever intending them to be used for any other purpose. Your API is the purveyor to some valuable data, and attackers are eager to get at it. This session will cover some of the methods attackers use to reverse engineer your API and some steps you can take to thwart them. 

The session will begin by demonstrating a few methodologies on how traffic to an API can be "sniffed" and analyzed. We will then discuss authentication with API keys and OAuth2 and the differences and pitfalls of each. We'll touch on some low hanging fruit on hardening your API: TLS encryption, certificate pinning, and some less obvious techniques including HMAC request signing, obfuscation, compilation protection, and more. 

At the end of the session you'll have a better understanding of the cat and mouse game that is API security, the knowhow of the tools and techniques attackers might be using to get at your data, and some steps you can implement to better your API's security.

Attackers want your data and they're getting it from your API - Tim Bond

Level: Intermediate/Advanced

Do you wish that PHP had features that other languages have? Have you got some great ideas about how to extend PHP’s feature set but don’t want to go through the RFC process? Great news. There is another way. It is possible to implement some new language features using static analysis. 

This talk will briefly introduce the PHP Language Extension library which offers features such as Java’s package level visibility and C++’s friend feature. Then, we’ll take a deep dive into how to create a custom PHPStan rule. By the end of the talk, hopefully you’ll be inspired to create your own enhancements to PHP, or at the very least have a starting point to write your own custom rules.

Extending the PHP Language with Static Analysis- Dave Liddament

Your career can feel like it is taking all the energy you have inside of you. You’re dreading the next working day, and you keep wondering if this is what you are going to do for the rest of your life. But what if it isn't? What if you find a job that makes you feel like you are on top of the world, all while being productive as well? 

During my talk I will share the lessons I have learned after changing my career, what the points are you need to take into consideration when making such a decision, and how this actually resembles climbing a mountain very well.

Stories from a career dropout - Femke Buijs

As developers we assume the responsibility of planning, architecting, building and maintaining our individual patches of cyberspace. Our codebases are the landscape of our virtual cities and this landscape must be cared for. From the perspective of a geography graduate turned software engineer, let's explore the parallels that exist between the built environment we inhabit and the virtual environment we are creating.

We built this city... The geographies of software development - Naomi Gotts

Level: Beginner

What's the difference between service location and dependency injection? Why is this dependency injection thing such a big deal anyway, and how do you use that tool correctly? I'll answer these questions and more, including real-world examples of refactoring an application toward the more explicit, testable, closer-to-SOLID applications.

Dependency Injection for Mere Humans - Ian Littman

Do you think the PHP interpreter is black magic and C is just like alchemy for you? Are you interested in harnessing some of that magic for yourself? This talk will give you an overview of how to develop an extension for PHP using rust. You’ll see how to setup up a simple example and how to add more elaborate features to it. After getting to know some general tips you’ll learn about some pitfalls and how to circumvent them. Equipped with this knowledge you’ll be able to work some of that PHP interpreter magic yourself.

Your first PHP extension - Christian Rades

Programming is passion and vocation for many developers, but sometimes you find yourself in a job situation that destroys your love for coding – it happens to the best of us and makes you question everything. This talk is about how I bugfixed my career and regained contentment and meaning in my work. I will pass on lessons I learned on how to protect yourself from false loyalty, get out of a job you once loved, take calculated risks and find your own field of passion.

Bugfixing your career - Diana Scharf

PHP has added more and more types in the last couple of versions. But what is the meaning of a type, a type system, and a subtyping relation? In this talk, we will explain those words, and see what comprises the PHP type system, how it checks for types, how it uses and implements Liskov's Subtitution Principle (LSP) for it's subtyping relation, and how the strict_type declare affects PHP's type system.

PHP's type system dissected? - George  Peter Banyard

You code the app. You've used Test-Driven-Development for it, because you do things the right way. You care about the quality of your code. You ship it. The job is mostly done! EXCEPT, of course, now that your app has -you know, users- performance is down. You've got a Redis instance caching sessions and database queries, but it's not enough! Your problem needs a bolted-on solution - maybe throw something else at it, like Varnish? We don't do Performance-Driven-Development in PHP, and we should. The problem is in the code, not the caching. In this session I'm going to show you how it's done.

What is Performance Driven Development and why aren't you doing it? - James Seconde

You’ve probably heard stories about the Rust programming language, and you’re probably wondering why it’s becoming so popular. In this talk, you’ll see what Rust is from a PHP developer’s perspective. Get ready for a live-coding session, where we are going to recreate an existing PHP application in Rust, from scratch, and demystify all the awesomeness behind it.

Rust For PHP Developers - Nuno Maduro

Reader, be aware: this is not a blockchain talk! The web we knew and loved has become a massive machine led by a small number of tech giants, controlling your data, hogging money, and burning the planet. Tech thought leaders and pioneers recognize the state of the current web for what it is: unsustainable. Find out in this talk which inspiring technologies lie ahead for us, that will help us take back control of our beloved web.

The bright and exciting future of the decentralized web - Pauline Vos

Level: Intermediate

At re:invent 2018, Amazon released custom runtime support and Layers for their Lambda function-as-a-service runtime. With this release, the fact that the company still doesn't have an official PHP Lambda runtime becomes more or less irrelevant, since we as developers can create our own without undue overhead. 

This talk will show you how Lambda custom runtimes work, how to build one that speaks PHP, and how to use pre-built custom runtime layers for either one-off job processing or behind a load balancer or API Gateway to serve web traffic with extreme infrastructure elasticity.

PHP on Lambda with Custom Runtimes - Ian Littman

Level: Intermediate

Reading and writing files locally comes with many nuances and difficulties. It becomes even more complex when files are hosted on external servers like SFTP, AWS S3, Azure, and other providers. Flysystem provides an abstraction layer between an application and interacting with the filesystems. Explore how to use Flysystem Adapters for seamless file management for writing, reading, moving, copying, deleting, and other file interactions. See how to set permissions, configure adapters, get file information, stream files, write unit tests, and more in this technical dive into file management with Flysystem.

Filesystem Management with Flysystem - Mark Niebergall

As a Software Developer, we’re expected to inhale new technologies from the latest libraries within our core programming languages to the latest cloud deployment platform, from programming the smart lights to the latest security enhancements of ipv6. Most recently I’m diving into a new backend technology and I invite you to join me as I hack my way to understanding. I will provide specific examples, from using an IDE to knowing when to give yourself a break so you can return energized and focused, and conclude with practical recommendations as you dive into your next new technology.

Diving Into New Technologies: Hacks to Work More Efficiently- Rain Leander

Level: Beginner

Assuming little or no existing knowledge of Docker, we will learn how to build images of our applications and run them locally as containers.

We will also look at how to orchestrate multiple containers using Docker Compose, with some tips and tricks for typical local development workflows.

Docker for development - Ciaran McNulty

Since Drupal 8 and the big migration to Symfony components, the Drupal community has progressively moved away from some of its custom tools and habits, opening up to more standard practices in the PHP and open source ecosystems. Let’s take a look at what was accomplished, which ‘drupalisms’ remain, and what the future will bring.

Bye bye drupalisms! Propelling Drupal into a modern PHP ecosystem - Marine Gandy

When you've been tasked with creating an HTTP API, the fundamental decision you need to make is which architcture to choose. Should your API be RESTful? What about GraphQL? or (g)RPC? In this session, I'll explain the choices and how each works. We'll then look at their strengths and weaknesses in order to help guide your decision. By the end of this talk, you'll be well-placed to choose the right API architecture for your project.

GraphQL, REST or RPC? Making the choice! - Rob Allen

PHP UK Conference 2024

PHP is a truly amazing language. You probably use PHP to create beautiful websites and services in an expressive way. But the language is capable of so much more than what you'll probably program in your day to day job. In this entertaining talk, we'll take a look a couple of surprising ways to use PHP. You'll see lesser known functionality being used such as weak maps and process control functions. We'll also cover a couple amazing open source PHP projects that have borrowed inspiration from communities outside of PHP such as Tailwind and Phoenix. After this talk you'll be even more convinced how truly flexible PHP. You'll also have learned a couple of functions and packages that you can use in your next project.

Fantastic functions and where to find them - Freek Van der Herten

Have you ever wanted to write a desktop application? Using existing tools? Even with PHP?

Well this talk is for you! Let me show you NativePHP - a Laravel Package that allows you to create desktop applications with PHP code. You can make use of native system APIs, clipboard access and more!

Building desktop apps with PHP - Marcel Pociot

In 1905, the Spanish philosopher George Santayana famously wrote the line 'Those who cannot remember the past are condemned to repeat it.' Like death and taxes, nothing can escape this inevitability. And so, the same is true of API evolution. We're going on a journey.

Awful APIs: A History Lesson in Painful Industry Mistakes - Jim Seconde

The objective of this tutorial is to get an overview of writing tests for a PHP extension, how to implement new functions/methods and how one can use some internal object hooks to create functionality which is not available to normal classes.

How to contribute to PHP - Gina Banyard

How are you supposed to organise your models in an MVC application? What goes where? What is a service class, a mapper or an entity? Domain Driven Design focusses on modelling the domain logic and helps us to map the business requirements to our software. We'll discuss the terminology and take a look at what Domain Driven Design is and see how you use it to provide the model logic for your application decoupling it from your controllers. By the end of this session you will be equipped to create excellent, maintainable models in your application.

An introduction to DDD - Rob Allen

Test doubles (a.k.a. “mocks”) managed to gain a bad reputation over the years for causing unreadable and hard-to-maintain tests. Years of misuse led to some programmers advising against test doubles. Even though they are fundamental in the London school of Test Driven Development.
In this talk, Jakub will go back to the origins of the technique to explain scenarios when it's best used and look at common pitfalls. We’ll discuss various types of test doubles based on examples and show how to make them trustworthy. The key to success, as it turns out, will be a combination of contract (role) and collaboration tests.

Your tests are mocking you - Jakub Zalas

Started in 2017, Bref is an open-source project that helps run PHP serverless on AWS. Today, Bref is used by thousands of companies and handles over 10 billion requests and jobs each month.

But how does it really work? Not just the 'hello world' demo where we take a basic Symfony or Laravel app and deploy it with a few commands. I invite you to lift the hood and understand how Bref runs PHP, how AWS Lambda scales, how it runs on servers and their data centers down to the bare metal. A compilation of public information, as well as experiences and surprises encountered while maintaining Bref over the past 6 years.
If serverless has always been vague or confusing to you, it will no longer be magical after this.

Serverless PHP: how does it really work? - Matthieu Napoli

At some point of your career you'll probably end up working on a majorly outdated version of a framework and prehistoric version of PHP. After months of whinging to the management that it really is time to upgrade, your wish is granted! You've got to take a creaking codebase to the future, or, at least the present. But how best to achieve this?

This talk tells the story of upgrading a Laravel 4 project to Laravel 9. I'll share the things we did well, and the lessons that we learnt along the way.

Regardless of framework and versions, this talk gives practical advice for planning and executing a major upgrade.

Elevating Legacy: A Case Study on the migration from Laravel 4 to 9 - Dave Liddament

Have you ever sweated away for months and finally achieved 100% coverage, but your customers still complained about bugs? Do you never feel satisfied that you can fully rely on your tests, even though you have data providers with all sorts of weird values in them? Are you certain that at least one test would fail if you introduced an error into any given line of code in the codebase? Do you have less than 100% confidence in your test suite?

How can you be sure that the code your colleague wants to merge to `main` via the `super-new-feature-branch` is adequately tested beyond the ‘coveralls’ report?

The Absolute Beginner’s Guide To Mutation Testing - Neal Brooks

A relational database has long been the go-to choice for PHP application developers, but as applications grow the data doesn’t always fit the relational model. Perfect normalised data structures have their place, but in the world of rapid delivery, cloud computing & microservices developers need more in their toolbox.

This talk looks at when you might want to try a different data store, and how you’d look to build out or migrate to a new service. We’ll look at queues, key-value, document stores primarily (with some specific examples in Amazon DynamoDB, MongoDB and Redis). We’ll also look at some emerging database types such as graphs and ledgers.

Beyond Relational: Data storage for modern applications - Mike Lehan

Writing a third-party integration would be impossible without API documentation and yet we continue to push it down our list of priorities or we create half-baked solutions that become immediately out of date.

In this talk we take a look at Scribe, a powerful package for Laravel that generates human-readable API documentation right from our code.

The talk will include a live demo of how to create documentation from an existing project.

Documenting Laravel APIs - James Brooks

Burnout today is one of the biggest problems in the industry, as studies show, the industry is evolving and trying to solve this problem using things like emotional salary or other types of incentives that allow us to have a better work-life balance. But the question that arises is, is there something else we could do that would somehow reduce burnout or at least try? In this talk we are going to see how Extreme Programming done well could help improve your quality of life at work and why. Going from what's XP, how each of the values, principles, and practices are related to each other, and how they could be a tool for us and our companies.

Improving your life with Extreme Programming - Emmanuel Valverde Ramos

Generative AI in 2024 has a consent problem. Scraped and otherwise stolen datasets are used to produce output that can directly compete with the people who generated the source data. This doesn’t have to be our future. The Common Voice project collects volunteer donated speech data to freely offer academics, industry and language activists a future where meaningful linguistic diversity is built into the digital products and services that increasingly fill our world. By teaching computers the way that real people speak, Common Voice doesn’t just offer a better connected future for global users, but presents us with one possible consent led model for community driven data collection. Together, let’s explore how community led dataset collection, design and governance structures have developed across speech datasets and look at how freely donated data, data trusts and other consent led collection models could offer a less dystopian AI future. An exploratory look at the proliferation of consent led data collection models in speech datasets, looking not only at Common Voice's CC0 donation-led approach but also looking into how data collection and governance models that offer more granular data control (like language community led data trusts) could offer AI and all of us touched by AI a less dystopian path into the future.

Community Driven Data Collection and Consent in AI - Jessica Rose

There are no secret tricks or shortcuts to leveling up in your career: talent and hard work are still the main recipes for success. But in terms of mindset, there are some things that can make a difference. And while I don’t claim to know all the answers, I’d like to share 10 tips that helped me in my career. In this keynote I’ll cover topics like passion, expression, communication, perception, patience, empathy, risk & creativity. While the title makes it look like a Buzzfeed-style article, these 10 tips & tricks are a guideline in a series of stories I’ll share with you. Take from it what you want. No success guaranteed though. And no refunds! 😉

10 things that helped me advance my career - Thijs Feryn

During this presentation, we are going to look at the new features that were introduced in PHP 8.3, and some in earlier versions. Join me to have a look at how the type system is strengthened with Typed Class Constants, Readonly Classes, Arbitrary Static Variable Initialisers, Overloaded Method Markers, and other new smaller features and clean-ups.

At the end you will have a good understanding about all the new and exciting features that are part of the PHP 8.3 release.

What's New in PHP 8.3 - Derick Rethans

Delve into the power of Symfony UX to significantly enhance user experience in your projects. Explore core tools like Turbo and Stimulus that enable seamless integration of frontend dynamics with Symfony's backend-centric approach, often requiring minimal to no JS. The cherry on the cake? We'll unravel how this can be achieved without any nodejs tooling or bundlers thanks to the 'importmap' directive, paving the way to accelerate your development cycles without compromising on rich UI interactions. Uncover a faster, smoother, and more efficient dev journey with Symfony UX!

Boosting Web Engagement with Symfony UX - Mathéo Daninos

Everybody knows that WP-CLI makes you the most powerful person on the server. But did you know you can be the most powerful person on a remote server without ever logging into the server?

Alias is not yet another WP-CLI command. Alias is your best friend, the one who knows all your passwords. If CLI tools make you smart because your work is fast and efficient, the alias will make you a sorcerer because it will feel like magic. Ready?

Alias WP-CLI - Milana Cap

When faced with a challenging legacy code base, tightly coupled and void of discernible structure: a big ball of mud, it is common to decide to refactor this monolith to a microservice architecture to separate concerns and split the codebase up, however without any clear boundaries you are in danger of creating a distributed big ball of mud.

You may recognise the symptoms of a distributed ball of mud: a large unfocused 'common' library shared between multiple services; performance issues as your front end makes calls to multiple back end API's to serve a single request; dependency hell on deployments as you have to release multiple code bases simultaneously and uptime issues as a single microservice going down brings down your entire application.

In this talk I'm going to cover some of the common pitfalls you might encounter when building a microservice architecture and show you how to use an event driven architecture to build truly scalable microservices.

Microservices vs The Distributed Monolith - Chris Riley

You probably already know that talking out loud can help you solve a problem (even if you don't want to admit it). People have even coined the term rubber ducking to help normalise it!

What would happen if the rubber duck talked back?

The ability to constantly discuss your code and what you are going to do next is just one of the many benefits of Pair Programming.

Pairing, Sharing, Caring - One team's journey to Pair Programming - Mark Bradley

I've been teaching Git for years, and everywhere I go `git bisect` seems to be a bit of a mythical beast. Some people have heard of it, very few know what it is, and almost nobody knows how powerful it can really be. In this talk, you'll find out not only what bisect is and how it works, but also all the ways in which it can work for you. From finding a specific point in your history lightning fast, to making it debug for you using a combination of bisect and regression testing.

The Business of Bisecting - Pauline Vos

I truly believe Dagger is the next evolution of CI/CD implementation. As a subject matter expert in CI/CD, I spent years building the perfect system to mitigate challenges we face at a tech level and business level. Now along comes Dagger, created by Solomon, the founder of Docker, and it makes so many challenges disappear, by design, and opens up so many new possibilties along the way.

In this talk I'll be your guide in a deep dive into Dagger-land, demonstrating how to strategically start integrating this into your existing projects and start benefiting from the awesomeness.

Cutting-Edge Continuous Integration with Dagger - Paul Dragoonis

The ever-evolving landscape of web development often places frontend and backend developers in two separate camps. However, backend developers are increasingly faced with the task of improving the speed of underperforming websites. With page speed and good user experience key factors in the success of modern websites, anything which slows down page loads is bad for business. The good news is that enhancing website speed is not solely the domain of frontend developers!

This talk focuses on easy-to-implement 'quick wins' that can significantly boost website speed from the backend. These tactics don't require an extensive understanding of frontend frameworks or languages. With simple code changes and optimisations, backend developers can dramatically improve frontend speed and user experience, without getting bogged down in node version mismatches, build process failures, or any of the other usual frontend bogeymen!

The key areas covered will include:
- Faster Font Loading: Custom fonts are a key part of modern website design, but heavy font weights can hurt page performance. We'll cover a combination of loading techniques and ways to effectively shrink the file sizes right down.
- Smoother Image Presentation: We'll go over the 'dos and don'ts' of effective lazy loading, using responsive images, and optimising image formats for faster rendering.
- Efficient Video Integrations: Youtube embeds are increasingly common, but can add a lot of weight to a page load. We'll explore ways to have lightweight video embeds, getting the benefits of video without slowing down your site!
- Minimising the impact of ads on your page speed score: Ads are often a necessary evil on sites - evil compounded when their typical loading pattern hurts our page speed scores! We'll go through practical examples to minimise the impact of your ad stack on your page load times.
- Measuring the impact of our changes: How do we know that our changes have had a positive impact?

This is a practical talk, which will feature real-world examples and code samples to demonstrate how these techniques can be easily implemented. Attendees will leave with actionable insights that can be applied immediately to optimise their websites.

Boosting Frontend Speed: Quick Wins for Backend Developers - Paul Conroy

SQL databases are an important part of many web applications. But what's the best way to interact with such a database? Do I use hand-crafted SQL statements everywhere in order to always remain in control? Or do I use an ORM, so I don't need to repeat myself too often and to remain compatible with multiple SQL databases?

We will take a deep dive into the Doctrine libraries ORM and DBAL as well as native PHP extensions and compare them with our use cases in mind.

How much database abstraction do I need? - Alexander M. Turek

Join us on an exploration beyond traditional PHP boundaries in this enlightening talk. Delve into practical examples showcasing PHP's versatility in three distinct realms: Infrastructure as Code, WebAssembly (WASM)-based serverless, and browser-based applications.

Discover how PHP can seamlessly adapt to the dynamic landscape of modern development, empowering developers with hands-on insights into its potential across varied domains.

Prepare to embark on a journey where PHP boldly ventures into uncharted territories, pushing the boundaries and changing the terms of fullstack PHP.

Where No PHP Has Gone Before - David Flanagan

Besides the traditional rule levels 0 through 9 which allow developers to adopt PHPStan incrementally while increasing the strictness gradually, the static analyser offers plenty of other configuration options to look at the code with a critical eye.

In this talk I'll show you these options with examples of practical impact on your code. It will become more predictable and readable.

Tuning PHPStan to Maximum Strictness - Ondřej Mirtes

PHP UK Conference 2025

Join five expert speakers—Nils Aderman, Paul Dragoonis, Gina Banyard, Katy Ereira, and Ivo Lukač—as they dive into the world of PHP, sharing insights and answering questions from the community.

Panel Discussion PHP UK 2025

APIs are at the heart of modern application development, and OpenAPI is a powerful tool to streamline your API development lifecycle. In this talk, we’ll explore how OpenAPI can enhance your projects and how an OpenAPI description evolves through the build process to power up different aspects of your project. Get hands-on examples of the cool tools to use with OpenAPI to transform the API descriptions, produce documentation or client SDKs, or mock up the API for testing. With practical tips and pointers to further resources, this session is perfect for anyone using APIs who wants to make them just a little bit better. Come along and get ready to take the next step in your API journey.

OpenAPI for Web Developers - Lorna Mitchell

FrankenPHP is a modern application server for PHP written in Go and integrates the popular Caddy web server.

FrankenPHP gives your projects superpowers: worker mode, native real-time capabilities compatible with Laravel Broadcast, resource preloading with HTTP 103 Early Hints code, automatic HTTPS, HTTP/2 and HTTP/3 support, modern compression, Prometheus metrics... Find out how to boost your applications with FrankenPHP!

Give your PHP apps superpowers with FrankenPHP - Kévin Dunglas

Continuous integration pipelines have typically been the responsibility of devops teams, despite the fact that day to day, developers have far more interaction with them and would be better placed to maintain them. Often this is exacerbated due to different tools being used for the pipelines than the ones developers use on their own machine. Enter Dagger. Dagger is a solution which allows for building pipelines, built on top of Docker, which run exactly the same on the local development machine as they do on the CI/CD servers. In addition, Dagger modules can be written in multiple different languages and composed into a single pipeline, removing the barrier of entry for developers to maintain their own pipelines. In this talk I’ll show you the work we’ve been doing recently on the Dagger PHP SDK and how you can sharpen up your own CI/CD pipelines.

Sharpen up your CI/CD pipelines with Dagger - Chris Riley

PHP is what one can call a truly organic language, in that it was never designed from scratch. And at 30 years old it has shown to be a reliable programming language which powers most of the web, but not just. However, it also has some quirky behaviours and edge cases that still linger and are waiting to be discovered.

So join me in this fun talk where we will explore some of PHP's utterly baffling behaviours, and how some of them have been fixed after being discovered in recent versions of PHP.

Modernizing PHP one edge case at a time - Gina Banyard

There is a lot of frustration among developers when they need to work with the old code, usually called “legacy”. But there is way more legacy code running than non-legacy out there in the world. Developers like starting from scratch but that is not often the case. If they want to successfully replace legacy with newer code they need to start with appreciation and respect for that legacy code because it somehow runs and there is no guarantee that new code will do a better job.

Learn to appreciate legacy (Story about Zed) - Ivo Lukač

Everyone has heard of supply chains at this point, but what exactly does that mean for a PHP project? Learn more about software supply chains, how Composer, packagist.org and Private Packagist come into it and which role PHP dependencies play. This talk will present concrete steps you can take to identify your dependencies and give advice on measures you can put in place to better manage and protect how your application is assembled.

Composer Guide to Supply Chain Security - Nils Adermann

Handling millions of API calls in production can be overwhelming. Everyone uses Guzzle, but in this talk we'll deep dive into using its underutilised middleware for efficient API monitoring. We’ll dive into logging with Kibana, error enhancement with Sentry, tracing with OpenZipkin and Jaeger, and making use of Prometheus metrics with Grafana, Alertmanager and KEDA. Drawing from my experience building an application that makes millions of API calls each week, you'll leave with actionable insights to keep your microservices and third-party APIs stable under pressure.

Beyond Requests: Supercharging API Monitoring with Guzzle Middleware - Liam Hammett

Have you ever encountered a codebase that’s ogreish and has so many layers of complexity that it makes you cry? It might actually be an onion!

In this humorous talk we’ll investigate the structure of large monolithic applications and how we can peel back layers to reveal greater understanding. Using the principles of hexagonal architecture and the science of onion growth, we can make monoliths great again.

Shrek, Onions and Architecture - Katy Ereira

Injection Vulnerabilities remain in the "OWASP Top 10" and the "CWE Top 25 Most Dangerous Software Weaknesses". Unfortunately database abstractions (like Doctrine), or parameterised queries, do not prevent Injection Vulnerabilities (I've got several examples); so they can create a false sense of security (especially with complicated code, or when junior developers are involved). Fortunately there is a simple solution to identify these mistakes, by “distinguishing strings from a trusted developer, from strings that may be attacker controlled” (Mike Samuel, March 2019; and Christoph Kern, September 2014). This can be done in PHP with the `literal-string` type (using PHPStan and Psalm). It's been proven to work in other languages (Facebook/Meta use the LiteralString type in Python; and Google use the "un-exported string type" in Go), it works really well with our existing code, and it guarantees there cannot be any mistakes that lead to an Injection Vulnerability.

Ending Injection Vulnerabilities - Craig Francis

This talk is based on our work deploying both the server infrastructure, as well as thousands of industrial computers around the globe, some of which are connected over slow 3G connections.

Deploying at scale with a single click - Wim Godden

Twenty years ago, I had a problem. I was working as a consultant introducing teams to ideas like continuous integration, pair-programming, and test-driven development. I was, and still am, a fan of TDD, and I was frustrated with how hard it was to get people to even try it. Most of the objections stemmed from the word ‘test’.

I tried changing my approach, using language like ‘code example’ and ‘executable spec’, and not mentioning tests at all, and that seemed to land better. People were certainly more willing to give it a try!

Fast-forward 20 years and I am amazed at the traction BDD has had. It has spawned a host of books, most of them fantastic, none of them by me. It gave rise to an ecosystem of automation tools starting in the Java and Ruby worlds as JBehave and RSpec respectively, and then exploding into the Gherkin-based tools of Cucumber, Reqnroll (née SpecFlow), and PHP’s own venerable behat.

Since PHPUK is also 20 years old this year—happy birthday!—it seems appropriate to look back over two decades of BDD to see how far we have come, what might be coming next, and why I think Cucumber-like tools are overkill for almost any use case (but fantastic when they aren’t).

20 Years of BDD - Daniel Terhorst-North

All the talks for PHP UK Conference 2026, all in one place.

PHP UK Conference 2026

As a consultant I'm often asked absolute questions, "Is $x better than $y?". The answer is nearly always "It Depends".

Software development is a constant game of give and take. Every day we (consciously or not) make numerous decisions and trade-offs in order to get our code shipped. I've found that making these tradeoffs front of mind when I'm working means easier and better decisions.

Let's take a look at some of the more common decisions we make day-to-day and try and figure out what the compromises are. Hopefully you'll start looking at more decisions as tradeoffs, and make better choices yourself in future.

It Depends - Gary Hockin

Static analysis tools like PHPStan have become essential for PHP developers, and all projects can greatly benefit from custom rules tailored to their specific needs. In this talk, I will guide the audience through the process of writing custom PHPStan rules to enforce project-specific standards and catch domain-specific bugs, and freeing up valuable time by automating repetitive code review tasks.

Crafting Custom PHPStan Rules - Ondřej Mirtes

In modern architectures, loosely coupled subsystems collaborate via events rather than giving each other direct instructions. This is referred to as event sourcing if the entire state of an application can be reconstructed from these events.

I teach you proven strategies and best practices for testing event-based software. Using PHP and PHPUnit as examples, you will see how tests can be implemented to generate visual documentation of event-based software through their execution.

From Events to Insights: Testing and Documenting Event‑Based Software - Sebastian Bergmann

I'll show how we're building native mobile apps with PHP and go deeper into how it works

Building Native Apps with PHP - Simon Hamp

In this talk I explain how to use Xdebug to get more productive writing PHP code, focussing on the improvements in Xdebug 3.5 such as Native Path Mapping, to make the debugging experience better and easier to set up.

Beyond that, this session also goes through a few complicated scenarios that are harder to debug, and shows solutions to these conundrums. I will also focus on the new features.

Saving Time by Using a Debugger - Derick Rethans

APIs are the foundation of our applications today and need to be secure. From broken authorisation and authentication to injection attacks, the OWASP API Security Top 10 identifies the most critical security issues facing APIs today. In this talk, we'll walk through the items on the list and explore these security flaws and look at how to prevent them. By the end of this session, you'll have a clear understanding of the most critical API security risks and be equipped with the knowledge to build more secure APIs.

Securing Your API: The OWASP Top 10 - Rob Allen

At MongoDB, I help maintain the open-source tools that help PHP developers use our product. Without active, stable OSS, we shrimply wouldn't have any users.

In this session, I'll share why open source is essential to your product's success, and how to get involved in the ecosystems that support it. Through real-world examples, you'll learn strategies for contributing effectively, the value of community trust, and getting leadership buy-in to invest engineering time in OSS.

You'll leave with practical ways to strengthen your product by strengthening its open-source foundations.

No OSS, No Users: Why Investing in Open Source Matters - Pauline Vos

This talk grew out of a side project that got wildly out of hand. I set out to build a quick Laravel app to make one of my favourite podcasts searchable - just a weekend hack, a bit of "vibe coding" to scratch an itch. Instead, it became EverythingIsShowbiz.com, a fully fledged PHP + AI transcript engine with semantic search. What started as an experiment turned into a practical crash course in where AI actually fits into PHP workflows: from managing GPU-heavy transcription jobs, to cleaning up potentially-libellous misheard phrases, making AI output trustworthy at scale, and all on a side project budget!

Along the way, I learned a lot about the gap between AI hype and engineering reality. We'll explore the messy middle - where Laravel pipelines replace notebooks, admin tools become sanity savers, and side projects quietly teach us the same lessons as production systems. This talk is for anyone who's ever been asked, "can you do that... but add AI in?" and wants to know what that really looks like in PHP.

A small reminder that PHP still belongs in the future - even when that future comes wrapped in AI.

Everything Is Showbiz: Lessons from a PHP + AI Side Project - Paul Conroy

Achieving optimal performance and reliability requires more than monitoring — it demands observability. Discover how metrics, logging, tracing, and continuous profiling empower you to understand, debug, and optimize your application at every level. We'll explore each pillar and demonstrate how to instrument your PHP application for actionable insights. Real-world examples will leave you equipped to make your PHP applications observable, resilient, and performant.

The Four Pillars of Observability - Florian Engelhardt

API Platform is a totally open-source, out-of-the-box framework for making APIs that follow all the Web's best practices (standards, RFCs...) since its release, in 2015.

In this talk, we'll see how in a matter of seconds, thanks to the contributions of around 1,000 developers since the framework was created, we can easily have a robust API with auto-generated documentation, via the Swagger UI, whether for a REST or GraphQL API.

Through concrete examples and feedback, we'll explore how to contribute to API Platform and use it in your projects, whatever the complexity of your APIs. We'll look at extending automatic documentation, adding custom filters, and integrating your own custom data sources.

API Platform: From Rest & GraphQL APIs to state-of-the-art standards in seconds - Vincent Amstoutz

Whether you're building APIs, deploying microservices, or just curious about what happens beneath the surface of your applications, understanding networking is essential. This talk explains the core concepts of networking - from the basics of TCP, UDP and the OSI model, to more advanced topics like routing, BGP and anycast.

You'll gain a practical understanding of how data moves across the internet, how routing decisions are made, and why these concepts matter when building scalable, resilient applications. No prior networking experience required

Packets, Protocols and PHP: Networking Fundamentals for Developers - Jessica Smith

Value Objects can be one of the most powerful tools in your modelling toolbox. They make code expressive, maintainable, deterministic and cohesive. Yet they are sometimes misunderstood and it's often difficult for developers to realise where and how they can use them.

In this talk you will learn how to identify value objects in the wild, what their properties are and how to create your own!

PHP, Value Objects and You 🫵 - Daniel Leech

In this talk, we'll explore options for PHP performance analysis. From understanding how the PHP virtual machine and OPCodes work, to performing your reliable and meaningful benchmarks, and how to use request profiling using open-source and commercial offerings.

You will leave with an overview of the available tools and an understanding of how to use them in your day-to-day. Learning how to spot bottlenecks and optimize them away efficiently and confidently.

PHP Performance Demystified - Measure, Understand, Optimise - Volker Dusch

In many developers' lives comes a time when they move on from "coder" to "lead" to "architect" (or similar terminology) and maybe all the way to CTO. After a while it gets harder to grasp the concepts the "coder" people are talking about, even though it seems like just yesterday. And it's not imposter syndrome, it's something entirely different ! In this talk, we'll walk through this journey, which is not always a one-way street, to illustrate that how you approach this journey makes all the difference to yourself and your team.

Stepping away from the code... but not quite... - Wim Godden

Exploring a code base is like navigating a maze with a partial map. While some paths are correctly indicated, some are mislabelled or turn out to be dead ends. Take a childless class not marked as final, for instance – the keyword’s absence is like a sign pointing to a dark tunnel leading nowhere.

How many such paths do we accidentally – or deliberately – leave open? This presentation introduces the Closed-by-Default Principle, a reframing of existing principles focussed on keeping those paths shut, relieving the developer’s cognitive load in the process.

It is also an exploration of PHP’s evolution over time, each version introducing features to keep the maze as navigable as possible. We’ll also see how to leverage static analysis tools to automate the corresponding rules, giving developers the assurance that all paths lead somewhere.

Escaping the Code Maze - Yannick Chenot

I've always loved creating things - designing systems, writing code, and shaping solutions by hand. So when AI tools started to dominate the conversation, I wasn't sure how they would fit into my world in a way that still let me do the parts I love most.

That question became real when I was tasked with evolving a large Laravel application towards an event-driven model. Faced with unfamiliar accounting concepts and event sourcing patterns, I turned to AI not to write code, but to help me learn, think, and explore.

In this talk, I'll share how AI became a valuable design partner as I navigated this architectural shift. From bridging domain gaps to shaping key decisions and incrementally evolving a live system, this is a practical story about integrating new tools without losing your craft.

Whether you're exploring event-driven design or curious about how AI can fit into your workflow, this talk offers practical lessons from a real-world journey.

Event-Driven Evolution with AI as my Partner in Design - Naomi Gotts

At first AI is a ton of buzzwords and hype, but how do we integrate AI in our existing products / software projects in a meaningful and realistic manner?

Let's have a look how Symfony AI enables us to bring AI-based or even agentic features, not only chatbots, into our PHP applications or scaled architecture.

If you are looking for input on how to approach AI, need ideas where to get started or find out what's realistic at first - let this talk be your inspiration!

Videos

It Depends

Crafting Custom PHPStan Rules

From Events to Insights: Testing and Documenting Event‑Based Software

Building Native Apps with PHP

Saving Time by Using a Debugger

Securing Your API: The OWASP Top 10

No OSS, No Users: Why Investing in Open Source Matters

Everything Is Showbiz: Lessons from a PHP + AI Side Project

The Four Pillars of Observability

API Platform: From Rest & GraphQL APIs to state-of-the-art standards in seconds

Packets, Protocols and PHP: Networking Fundamentals for Developers

PHP, Value Objects and You 🫵

PHP Performance Demystified - Measure, Understand, Optimise

Stepping away from the code... but not quite...

Escaping the Code Maze

Event-Driven Evolution with AI as my Partner in Design

PHP & AI: Beyond the Hype

Know Your Enemies: Live Exploit of a PHP Engine Security Breach