PHP Tek 2025
20 - 22 May 2025 at Sheraton O'Hare Suites

Developers have been stereotyped as being anti-social. Oddly enough, we're the most social group of contributors around. Think about how we build software through Open Source or exchange code and solutions. We're the true inventors of the anti-social social club because as soon as we get to talk shop and compare notes with our peers, we become the most social beings around. This talk is intended to open up our views on leveraging this conference and other opportunities to build meaningful relationships with our fellow anti-social social club members. Prepare to move and engage with the audience around you, so drink your coffee, eat your breakfast, and I'll see you on stage to kick off PHP Tek 2025

The 1brc is "a fun exploration of how quickly 1B rows from a text file can be aggregated with Java", but let's face it, we should be able to do this in PHP too, right? Join me and let's see how fast we can actually aggregate 1B rows in PHP and learn about optimising the performance of PHP software along the way.

Imagine, if you will, a world where you're able to define a tailor-made type for domain objects that is always valid, type-safe, immutable, and easy to test. No more email addresses passed around as plain strings, nor associative arrays being passed around with potentially-undefined keys and unpredictable types. In this session, we'll dive deep into PHP Value Objects: where are they useful, how do we write (and test!) them, and how do we ensure that the data they encapsulate is valid? Attendees will leave with a better understanding of domain modeling, Value Objects, and immutability. Warning: once you start using proper value objects, you may never be able to go back to using anything else!

Before the advent of Enums in PHP, we had numerous ways of representing enum-like data. Like many aspects of PHP, how the Enums have been implemented to replace those old methods can vary widely based on the developer and the application in question. In this session, we will dive into the ways Enums have been adopted - the good, the bad, and the ugly. We'll talk about readability and data storage as well as diving into methods for refactoring. This will be an interactive session and I encourage all attendees to share their experiences as we go.

A common refrain from non-PHP devs is that our favorite language is old and doesn't support powerful features like asynchronous code execution. This couldn't be further from the truth. Together we'll cover the fundamentals of synchronous versus asynchronous execution. We'll cover event loops in PHP and work through both promises and coroutines. We'll even cover PHP 8's new Fiber implementation!

Developers love predictability. Come learn how to use tools like Ansible and Terraform to ensure predictability in your infrastructure and deployments. This session will show you exactly what these tools are capable of, how they're different, and the best ways to approach deploying your application into production.

What's today's date? Is it 07/20/2023 or 20/07/2023? Or maybe it's 2023/07/20? How many elePHPants do you want to buy? Is it 1,500 or 1.500? Will that be $30,000.00 or 30.000,00 $? We represent dates, times, numbers, and currency in a variety of ways, depending on where we are in the world, and writing software to accommodate these different formats can be scary. It's worse when you find out you need to put these formatted values inside a translated string like, "Sign up before July 20th, and you'll get 20% off the regular price of $30,000." String concatenation and standard placeholders won't work because different languages and regions follow different rules. Fortunately, we have tools to make our jobs easier, and in this talk, we'll take a look at FormatPHP and FormatJS, libraries designed to help with internationalization and localization of web applications. We'll see how these libraries aid in formatting dates, times, numbers, and currency, as well as messages with plural conditions. We'll learn how to format messages for translation, and by the end of this talk, you'll know what a translation management system (TMS) is and how to extract strings from your application to send to your translators.

In 2021, I was tasked with building a new serialization system for TYPO3. The result was a trio of new, general-purpose libraries that demonstrate the power and flexibility of the modern PHP language: FP, AttributeUtils, and Serde. In this session, we'll start with an overview of the plethora of potential PHP processes for handling serialized data, and show their pros and cons. We'll then transition into talking about Serde and what goes into a modern PHP 8-centric serialization framework, before showing novel ways to use serialization tools. Along the way, we'll touch on the power of PHP attributes, and how AttributeUtils makes them even more powerful.

