A Field Guide to PHProperties :: Larry Garfield

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.

Admin, Product and Beyond with FilamentPHP :: Easton Meth

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!

Advanced Rector Shenanigans :: Chris Abbey

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.

Amazon Web Services: What Services Should You Use For Hosting Your Applications? :: Jack Polifka

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.

Architecture for Scalable PHP Applications :: Andrew Cassell

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.

Better Debugging With Xdebug :: Derick Rethans

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.

Better Dotfiles II :: Andrew Woods

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

Building an AI Powered Application with Prism :: TJ Miller

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.

Code Review: For Me & You :: Steve Grunwell

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.

Commanding Accessibility: Designing CLI Programs for Inclusivity :: Chuck Reeves

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.

Converting Your Dev Environment to a Docker Stack :: Dana Luther

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.

Cron Jobs Gone Wrong: The Top Mistakes That Keep Your Tasks from Ticking :: Peter Meth

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!

Data in 3D :: Daniel Coulbourne

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.

Design Choices When Implementing Your API :: Jack Polifka

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.

Domain Driven PHP :: Christopher Miller

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

Enums in the wild :: Dana Luther

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.

Event Sauce: Using Event Sourcing For Better Applications :: Christopher Miller

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

Event Sourcing Teardown: Understanding the Pattern :: Tim Lytle

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.

Extending the PHP language with PHP :: Dave Liddament

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.

Fortifying your Defenses with Threat Modeling :: Eric Mann

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.

Growing the PHP Core—One Test at a Time :: Florian Engelhardt

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.

I Promise() to Teach You Asynchronous PHP :: Eric Mann

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!

Immutability to Save an Ever-Changing World :: Andrew Cassell

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 defense of “monolithic microservices" :: Sarah Savage

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.

Internationalization & Localization With PHP :: Ben Ramsey

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.

Introduction to Infrastructure as Code :: Sarah Savage

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.

Introduction to PHP Extensions :: Derick Rethans

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.

Is This Test Worth It? Evaluating the Real Value of Testing :: Tim Lytle

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.

Mastering automated refactoring with custom Rector rules :: Dave Liddament

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.

Measuring PHP using Metrics :: Mark Niebergall

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.

NativePHP: Past, Present, and Future :: Shane Rosenthal

NativePHP is redefining what’s possible with PHP beyond the browser. In this talk, we’ll explore how NativePHP has evolved from a desktop-focused experiment into a promising approach for mobile app development. We’ll look at the key milestones that brought us here, the challenges of running PHP natively on mobile devices, and how developers are already leveraging it to build powerful mobile experiences. Finally, we’ll look ahead at what the future holds for NativePHP on Android and iOS—and why it might just change how we think about PHP entirely.

Passing the Code Torch: A Father and Son’s Story of Teaching, Failing, and Laughing in Tech :: Easton Meth

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.

PHP Security Mechanisms You Aren't Using :: Chuck Reeves

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.

Prepare Your Code for PHP 9: Overview of PHP 8 Deprecations :: Damien Seguy

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.

Processing One Billion Rows in PHP :: Florian Engelhardt

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.

Reducing Bugs With Static Code Analysis :: Scott Keck-Warren

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.

Return to REST :: Ben Ramsey

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.

Scaling Your Database: A Real-World Journey from Millions to Billions :: TJ Miller

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.

Secrets Security End-To-End :: Dwayne McDaniel

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.

Serializing modern PHP :: Larry Garfield

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.

SQL Database Design For Developers :: Scott Keck-Warren

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.

Systemic PHP typing : best practices :: Damien Seguy

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.

Test Less To Test All: Client-side Philosophy In Testing :: Philip Tadeo

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?

The Art of API Design :: Chris Tankersley

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.

Writing Testable Code :: Mark Niebergall

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.