Keynotes will take place on the main conference days. (Friday, May 3rd – Saturday, May 4th)

  • More and more people are entering the tech sector without tech-specific work experience, and/or with non-technical degrees (if they went to college at all). While many tech giants still require or heavily favor candidates with a computer science background for technical roles, other companies are recognizing the value of staff with diverse experiences and educational history.

    As a journalist-bartender-turned-developer, I’m constantly finding ways that my “useless” liberal arts background and years spent slinging pints of beer have, in fact, prepared me for a successful career in tech. For those in tech with non-tech backgrounds, as well as the folks who do the hiring at tech companies, we’ll discuss the myriad – and often hidden – skills that non-CS grads can bring to the table, and how they’re broadly applicable to tech-focused jobs.

  • We are literally in the best industry in the world. Want proof? We create value by turning ones to zeros and vice versa. And almost all of us are incredibly passionate about programming and that creation of value. However, there’s a lot more to creating truly great software than passion and your favorite IDE. It’s about working well with in a team that is a high performing team that is at a company that gives them enough structure to keep them focused but doesn’t get in the way with the process. More of this is in your control than you might expect. We’ll talk about what you can do as an individual to lead through influence to create a high performing team and company culture.

  • “Community” is a term often bandied about in tech circles, but what does it mean? Where is this community? What is Community’s hit point max, magic rating, and XP to next level? Does it have special abilities? How can individuals best connect with, contribute to, and benefit from the greater technical community? And also what is the end goal? So many questions! I don’t have all of the answers but I may have a few, so join us and let’s share some community skillz.

  • There is a stereotype of programmers as being antisocial and difficult, and unfortunately many of us take on this attitude as if it comes with the job – but it doesn’t have to be this way! I know it from experience, because I’ve been an angry, judgmental know-it-all, and I’m ready to tell you how I completely changed my attitude and refactored my life.

    In this talk I’ll explain how anger and fear are the root causes of our aggressive behavior, how these feelings manifest as judgemental comments online, bullying in the workplace and ultimately keep the tech community toxic and stunted. I’ll show you how embracing compassion, respect, and empathy will make you a better programmer and a happier person.

  • Change is Software’s greatest threat, and its defining characteristic. Disagree? How’s that Agile Transformation going for you?

    We will explore this cognitively-dissonant statement as we investigate the challenges that we’ve faced, how we continue to fail to address them, and what we can do tame this raucous beast.

    To do this, we will study the most ambitious, most expensive computing system built by the United States military in the post cold-war era of the 1950s, looking at the challenges they faced, and the choices they made to overcome them.

    We will then explore how many of those choices were carried-over to modern-day software engineering throughout the 1990s until we, as an industry, decided to free ourselves from the shackles of certain self-imposed limitations.

    In doing so, we got ourselves into different sorts of troubles. We will explore what they are and how some of us have chosen to overcome them.

  • Tutorials

    Tutorials will take place on the tutorial day, before the main conference days. These sessions will be longer than regular conference talks and may involve hands-on coding by attendees. (Thursday, May 2nd)

  • GraphQL is a powerful API query language that allows a web client to ask and receive the exact shape of the data it needs. As an alternative to REST, GraphQL promises to eliminate over-fetching data, reduce the need for multiple API calls, and let engineers move faster by leveraging the powerful developer tooling it enables.

    This workshop will introduce you to key GraphQL concepts, and we’ll discuss together how GraphQL is different from other API technologies. Then we’ll take these concepts and apply them to building an actual a GraphQL API, end to end, in PHP. And along the way, we’ll discuss important topics such as security, performance optimization, and application architecture.

    By the end of this workshop you’ll have a solid understanding of how GraphQL works. You’ll know how to spin up a GraphQL API in PHP, and what considerations you need to take into account. But most importantly, you’ll understand the tradeoffs and benefits of different API paradigms, and understand why GraphQL might be the right choice for your application’s API.

  • PHP is nothing like compiled languages. If you make a mistake, the program will crash when the line of code with the mistake is executed. When testing a PHP application, whether manually or automatically, developers spend a lot of their time discovering mistakes that wouldn’t even compile in other languages, leaving less time for testing actual business logic.

    PHPStan is a popular static analyser focused on finding bugs in your code. By leveraging the strength of PHP type system further enhanced in PHPStan itself, developers can create robust applications and discover bugs early in the development process. The aid the tool provides during refactoring is also indispensable.

    In this workshop, I will show the attendees how to install, configure and run PHPStan, and also give tips how to write code so that PHPStan can be as powerful as possible.

  • Figuring out the best way to apply object-oriented design principles to your code is a challenge for even the most experienced developers. In this tutorial we’ll dive deeply into exactly how to apply object-oriented design principles to the software we’re writing, including an in-depth analysis of the SOLID patterns and practices.

  • Developers still hesitate to include writing tests in their everyday routine. There are numerous excuses, myths and misconceptions around: “they slow us down”, “we’ll never achieve 100% code coverage, so why bother”, “takes too much time to learn testing, we’re better of writing business logic instead”. When we get to the topic of writing tests first, the debate becomes even more heated.

    In real world, where you get paid by code that ships, developer strive to write the most efficient tests possible. To cover mission critical code. To quickly decide whether writing a functional test or series of unit tests is the best approach. Let us learn together how to use phpunit and TDD in most efficient way possible, for extraordinary results.

    This workshop is for developers who start their projects by drawing model of the database first, developers who are overwhelmed by number of testing tools or don’t know where to start and developers who simply want to level up their game.

    Attendees will want to have PHP 7 and Git installed, preferably locally (or in a local VM). Pull down this repo to prepare for the tutorial.

  • Nearly every application uses some sort of data storage. Proper data structure can lead to increased performance, reduced application complexity, and ensure data integrity. Foreign keys, indexes, and correct data types truly are your best friends when you respect them and use them for the correct purposes. Structuring data to be normalized and with the correct data types can lead to significant performance increases. Learn how to structure your tables to achieve normalization, performance, and integrity, by building a database from the ground up during this tutorial.

    Attendees, please take a look at prior to attending so you’ll have your system ready to jump in when you arrive on Thursday!

  • Symfony is not only a framework, but also a collection of components that can be used in generic PHP applications. Their number has grown from 21 in version 2.0 to 48 as of today, and they are used in some of the most prominent PHP projects.

    This workshop will take you from zero to a simple framework built with those components. You will learn how a framework works at the core, and how the basic components fit together. Along the way we will see how some components can be useful in vanilla PHP projects apart from Symfony full stack.

    Make sure to bring a computer with PHP 7.2+, Composer, Git, and your favorite IDE installed. This tutorial assumes some basic Composer and PHP OOP knowledge.

  • Talks

    Talks will take place on the main conference days. (Friday, May 3rd – Saturday, May 4th)

  • Giant legacy apps! They’re super fun just to think about, right? But regardless how yucky they feel, and how much we dream about rebuilding things from the ground up, legacy systems are often critically important, and often do actually get the job done.

    BUT… that doesn’t mean we can’t modernize the legacy apps in our care, and it doesn’t mean we can’t utilize things like serverless in our approaches.

    Join me if you’re interested in how to approach serverless within the context of augmenting legacy applications. We’ll start with some ideas that should be easy to get buy-in and approval for, and work our way through replacing core components of a legacy system. All examples are things we’ve done (or are doing) ourselves at

  • The future we saw in Star Trek is happening now! Instead of having to actually touch your technology, you can now use your voice to bend it to your will. In this talk, we’ll go from an idea for an Alexa skill to a fully functioning voice-based assistant for a hobby that involves a surprising amount of calculations: brewing beer. No brain cells will be harmed during this talk (meaning no alcohol), but you may accidentally learn how it’s brewed as we build a skill to aid in it.

  • Like Blair Waldorf and Serena van der Woodsen, Pa11y is an accessibility tester’s BFF. You already have a million issues on your plate, so how do you find a way to get started on accessibility testing? Pa11y to the rescue! Pa11y is a lightweight JS a11y testing tool with some serious “it” factor. This talk will explain what pa11y does and does not cover, review examples of both command line and scripted usage, dive into the pa11y web service and show how to best accessorize a Pa11y setup with your current testing process. Bonus content: how to convince the rest of your team and business why accessibility is totally worth prioritizing and how getting started with low-hanging fruit can vastly glamorize your product. Now you can take on creating a more accessible product like S & B take on the Upper East Side. XOXO Accessibility Girl 💋

  • Can you say with images what you might say with words or voice? Storytelling is in our DNA, it is what we do everyday and as designers, developers, and leaders. You are entrusted to tell the stories of your clients and stakeholders. This session will help you be concise, conclusive, and comprehensive with storytelling.

  • Abstraction. Encapsulation. Polymorphism. Interfaces.

    Whether you’ve been programming in PHP for years or are just starting your journey, these terms can be overwhelming. On top of that, people who already understand these concepts act like they’re so easy, talk right over the simple questions, and never explain the basic concepts in a way that actually makes sense.

    We’ll dive into this Object-oriented terminology, complete with real-life examples in a way that makes sense and allows you to utilize OOP immediately.

  • Separated layers are one of the fundamental principles of software design. Your framework is just the topmost layer, and your business code should not depend on it. While we will touch a few package design basics, the focus is on how to actually DO it: Expose the user accounts in your model to your framework without depending on it. Separate form input validation from entities. Isolate ORM-specific code in bridges. We’ll also take a look at Deptrac, a tool that helps you to to visualize and stick to that separation during your project’s lifetime.

  • Often in our applications we need to make HTTP requests to external services either to integrate with an API, upload a file to S3, or perform some other action that requires us to interface over HTTP. PHP doesn’t natively make these requests user friendly so many of us turn to the 3rd-party library Guzzle. But how well do you know Guzzle beyond the basics?

    Guzzle is much more than syntactic sugar for HTTP requests. PHP is a synchronous language by nature, but did you know that you can make asynchronous HTTP requests out of the box with Guzzle? It’s functionality extends even further with support for custom request handlers and middleware.

    In this talk we’ll start with some basic example requests using Guzzle. Then we’ll look at extending our requests with middleware such as logging, retry middleware, handling failed requests, and mapping responses from 3rd-party APIs. From there, we’ll refactor our synchronous requests to be asynchronous using promises and generators to process our async responses. Finally, we’ll look at how to test our requests without needing to send them over the internet. You’ll leave this presentation with a deeper understanding of the power of Guzzle, how to extend it with your own middleware, how to speed up your application with async requests and how to test your requests without external dependencies.

  • What is your greatest tool in your toolbox? Your brain! Sure, you could sharpen this tool and promote your project the normal way, with hard work and years of slow, incremental progress. Or you could use some of the brain’s built-in cheat codes and just hack your way to success.

    Along with learning, our brains are plagued by a raft of bugs and unwanted features that we have been unable to remove. Use these features to your advantage to teach, learn, and persuade. Join us in a tour of some of the most amusing bugs and exploits that allow you to play with the interface between our brains and the world.

  • The only thing in this universe denser than a black hole is the average node_modules folder and boy, is all this webpack nonsense complicated! Hi, I’m a recovering PHP developer buried deep in the Javascript frontend world so I know the questions you’re asking: why is this so complicated? Why do I need so many tools, better known as “tens of megabytes of npm packages”? Why webpack and babel?

    Together we’ll take a journey down the demands of a modern frontend application, the limitations still imposed by modern browsers, and what YOU can do to improve frontend performance. From learning about repaints, reflows, to network connection limitations and bundle splitting all the way to preloads, prefetches, and even preconnects, you will walk away with both action items to improve your apps TODAY as well as a deeper understanding why the JS ecosystem has evolved the way it has and what your fashionable and beautifully intelligent frontend engineers are even doing all day.

  • Learning more than one programming language is key to becoming a better developer. It is like adding a new tool to your toolbox. The more tools you have, the easier and quicker you’ll be able to tackle whatever job you need to do. You’ll also be able to use the right tool for the job, and who doesn’t like that?!

    I picked up Go (golang) a few years ago as it was becoming more popular among developers. Coming from a PHP background, I had no idea what channels or goroutines were or how is concurrency different from parallelism. I’ve got to say, it was a whole new world. Very different, but very cool. I was hooked!

    By happy coincidence, my company was looking to rewrite a legacy PHP app in Go. It was over 2000 lines of procedural and messy PHP4 with more downtime than I’m willing to admit to. I took on this project, and soon enough we had a much faster, more maintainable and much more reliable app for our customers. Go gave us options we would not have in PHP.

    The goal of this talk is to give you a good idea of what Go is and how it compares with PHP. We’ll look at the language itself as well as the tooling and communities around it. Even if you’re not sold on Go by the end of it, I hope you’ll leave inspired to go out there and learn whatever language you wanted to look into next!

  • GraphQL is a powerful API query language that allows a web client to ask and receive the exact shape of the data it needs. As an alternative to REST, GraphQL promises to eliminate over-fetching data, reduce the need for multiple API calls, and let engineers move faster by leveraging the powerful developer tooling it enables.

    PHP and GraphQL work great together, and whether you’re building a greenfield application or working in a existing codebase it’s easy to get started writing a GraphQL API. This talk will introduce you to GraphQL, and demonstrate how you can build and use a such an API, in PHP, today.

  • If you’ve only ever experienced web development through a web framework, you’re missing out. Have you ever been tempted to rewrite a codebase in your favorite framework? That’s a smell that you need to come to this talk.

    Being comfortable developing without a framework is a crucial skill to have for refactoring legacy applications. In this talk I show you how to harness the power of going “frameworkless” so you’ll feel empowered to make better decisions in your next web project. Be set free from your web-framework ball and chain.

  • Having an OpenAPI Specification (OAS) is a useful document for numerous reasons. The most common being the ease of generating API reference documentation, but it overshadows some additional benefits that you can gain from adopting the OpenAPI Specification. This talk will delve into the hidden value of the OpenAPI Specification, and how you can employ it to your advantage. Some of the ideas that we will explore are:

    – What are the lesser known benefits of using OAS to build API docs
    – What is a single source of truth in an API
    – How OAS gives us a way to breakdown APIs and helps us improve communication around HTTP
    – How design-first APIs, mocking, and testing with OAS can create better developer experiences through feedback cycles
    – How OAS creates a structured document for collaboration between teams and other ways OAS can increase collaboration throughout the API design process

    Attendees will leave the talk having a better grasp of how the OpenAPI Specifications can fit into their workflow, including different PHP and language-neutral tools, and how they can leverage it to improve their API design and developer experience processes.

  • Being fast, lightweight and embeddable, Lua got its reputation through game engines and desktop applications. With rise of microservice architecture popularity in building web applications, Lua is also becoming an important player in web development.

    After quick introduction to microservices, we’ll show how Lua fits in backend development and how it can be used in Redis and Nginx.

  • Thanks to cloud providers like DigitalOcean, AWS, GCP, Linode, etc, we as developers can easily spin up servers for testing or production. We can have a complete server ready to go in a matter of seconds. Often security is an afterthought leaving servers vulnerable to attacks, abuse, or worse.

    In this talk I will introduce some basic security settings and monitoring. I will make attendees aware of some of the many types of attacks, and the methodologies that can help protect them.

    Some of what this talk will cover:

    • Passwords – generating and protecting strong passwords
    • Users – setting up, restricting access, granting rights (like sudo)
    • Root – keeping access to root safe
    • SSH – managing keys, defending against unauthorized access
    • Firewalls – enhancing security with firewall rules
    • Logwatch – get a daily email that summarizes security issues
    • Fail2ban – rule-based control of your firewall
    • Security Updates – how to automate

    Who this talk is for:

    Web developers who manage a cloud server, or those who want to manage one

    Key Takeaways

    Attendees will leave this talk with a better understanding of the threats that impact servers, and how to mitigate those threats. They will also have a list of resources and will leave with a basic understanding of how best utilize and implement those resources.

  • A few years ago, Ed Finkler got the conversation going about working in tech with mental health issues. Today we are keeping the dream alive with OSMI, pushing forward helping people understand what’s out there in the way of help and understanding. We will look at stats, stories, and more as we work through some tough issues.

  • Learn to expand beyond just PHP to integrate other languages into both your personal skill set and the solutions you deliver.

    In this talk we’ll cover integrating JavaScript (frontend and backend via node) and how you can expand your current skill set to include this or any other language alongside PHP.  The old saying, if all you have is a hammer everything looks like a nail, is very true so let’s learn how to use a wrench and maybe a chainsaw!

    Not only will this give you another tool in your tool belt, it will give you a greater understanding of development practices and the ability to on new jobs, new projects, and new challenges.

  • MySQL 8 comes with many new features like a transnational data dictionary, new locking strategies, resource groups, CTEs, Windowing Functions, improved JSON support, invisible indexes, and more. This session is designed for PHP Developers to see how to take advantage of these new features immediately plus show you how things behind the scenes like the new temp table that make queries much faster ‘out of the box’.

  • How do I know if my program will perform well in production? What does it mean to “perform well”? How much memory will it need? How much traffic can it serve? Are there any memory leaks or race conditions? What part of processing takes up most of the time? Can I optimise it?

    Every developer should be able to answer those questions about their code. But most of us don’t bother. Why? Because analysing performance is hard and as a result it is often skipped in the development process or ignored until things get really slow. Or we may simply not know where to start.

    Writing efficient code is a valuable skill that takes time to learn. Being able to analyse performance can not only prove that our code is efficient and safe to run in production, but also teaches us what to avoid next time. It may seem daunting at first, but with the right tools at hand it is a highly rewarding process.

    In this talk, we will analyse and optimise the performance of a simple PHP application. By demonstrating how to use some of the excellent open source projects such as xdebug and xhprof, I hope to give you a good idea of where to start with analysing and optimising your PHP code.

  • Your users deserve a fast and responsive web app and PWAs help you step that up a notch through notifications, offline support and more.

    There’s a lot that goes into that from understanding how the DOM tree works and how that plays with CSS and JavaScript to how to leverage the ServiceWorker for cashing and push notifications.

    In this session, we’ll build a PWA that show cases many of the things you need to keep in mind when building a great and fast progressive web app.

  • In this talk, I’ll convince you that your parents were wrong & procrastination is actually a best practice. I’ll discuss: what caching is, what queuing is, why you (probably) don’t need live data, why you should push everything off until later & how we can get our lazy on with Redis.

  • Congratulations, you made a todo list! Now you’re trying to write your next greenfield project in react+redux, but it seems the instant you step up a level in complexity the resources and advice are few and far between. You could succumb to JS fatigue and throw the whole thing out on your way to a life of farming in Kansas, or you could learn from my mistakes and (occasional) successes. Together we’ll look at how React and Redux scale not just in terms of quantitative performance, but in terms of architecture and team participation.

    You should expect to learn a deeper understanding of idiomatic Redux, tips for manageable and efficient store structures, organizing your domain model, React patterns and anti-patterns, efficient and predictable builds, pain free deployments and easy rollouts, and even some Hot Takes™ on when to focus on which improvements and which “common knowledge” rules are meant to be broken. Attendees with basic working knowledge of React+Redux will get the most out of this talk, however anyone interested in maintainably scaling a single-page-app out to multiple developers should still find ideas worth considering.

  • In software development, the two typical career paths are management and architect/systems design. Both of these share a common transitional step from development to the manager or architect role, a lead position. Time spent as a developer allows one to master technical skills that are useful as a leader, but being a technical lead requires skills beyond those of a developer.

    This talk will explore the interpersonal, communication, and organizational skills that the most successful leads have cultivated, and how to go about expanding your own skill set to include these.

  • Testing software in an automated fashion is one of the best ways to guarantee quality, reduce bugs, and prevent regressions in our code, and is a prerequisite to operating in a Continuous Integration environment. Unfortunately, the most difficult parts of testing come right at the beginning: scaffolding a test suite and writing our very first tests. For those who are new to automated testing, these hurdles can prove overwhelming.

    This talk covers the fundamentals of testing, in a beginner-friendly way. We’ll discuss how testing makes software better, the various levels of the Automation Pyramid, how to scaffold some basic unit and integration tests, and discuss the characteristics of great tests.

  • What if I told you that you don’t need a 100% code coverage?
    Compiled languages need to know about the type of every variable, return type of every method etc. before the program runs. This is why the compiler needs to make sure that the program is “correct” and will happily point out to you these kinds of mistakes in the source code, like calling an undefined method or passing a wrong number of arguments to a function. The compiler acts as a first line of defense before you are able to deploy the application into production.

    On the other hand, PHP is nothing like that. If you make a mistake, the program will crash when the line of code with the mistake is executed. When testing a PHP application, whether manually or automatically, developers spend a lot of their time discovering mistakes that wouldn’t even compile in other languages, leaving less time for testing actual business logic.

    There are several static analyzers available for PHP that substitute the role of the compiler from other languages. By finding bugs without even having to execute the code, they can save a lot of effort that’d be spent on tedious writing of boring unit tests. In this talk, I will share tips and tricks on how to structure your code to maximize benefits from using a static analyzer. You won’t stop writing unit tests, but you will focus your efforts on areas where they count the most.

  • OOP is awesome, and most PHP is written that way, but that doesn’t mean we can’t learn good habits and practices from Functional Programming too.

    Learn about PHP’s ability to do some FP, how to integrate it into your stack for cleaner code, and more reliable programming. See how we can limit mutations and side effects in your current setup by making small adjustments to your class structures and methods.

    Functional Programming can make your code safer, easier to test, and way more confusing – let’s find out how.

  • When did you stop speaking up? Was it when you were told you were too sensitive? Was it when Bill got credit for the idea everyone said sucked last week? When considering diversity and inclusion, when those generally not in the majority are invited to the table, they aren’t always heard. But how can we encourage diversity of thought? We must encourage thoughtful inclusivity of speakers.

    We will look at the ways that teams can encourage those who have been silenced before to speak up and how those that have been silenced can get their voice back.