Transitioning from monolithic PHP applications to a microservices architecture can be a game-changer, unlocking greater scalability, flexibility, and resilience. This session will explore not only the technical steps but also the transformative impact on team dynamics. By decentralizing services, teams can work more autonomously, fostering faster development cycles and greater ownership. Drawing on over 20 years of PHP experience, I'll cover essential elements of microservices-from decomposition and data management to deployment strategies. We'll examine real-world examples, common pitfalls, and effective solutions to equip PHP developers with the tools and strategies needed to confidently transition to microservices. Key Takeaways: 1. Understanding the core technical and team dynamics benefits of microservices architecture in PHP. 2. Techniques for decomposing a monolithic application into manageable services, leading to more focused team ownership and accountability. 3. Best practices for inter-service communication, data consistency, and monitoring to enable smoother team collaboration. 4. Insights on avoiding common microservices pitfalls, such as over-engineering and excessive interdependencies, to keep teams aligned and efficient.

As shocking as this may be, not every team has a dedicated database administrator. Like many developers, I have had to learn difficult lessons about database design the hard way when under a lot of pressure to get something that's broken fixed. In this session, we will go over how to normalize our database, how to use indexes to improve our performance and discuss using constraints to make sure that the data entered into our database follows our business rules.

Join me for a hands-on journey into the world of Prism! In this workshop, you'll get the chance to build a fully functional AI application from the ground up, utilizing the powerful features of Prism to create innovative and practical solutions. Highlights of the Workshop: Tool Use: Learn how to extend your AI's capabilities by integrating custom tools and external APIs, enabling your application to perform complex tasks like web searches and real-time data analysis. Structured Output: We'll dive into the latest advancements in structured output generation, ensuring your AI can produce precise, structured, outputs for a wide range of applications. Text Generation: Master the art of generating high-quality, contextually relevant text using Prism's intuitive API, and explore how to fine-tune your outputs for optimal performance. Throughout the workshop, we'll progressively build and enhance an exciting AI application with Laravel, showcasing practical use cases and techniques that you can apply to your own projects. Whether you're a seasoned developer looking to enhance your AI skills or a newcomer eager to get started, this workshop will provide you with the tools and knowledge you need to build innovative AI solutions with Prism.

Are you working on a legacy project that is in need of upgrading? Do you need to make changes to your project that require the same repetitive refactor applied to your codebase hundreds of times and no existing tools can to help automate the task? If either of these scenarios are familiar you've probably had a look at or used Rector. Rector has hundreds of rules that help with automating upgrades and refactors. However what happens if you need to do something custom to your project, that is not available with an existing Rector Rule? In this case you can create your own custom Rector rule. This tutorial will teach you how to create custom Rector rules that can automate tasks specific to your project. By the end of this tutorial you'll know how to create your own rules and have a framework for creating rules for whatever refactor you wish to automate.

Take your testing practices to the next level with Codeception, the all-in-one PHP testing framework designed for everyone. Whether you're new to testing or an experienced developer, this session with Alena Holligan will help you confidently create and manage tests for PHP web applications. We'll dive into Behavior-Driven Development (BDD), a methodology inspired by Agile and Test-Driven Development (TDD), that bridges the gap between technical and non-technical teams. Learn how BDD enhances collaboration by turning user stories into executable tests using the Gherkin syntax. Together, we'll explore: Describing features with scenarios in formal, readable text. Using examples to make abstract concepts concrete. Implementing test steps to validate real-world use cases. Writing functional code that aligns with the user's needs and expectations. In this session, you'll get hands-on experience setting up Codeception, writing reusable acceptance tests, and leveraging BDD to improve communication and clarity within your team. With Codeception's flexible modules, you can also extend your testing to functional, unit, and API levels, ensuring robust coverage. Discover how BDD with Codeception ensures that developers, QAs, managers, and stakeholders stay aligned, delivering features that meet requirements from the start. Learn to simplify complex workflows and empower non-technical team members to participate in the testing process. Join us to write your first BDD test and leave ready to build better software with Codeception.

Investigating Event Sourcing as an approach in PHP we examine the principles, steps and approaches to an Event Sourced Application, showcasing how event sourcing can improve reliability, confidence and extensibility of an application

