PHPSerbia Tickets

CQRS and Event Sourcing are challenging if approached for the first time, and especially if done from scratch. This tutorial day will lead give you a basic understanding of what CQRS and ES are, including their complexities, advantages and pitfalls.

We will help you modelling, designing and implementing an application relying on these architectural patterns, guiding you through:

  • Domain analysis
  • Involved architectural components
  • Data flow
  • Synchronous / Asynchronous dispatching
  • Implementing domain logic with aggregates
  • Projections
  • Scaling
  • Testing

Requirements for participants:

  • Laptop with WiFi
  • PHP binary (no docker, no vagrant)
  • ext-pdo_sqlite
  • ext-mbstring
  • ext-xml
  • SQLite editor (PHPStorm integrates one)

“Hope for the best and plan for the worst.” We spend a lot of time talking about best practices: the ways we should run our projects and write our software so that everything turns out as well as possible. But when you add human beings to the mix -- whether they’re coworkers, clients, or, well, you and I -- something will eventually go wrong.

Using stories from the interactive agency world (where no two clients are ever the same), we'll talk about methods for triage, what to do when you sense a project is on shaky ground, and ways to ensure everyone gets to the other side in one piece.

Bundles. Packages. Modules. Plugins. So much code is locked up in framework-specific packages. With so may people talking about wanting to write framework agnostic packages, it can be easy to get stuck thinking that this is, and should always be, the end goal. Learn about one developer's experience trying to write truly framework agnostic code. See what worked, what didn't, and walk away having a better idea how you, too, can attempt to unglue all the things!

One of the most recent new features of PHP is Anonymous Classes, introduced with PHP version 7. But what are Anonymous Classes? How do you use them? And what would you use them for? Let's take a look behind the mask, and find out.

In this talk you will learn what PSR-6 and PSR-16 are, why they are designed like they are, what the differences are, and how to use them. From the provided interfaces, the virtual package on, to the implementations available. Everything will be explained for both beginners and more experienced developers. We will dive into implementations, cache stampede protection, all using libraries we can find on We will also show how to start using it today in our current applications by using adapters. The entire talk will be accompanied with code samples and live demos, showing both working and failing caching systems.

We always try to avoid the famous Big Mall of Mud™ due to many reasons but what happens when we're already facing it - and making profit with it? Should we just accept our fate and keep fixing bugs for the rest of our lives or should we actually do something different? In this presentation we'll share the challenges we're facing at Usabilla and how we're using DDD and Kafka to understand and decompose our software into services without having downtime or any impact on our users' experience.

The blockchain is a hot new topic in the technology due to the rise of various cryptocurrencies, Bitcoin being a most prominent example. How does it work? What advantages does it give? What problems do they solve? What problems can be solved that way? I want you to dive with me into the immutable world of blocks where I will explain everything, from a simple hash, through Merkle trees, up to implementing your own blockchain.

No no, not country flags, feature flags! Feature flags are a powerful technique that allows teams to modify a system's behaviour without changing code. They can be used several reasons - canary releases and A/B testing to name a few.

This talk will show you how you're already using feature flags in your application without realising it. Next, we'll take a look at some of the best tooling out there to help you take feature flags to the next level. Finally, we'll cover strategies for removing feature flags before they become technical debt that you have to manage.

Whenever you are faced with a problem it is normal to try to find a generic solution and then you implement that solution in code. But some problems might be too complex to solve by humans (and even engineers). Imagine you are a traveling salesman, about to visit 10 cities in Europe. You can visit them in any order. What’s the cheapest route? To find this out, we could use dynamic programming to let the computer solve the problem for us and just give us a result.

Event Sourcing can look like an attractive solution for any of your applications, but does it actually pay off? What if it is all just buzzwords and no gain? We’ll look at how we implemented event sourcing in our own app,

  • what made us fast
  • what made us super slow
  • what made us cry

This talk will give you a good idea of what kind of challenges you will encounter when approaching event sourcing for the first time.

Have you tried to write a Chatbot for multiple messaging platforms like Facebook or Slack? It is quite cumbersome as each messaging platform has its own way of communicating with your application. Let us find out how to simplify this task and create an intelligent Chatbot using PHP and BotMan.

While PHP’s open source community is thriving, only a relatively small number of PHP developers contribute to the number one tool they use on a daily basis: PHP itself. Although it may seem daunting to help out on a project written in C, requiring compilation and linking, getting started is actually pretty easy. In this talk I would like to share my own recent experiences of beginning to contribute to PHP itself. We will see different ways to contribute and cover some practical tips, workflows and resources, so you can start giving back to your programming language straight away!

Our application has so much going on! Slow page loads and a large legacy codebase make developers feel stuck between a rock and a hard place. In this session, we will explore a strategy to add a modern codebase alongside the legacy code, allowing them to run simultaneously until you replace it. We will discuss common legacy problems like complex database queries causing slow downs and large reports that take so long to load, users must wait instead of analyzing the data. As our system has grown, we may need to separate our application into distinct parts and pass relevant information between them. Or maybe we have two distinct codebases already and each codebase is affected by the other's changes in ways we didn't expect. We will examine how to add Event Sourcing and CQRS to these pain points and throw away that legacy spaghetti!

