Sessions

  • Talk: 2nd hardest thing in computer science

    Have you heard about the two hardest things in computer science? It’s cache invalidation and naming things. I want to focus on the second one. Let’s see common examples of both good and bad naming. What’s the common part of each of them? What’s makes names good? Can we settle on good enough or should

  • Talk: Advanced debugging techniques

    Step-by-step debugging with Xdebug is no secret for you? Perfect then, because we won’t talk about it. We will rather see tools that let you know what’s really happening in your PHP code, like the phpdbg debugger, phptrace, process tracing tools like: strace, ltrace, the Linux inotify mechanism, tcpdump/wireshark for network analysis or MySQL Proxy

  • Talk: Aiming for Autonomous Services

    The much hyped “Microservice Architecture” tells us to design our services to be autonomous. Let’s find out what this means and how we can achieve it. In this talk I will guide you through the fascinating world of asynchronous communication, event-driven systems and distributed data.

  • Tutorial: Building (on) IoT devices for web developers

    Internet of Things, City of Things, Smart Cities,… they’re all vague descriptions for the same thing : a collection of networked devices providing or consuming information. But how do these devices work and how can a web developer not only use their data, but actually work with the devices directly ? We’ll have a look

  • Tutorial: Building Autonomous Services

    In this workshop we’ll dive into the topic of Autonomous Service development, with a sandbox project containing several interdependent services. These projects send messages to each other, and they call each other to retrieve data. In other words, they’re not autonomous at all. We’ll figure out some ways in which we can invert dependencies and

  • Talk: Building teams, what can we learn for professional sports

    It’s about building a development team that can rely on each other. Which phases does a team go through when it’s growing? How do you work with each other, what are the unwritten rules. How can you build routines, get better at estimating. Why is the principal developer as important as the newly joined junior

  • Talk: Challenges deploying PHP apps on multi node docker swarm

    How do we get started with docker swarm and how do we get to the point we can properly deploy and update our php applications. Can we just add and remove nodes, what about our data?

  • Talk: Crafting Quality PHP Applications

    This prototype works, but it’s not pretty, and now it’s in production. That legacy application really needs some TLC. Where do we start? When creating long lived applications, it’s imperative to focus on good practices. The solution is to improve the whole development life cycle; from planning, better coding and testing, to automation, peer review

  • Tutorial: Debugging PHP Applications

    Sooner or later, an application will have errors. Some of them will be your fault, or that of a teammate. Others stem from third party libraries you are using. We want to be able to locate the cause of the error as quickly as possible. In this workshop, we will do exercises that will help

  • Tutorial: Demystifying Object-Oriented Programming

    Abstraction, Encapsulation, Polymorphism, and Interfaces: whether you’ve been programming in PHP for years or are just starting your journey, these terms can be overwhelming. Not only that, people that already understand it act like it’s so easy and they talk right over the simple questions and never explain the basic concepts in a way that

  • Talk: Disco – A fresh look at DI

    In this session let me introduce you to Disco, a PSR-11 compatible, annotation-based Dependency Injection container. Disco does not use an external configuration file but uses a standard PHP class with some meta data attached to configure your services. I will guide you through the journey of setting up Disco for a new project as

  • Talk: Does the SPL still have any relevance in the Brave New World of PHP7?

    Largely ignored under PHP5, the SPL (Standard PHP Library) offered a powerful toolbox for developers, ranging from it’s horrendously named collection of Iterators, and a series of Interfaces allowing us to build our own, to DataStructures, and Object Oriented file handling classes. Fast and powerful, the SPL provided a stable and well-tested library of classes

  • Tutorial: Domain-driven Design in PHP

    Building PHP applications using Domain-driven design techniques results in code that is easier to modify, maintain, and test, and a better user experience. Once you try DDD, you will never design software in the same way again. In this tutorial, we will start by learning how to build a strong ubiquitous language with stakeholders. Then,

  • Talk: Exploiting the brain for fun and profit

    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

  • Talk: Immutability to Save an Ever-Changing World

    Want to build software that is more testable, easier to modify, and has fewer lines of code? Architecting 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, more DRY

  • Talk: JavaScript State of the Union

    This session will cover the developments of the JavaScript / ECMAScript language in recent years, to give you a quick update on how JavaScript can be written in 2018. The pace of the JS community has remained very high for several years now, and it is often easy to be overwhelmed by the amount of

  • Talk: Laravel Design Patterns

    Most of us use Design Patterns on a daily basis without noticing. Design patterns are commonly defined as solutions to recurring design problems. Frameworks like Laravel use Design Patterns throughout the codebase to keep structure and maintainability. In this talk we will explore 3 to 4 Design Patterns used in Laravel. Once we have a

  • Talk: Learning Machine Learning

    From chatbots to your home thermostat, it seems like machine learning algorithms are everywhere nowadays. How about understanding how this works now? In this talk, you will learn about the basics of machine learning through various basic examples, without the need for a PhD or deep knowledge of assembly. At the end of this talk,

  • Tutorial: Making Async Applications

    You’ve probably been to a couple talks, about how to do “asynchronous things” with PHP. What the experts don’t tell you is that the hard part starts when you need to build an application. Sure, there are tools for starting an HTTP server or connecting to a web socket. But what about when you need

  • Talk: Monads in PHP

    Many developers get lost in the hype of object oriented design. They miss out on how expressive and succinct their code could be if they tried functional programming. Take Monads, for instance. Many developers haven’t even heard the name, much less are able to describe what Monads are and how they can be useful in

  • Talk: Proactive web security

    Keeping your web application secure and free from vulnerabilities is hard work, even if you know the OWASP Top 10. In this talk I will show tools, best practices and patterns to help you with this, so that you can find security issues before an attacker does and even prevent them in the first place.

  • Talk: Refactoring, the third commandment

    If it works doesn’t imply it’s good. Improving the internal structure of a project is important for many reasons. Refactor also means simplify the debug processes, tuning up performances and make the code readable to avoid a gradual spaghetti project failure. This talk shows some important bad code smells, how to assign priorities, tools useful

  • Tutorial: Symfony 4 – Hands On!

    In this 3 hour tutorial session, you’ll learn how to quickly get started with Symfony 4 and build you very first small application. To get the most of it, we’ll try to cover as many topics as possible in 3 hours : Installing Symfony and third party free plugins with Symfony Flex, Configuring the application

  • Talk: Symfony Internals

    Symfony has a wide userbase today. Most who work with Symfony on a daily basis have configured their own services, are fluent in configuring routing and validators. But what is actually going on under the hood? What happens when the configuration is parsed? What is a cache warmup? What happens to a request before hitting

  • Talk: Tales from the wrong end

    I’m the maintainer of a very popular open-source PHP package – PHPMailer. In December 2016, two critical vulnerabilities were found in PHPMailer, affecting potentially millions of sites. I’d been involved in reporting minor security issues in the past, but nothing of this magnitude, and never at the receiving end. I found myself at the start

  • Talk: Technically DDD

    You might have heard of Domain Driven Design. You may have heard DDD is a tool to write readable and change-ready code. You may have even heard DDD comes with a lot of talking, and modelling, and customers… Starting with DDD sounds big, and scary, doesn’t it? But getting started is not scary! Come find

  • Talk: The Science of Code Reviews

    We all make mistakes, as much as we try to write flawless code, every now and then an error slips through. In order to reduce this number we do code reviews to ensure the code meets certain standards and to see if the feature was properly implemented. But how do you do a good code

  • Tutorial: Thinking in Events

    Modeling complex problems is hard and often leads to very complicated code. Controllers, repositories, services, conditions, forms – client’s business requirements sometimes infiltrate all these layers, everything is mixed together, making code really difficult to read, understand and develop. When you want extend business logic, but you need to dig in tens (or even hundreds)

  • Talk: What the FLOAT!

    We have all seen some pretty interesting things happen when using floats. You might even know how to get around most of these problems. But why do these problems occur? Why do floats become so inaccurate when working with really small, or really large numbers? In this talk, we will take a look at decimal

  • Talk: Year with event sourcing and CQRS

    For the last few years, PHP community has been buzzing about ES/CQRS, pretty much there was a talk on every conference. Now it’s time to see how it worked out for me in practice. ES/CQRS is a different approach to building applications from what we all have been thought to do for years. I’m not