One of the things that developers often leave last when pushing out code is security. The amount of support requests I get in alone on implementing APIs on PHP versions that were end of life 2+ years ago tells me we still neglect security. You have hashed passwords, fine. What about more modern application auth? Well, some people might already be using two-factor authentication with SMS. BUT... have you heard of Silent Authentication? Ever tried a Yubikey integration? In this session, we'll revisit security to open new doors you might have missed.

Every year PHP matures and evolves with a new release. This talk will discuss the must-use features in PHP 8.4, the latest release. To further help bring your code into the future, we'll also discuss some key features from PHP 8.3 and 8.2, that you may have missed. Additionally, we'll review some deprecations, to help you side step problems as you modernize your PHP code base. Attend this talk to learn to create tomorrow's legacy code today - a legacy that you can be PHProud of. Key Takeaways * Strategies for keeping your code up to date * Use your static analysis tools and IDE effectively * Improve your application design via new features * Practical tips for improved code maintenance and readabilty

Cron jobs are like that one friend who's reliable... until they're not. In this session, we'll unpack the surprisingly common pitfalls PHP developers face with cron. From endless loops to overlapping jobs that play tug-of-war, I'll show you how to dodge the usual traps and keep your tasks ticking smoothly. Expect real-world examples, tales of cron gone wrong, and practical tips to make cron your dependable sidekick. Whether you're new to cron or think you've seen it all, join in for a crash course in taming those scheduled scripts!

The differences between unit tests, integration tests, contract tests, end-to-end tests, and behavior tests-and which type is best to use-are often debated. Principles like "don't mock what you don't own" or "test behavior, not implementation" are often cited in those conversations. But there's one key question we should always ask when writing tests: is this a valuable test? So let's put those other concepts aside and ask a simple question as we look at some real-world examples: "What is the value of this test?" Answering that can lead to more nuanced questions. Does this test continue to deliver value over time? How much value comes from the act of writing this test? Are there ways to increase the immediate value as well as the long term value? Join me as we rethink testing-not in terms of types and categories, but in terms of the practical, meaningful value that testing brings to our codebases and our teams.

Want to build software that is more testable, easier to modify, and has fewer lines of code? Architecture with more immutable objects that are always in a valid state is the most important lesson I have learned in building better software applications. Using immutable value objects will lead to less checking, fewer bugs, and more DRY code, and will help avoid the "spooky action at a distance" problem in PHP. We will also learn how to use immutable objects and immutable collections to improve design of our mutable entities. Lastly, we'll see how our immutable modeling approach can drastically reduce the complexity of things in our systems that are mutable.

In this presentation, we take a first look at writing PHP extensions. Using step-by-step examples, we'll take a function written in PHP and convert them into a loadable extension using C. We'll then test both versions and compare the results. After seeing the size and scope of the benefits that can be realized with only a few minor changes, you'll want to try it out for yourself. You'll also understand why we start with simple things, and not try to rewrite all of Symfony or Laravel in C. You will learn: - What PHP extensions are, and which different types there are. - Why you might want to write a PHP extension. - How you write your first PHP extension, with practical tips and tricks.

What does good, clean PHP code look like? This somewhat opinionated talk will cover marquis and key indicators of good PHP code. Hit on best practices, see how to measure code with metrics with PHPMD, and refresh on guardrails like PHPCS and PHPStan. Use these tools and tips to really start writing beautiful PHP code that is readable, testable, and has good architecture.

You were just handed the keys to a new repo. Your first glance over the code base causes the fearful "LEGACY" word to ring in your head. HAVE NO FEAR! I'll share the techniques I've learned after working on several legacy codebases to help update that old code to the current PHP generation. We'll cover triaging the old code base, writing tests to make sure you don't break anything, and how to modernize your old code base!

I'll talk about event sourcing, build up the concept, and then talk (and probably live code) through implementing events into an existing codebase using Verbs.