Does managing YAML, XML or PHP container configurations make you sad? Do you dread making changes to your classes’ dependencies for fear of the inevitable container configuration wiring blues? Life doesn’t have to be this way! Not if your container supports autowiring, that is. Hear one developer’s journey into the wild world of containers, learn how autowiring works, and find out how using autowiring can free you from having to manually configure every dependency.

Our clients come to us to solve their problems using software. We listen to their pitch, we read their emails, have a meeting or two, and then we take out our favourite code editor, framework and database, and start pounding at the keyboard. Few weeks, months later, we come back with a solution to all of their problems. Or is it, really?

Our solutions should be driven by our clients and what they really need. We need to listen to them, talk to them, understand them.

This presentation will show why we should become better communicators, and how we can use Domain Driven Design to bridge this communication gap. Creating an ubiquitous language that we share with our clients, we model their world in ours. These models live in bounded contexts, made out of aggregate roots, domain events, entities, value objects, that are all here to guide us to create better solutions, and write better software.

Tokens are widely used to identify resources and try to add some security to insecure environments, but sometimes the management of those identifiers can get a bit complex - even more on distributed systems. What if we could have an intelligent token, one that simplifies the way things works without losing integrity or security? In this talk we present JSON Web Tokens as an alternative for smart and self contained tokens, explaining how to use each claim and giving some common use cases.

The world we live in is one where data is one of the most valuable assets. There are many different pieces of data we can analyse on all kind of data from analytics of user behaviour of your platform, user generated content, monitoring of exception rates, or when your core business model is to provide some kind of analytics platform. This talk will talk about how you can, in your PHP applications, perform utilise machine learning techniques to build models, analyse data to get useful information and spot anomalies.

Functional programming is a programming paradigm with origins in lambda calculus and the 1930's. Stack Overflow's developer survey 2017 shows that the languages optimized for functional programming are low in popularity. However, the same survey recognizes that developers actually working in Elixir, Clojure, F#, and Haskell, actually love their languages much more than PHP or C developers.

So functional programming is unpopular but fun!

The good news is that it can be applied in a popular language like PHP. Whilst the bad news is that PHP might not be 100% optimized for functional programming, we already have pretty nice libraries of functional primitives for PHP. Accepting functional programming style may help PHP developers develop a bit cleaner or more interesting code. More importantly, it will make it a whole lot easier to pick up an actual functional language or make use of serverless architectures such as AWS Lambda. This session will cover:

  • Introduction to lambda calculus
  • Basic principles of functional programming
  • Overview of the lstrojny/functional-php library
  • Performance, compared to imperative programming style
  • Reusability, compared to object-oriented coding
  • Serverless computing as one of the great applications for functional programming paradigm

Graph Databases are naturally well-suited for building recommendation engines. In this talk, Christophe will share his experience building a number of production-ready recommendation engines using Neo4j and introduce the open-source GraphAware Reco4PHP Library, which enables PHP developers to rapidly build their own recommender systems.

This presentation starts by a brief explanation of why graphs are a suitable data model for building recommender systems. A summary of typical recommendation engine requirements follows, including the business and technical challenges these requirements introduce. Afterwards, the talk dives into possible solutions of these challenges, both from business and architectural/design perspectives, and introduces the GraphAware Reco4PHP Library.

What follows is a demonstration of how this open-source recommendation engine skeleton solves many of the issues and how it handles the "plumbing", so that developers can focus on expressing the business logic specific to their domain.

A majority of examples in this talk are drawn from real-world use cases and the speaker's personal experience building recommendation engines. Attendees should have a very basic understanding of graph theory. Prior experience with Neo4j and the Cypher query language is a plus, but not necessary.

Have you ever heard terms like automata theory, Turing machines and finite state machines? While they might sound too abstract or even out of place for web development, rest assured, they can be quite useful in your web applications.

We will quickly cover some basics and then dive right into most popular PHP state machine libraries. After the talk, you will know benefits of using state machines and, most importantly, how and when to implement them.

Remember the last time you spent an afternoon setting up the server for your new app? Or that time unexpected traffic peak ruined your weekend. We all do...

As an application developer you shouldn't care about that. And the solution is right in front of us all. It does include servers, despite its name. But the servers you don't need to care about.

This talk is about that solution. It will show you what is serverless and why should you care. And it will also tell you how your future apps might look and works in a serverless way.

If you look at the stage of any conference in the PHP world, people are preaching testing,testing,testing ... If you on the other hand look at the community, the percentage of people writing tests is really low.

As a person who went from 'How can I ask for more time/money/resources for testing?' through 'ask for forgiveness instead of permission', to person who writes tests a lot, I still believe testing doesn't make sense. No, it doesnt make sense for all and everyone, often enough it makes no sense for me too.

This talk will explore that fuzzy line when you have to shift your mind from one side to the other: in both directions.

All of a sudden, it happens! Your site is receiving tons of traffic and is folding under the pressure. What can be done to make your system more scalable, what are the key point in organizing code and services so they can take the load.

The talk will cover the first lines of defense using Varnish, denormalizing data so it can be queried faster, usage of search engines (SphinxSearch) and key-value stores (Redis). It also provides background on how to still keep the site individual for every user.

Focus will be on the use of open source software and medium-sized service APIs to deliver the best possible experience for the customer.

Can you afford not to be prepared for the big traffic storm?

Get updates to your inbox