When starting a new project, there is often a lot of monotonous work that is involved in getting your frontend components and backend logic and validation set up. In reality, a lot of this work is the same across every project, and there isn't an inherit need to rewrite the same thing every single project. That's where FilamentPHP comes in. In this talk, we will go over the basics of getting started with FilamentPHP and building a basic admin panel to show how streamlined it makes the process. We will also go over some of the capabilities it has outside of panel-based applications, and how you can implement it in your existing project. So come along, bring a friend, and learn how to make your life easier with FilamentPHP!

We don't talk about REST much these days. Why is that? Was REST too hard? Did we get tired of it? Did GraphQL win? Let's revisit REST to learn how its concepts can be put into practice to build great APIs. Along the way, we'll talk about some of the criticisms of REST and why GraphQL is an attractive alternative. We'll also discuss when it's okay to bend or break the rules, and we'll cover hypermedia, content negotiation, and API versioning pitfalls.

At the heart of all of our tools, credentials allow human-to-machine and machine-to-machine communication. According to recent research, 93% of organizations had two or more identity-related breaches in the past year. It is clear that we need to address this growing issue. Unfortunately, many organizations are OK with using plaintext credentials, which we should all know not to do by now. Given the scope of the problem, what can we do? Let's make a plan! - Secrets Detection - Secrets Management - Developer Workflows - Real-time Secrets Scanning - Automatic Rotation By the end of this session, you should have a clear roadmap for taming the machine identity mess in your code and pipelines.

In the world of web development, creating an API that users will love involves more than just providing access to data. It requires thoughtful design, efficient performance, and a clear understanding of user needs. In this talk, we'll dive into the principles of designing and building APIs that prioritize user experience. From choosing the right PHP tools to implementing RESTful practices and documentation, we'll explore the key components of a developer-friendly API. Whether you're building an API for internal use or external consumption, this session will provide you with the insights and strategies to create an API that delights your users. Or at least make them more likely to pay for your product.

Ever dreamt of becoming a PHP core contributor but felt overwhelmed by the prospect of creating RFCs, maintaining extensions, or writing C code? Worry no more! In this talk, you'll discover how to make a meaningful impact on the PHP core by writing tests without the need to write C code. Join me for an interactive session where I'll live code a test on stage, demystifying the process and equipping you with essential testing techniques.

Leverage high-level tests to cover more functionality and challenge your current view of unit testing. What are the priorities when you're building your application? How can you have confidence in your code and write strong tests?

Type management has become a fundamental pillar for the quality of PHP code: static analysis makes permanent use of it. However, the design of a type system remains anecdotal: at best, it is often an organic effort, based on a few simple rules. In this conference, we will explore good typing practices in PHP. We will put a particular emphasis on the notions of code validation and completeness, through concrete examples. You will discover a methodical approach to define and organize types in a consistent way. This conference is aimed at developers of all levels wishing to take a step back and urbanize a growing number of types.

Application Programming Interfaces (APIs) are fundamental to how information travels across the Internet. They help to standardize communication between different applications using the HTTP protocol. While APIs can be extremely helpful, there are multiple questions that need to be answered before implementation. When is an API really needed? What should its endpoints be? If a database is needed, is raw SQL or an ORM better? These decisions among others will be reviewed in this presentation to help professionals better understand when they need an API and how to implement them.

Properly securing your applications and data require an understanding of the threats facing them. Threat modeling is the methodology for identifying and quantifying the threats your application can and will face. There are a number of resources available for performing a threat model but this session will get you started building a strategy from nothing.

Many Command Line Interface (CLI) programs unintentionally exclude users with disabilities due to overlooked accessibility features. This talk highlights the importance of prioritising accessibility in CLI design. We'll explore considerations, such as integrating auditory cues, designing inclusive colour schemes, and ensuring compatibility with assistive technologies. By focusing on creating readable and navigable outputs, developers can build programs that are not just functional but truly inclusive, enabling everyone to interact effectively.

Microservices (often deservedly) get a bad rap: they create complexity and introduce a new class of problems that are hard to solve. But what happens when you legitimately need multiple services to perform disparate tasks in your infrastructure? Come learn about the "monolithic microservice", a new architecture for separating service concerns and offering a middle ground between the monolith and microservice.

Have you ever deployed code only to have it causes errors and unexpected results? By using static code analysis we can reduce, if not completely remove this risk. In this session, we'll discuss the basics of static code analysis, some free and inexpensive tools we can use, and how we can run the tools successfully.

In this talk I explain how to use Xdebug to get more productive writing PHP code, focussing on the improvements in Xdebug 3.2 and 3.3, and the upcoming 3.4, 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, such as native path mapping.

Event sourcing is a powerful pattern that can fundamentally change how you approach building applications, when auditability and adaptability are needed. However, aspects of event sourcing can be misunderstood, and those misconceptions make it harder to understand and utilize effectively. We'll take away the abstractions and focus on building an event sourced system without the use of an event sourcing library. This approach will help focus on the core concepts: what an event table is, how events are replayed when loading an aggregate root, what a projection is, and how snapshots work. Once we've established that base understanding, we'll take a look at how event sourcing libraries handle common concerns. Along the way, we'll clear up some common points of confusion, and explore how this can be applied to existing systems, not just greenfield projects. You'll leave with a clear foundational understanding of event sourcing, so you can decide if this pattern is right for your next project.

Ever made the same change in hundreds of locations across dozens of files as part of an upgrade? Would you like to have automated it in a safe way instead? Rector can do that! In this session we'll look at what Rector is and does, and how you can use its extensive collection of rules to safely automate bulk changes across your codebase.

PHP properties are having a golden age. Starting with PHP 7.4, they've become steadily more capable and flexible, and now in PHP 8.4 interface properties, hooks, and asymmetric visibility absolutely blow open the power of properties. So now what? Now that we have all this power, what shall we do with it? Is it really just an edge case benefit, or does it necessitate a rethink of what it even means to model data? Or both? In this session, we'll look at PHP properties, and OOP modeling in general, with fresh eyes to see all that they can, should, and will do to make our lives that much better.

Dotfiles drive your command line experience, offering power and extensibility. This sequel to my Better Dotfiles talk from last year, will demonstrate how to further level up your dotfiles. With an emphasis on practical commands, flexibility, and workflows, I'll provide a live demo on stage some of my workflows. We'll also review how to debug with Bash, and some ideas how to improve debugging. This will provide you with practical strategies and tactics to make the most of your dotfiles. Key Takeaways * Strategies for dotfiles management and greater control * Use shell features more effectively * Improve your debugging with Bash * Practical tips for customizing your terminal * Identifying some best practices

On the surface, the idea of code review is a no-brainer: why *wouldn't* we want a second set of eyes on our code, especially before deploying to production? As we peel back the layers, however, we find that the topic of code review is much more nuanced. How detailed should the review be? Who is qualified to perform the review (hint: it's not just senior developers)? Can we afford to take another developer away from their project to review this one? What steps can we take to ensure reviews are constructive, rather than demoralizing? Attendees will gain deeper insight into some of the arguments for and against systemic, peer code review, as well as pick up some useful tools to make code review a natural part of their teams' workflow.

In this session we will explore the development of a custom Rector rule for migrating hundreds of classes off of a legacy framework and onto a set of more modern compositional traits. Using traits we will upend the class inheritance tree, and put guardrails in to contain the chaos. A basic understanding of Rector would help you get the most out of this, but is probably not required, @see Intro to Automated Refactoring with RectorPHP for that.

Scalability is more than handling traffic-it's about crafting a codebase that evolves with your business. In this talk, we'll explore design patterns that enhance performance and maintainability in PHP applications. Learn when to apply patterns like caching, modularity, CQRS, and event-driven systems, and how to integrate cloud providers like AWS to optimize scalability. We'll also discuss key indicators for transitioning from a monolith to microservices and making the shift effectively.

Having problems writing tests for code? Not sure how to start writing tests? Testable code follows specific patterns, principles, and practices to make it testable. We will cover Dependency Injection (DI), decoupling, mocking, and other code architecture techniques to make your code easier to write tests for. Common problem areas with practical solutions will be discussed, including race conditions, timing, dynamic data, databases, and external dependencies.

According to the 2024 Stackoverflow Developer survey, 48% of all respondents and 52.2% of professional respondents stated that they use Amazon Web Services (AWS) extensively. These numbers are no surprise given the flexibility and customization of over a hundred services offered by AWS. This presentation will focus on three services used for application hosting: (1) Elastic Compute Cloud, (2) Beanstalk, and (3) Lambda. We will compare and contrast these services to better understand the best choice for a given business scenario.

Heard a lot about docker but not sure where to start? Frustrated maintaining development VMs? In this presentation we will go over the simplest ways to convert your development environment over to a docker stack, including support for full acceptance testing with Selenium. We'll then go over how to modify the stack to mimic your production/pre-production environment(s) as closely as possible, and demystify working with the containers in the stack.

Describing the art of Domain Driven Development For PHP, designed to talk about this from a frameworkless way - showing developing an application in PHP that doesn't use a framework at all in a Domain Driven way, that then shows how you can take the principals of DDD to frameworks in a safe way

Join us for an in-depth exploration of a high-stakes database migration journey. We'll dive into the critical decision-making process when your current database engine starts showing its limits, explore various alternative solutions, and walk through the actual implementation that kept everything running smoothly. Through real examples and practical code snippets, you'll learn how to evaluate database engines, plan complex migrations, and execute them with minimal downtime. Whether you're dealing with massive logging operations or planning for future scale, this talk will arm you with strategies and insights for your own database migration adventures.

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.

Four years after its first version, PHP 8 has already started the work of feature deprecations, targeting PHP 9. This conference offers a complete overview of these changes: from the planned disappearance of certain features to the modernization of basic behaviors. We will detail each major deprecation, explaining the reasons behind these changes, the potential impacts on existing code, and best practices for adopting them today. You will leave with a clear roadmap to gradually adapt your code, minimize the risk of breakage, and take advantage of the new features and optimizations offered by PHP 8.

Modern software development often defaults to complexity, but does this truly lead to "better" applications? This talk advocates for a return to simplicity, challenging the over-reliance on intricate toolchains and architectural patterns. We'll explore how embracing core principles like clear requirements, small teams, and constant feedback can result in more efficient and maintainable software. Join us to discover eight fundamental rules for building better applications, emphasizing a streamlined approach that prioritizes user needs and developer productivity.

Join us-father and son together on stage-as we share the story of how a passion for coding (sort of) passed from one generation to the next. Through lighthearted, relatable stories, we'll explore how several attempts at teaching code didn't exactly go according to plan but eventually worked out. You'll get both perspectives: a father trying to be the perfect mentor, and a son learning to love (and sometimes avoid) programming in his own way. Whether you're a parent hoping to inspire your kids in tech or just looking for some laughs, this talk will show that the journey matters more than perfection. We promise insights, humor, and maybe even a little code!

In the fast-paced world of tech, where precision and innovation are key, your brain's protective instincts can sometimes interfere with your ability to perform at your best. Picture your brain as a loyal dog-always on alert to guard you from perceived threats. While these instincts are intended to keep you safe, they can also trigger automatic thoughts of doubt, overwhelm, or stress, which hinder creativity, focus, and problem-solving abilities in high-pressure situations. This presentation dives into the neuroscience behind how the brain reacts to stress, explaining the chain reaction that unfolds under pressure: Thought _ Emotion _ Physical Response _ Performance. When faced with deadlines, complex challenges, or creative blocks, automatic thoughts can trigger emotional and physical responses, such as tension or anxiety, which directly impact your ability to think clearly and perform at your highest level. By understanding this process and recognizing how your brain's protective instincts might be working against you, attendees will learn how to manage these automatic reactions in real-time. Using science-based strategies, you will gain practical tools to stay focused, enhance creativity, and remain mentally sharp.