Commands, events, queries - three types of messages that travel through your application. Some originate from the web, some from the command-line. Your application sends some of them to a database, or a message queue. What is the ideal infrastructure for an application to support this on-going stream of messages? What kind of architectural design fits best? This talk provides answers to these questions: we take the *hexagonal* approach to software architecture. We look at messages, how they cross boundaries and how you can make steady communication lines between your application and other systems, like web browsers, terminals, databases and message queues. You will learn how to separate the technical aspects of these connections from the core behavior of your application by implementing design patterns like the *command bus*, and design principles like *dependency inversion*.

Test Driven Design is known for its ability of make us aware of bad design, thus having an important impact in improving our understanding of design or in some cases raising our awareness of the importance of design. Software tends to entropy, the more you touch the code the more random behaviour and complexity emerge. Creating a code base that ​stays​ with us for long is always a challenge. Good design is key ​to​ prolonging the life of​ our code. This talk ​illustrates​ the foundations of good design and how we can benefit from it in combination with other approaches like TDD, to ​guide​ us in the right direction of sustainable software development.

One of the main selling points of PHP 7 is greatly improved performance, with many real-world applications now running twice as fast... But where do these improvements come from? At the core of PHP 7 lies an engine rewrite with focus on improving memory usage and performance. This talk provides an overview of the most significant changes, briefly covering everything from data structure changes, over enhancements in the executor, to the new compiler implementation.

What exactly happens when you run `php example.com`? I wanted to answer this, so I decided to build my own PHP interpreter. Let me tell you what I learned and what does fancy words like opcodes and bytecode cache mean. With now two main rivals the standard PHP and HHVM from Facebook, there are plenty of choices to run your code fast. But they are both complicated projects, making it hard to understand the inner workings. Rather than relying on them to magically do the right thing, understand the principles of programming languages.

Many people teach design patterns as a fundamental step to Object Oriented Programming. They are so universally seen as important that almost every single programming conference that I have been to has had at least one talk about them. They are quite often used as interview questions to test a candidate's OOP knowledge. However, just like inheritance, they are not needed for OOP. And just like inheritance, they are a distraction rather than a foundation. Instead of focusing on patterns, I suggest focusing on learning about abstraction and communication. Why? Come and find out!

Processes are at the heart of how many businesses operate. The processes are governed by policies, agreed upon with contracts, and guided by documents. In software systems on the other hand, we often bury the processes. There’s a domain model for sure, but it’s all about “things” and “operations on things”. We need better, more explicit, more visual temporal models, so we can reason about the effects of time.

Graph databases come with enhanced connectivity of data and whiteboard friendly paradigm. Some, like Neo4j, also brings a gremlin in your code : it is one of the most powerful graph query langage. It brings a refreshing look at how we store web of data and search for it. Gremlin provides an abstract layer that make it easy to express your business logic without fighting with the code. It may even change your mind on object oriented programming.

The presentation focuses on our journey of migrating a legacy PHP application to a modern implementation, following the industry’s best practices and with 95% code coverage, capable of serving our global pool of users fast and reliable. We will go through all the steps we followed from the beginning, choosing the best framework for the job (Silex), building the application in increments, testing it and releasing it one page at a time without causing service interuption.

The talk's description While working on Sylius, I have come up with an idea for generic-use and format agnostic CRUD controllers. Thanks to several amazing packages from Symfony & Sylius communities, you can build REST APIs in minutes. What is Lionframe? Lionframe - Rapid REST API development framework, based on Symfony and few libraries, including: SyliusResourceBundle FOSRestBundle Hateoas JMSSerializer What you can do? Lionframe workflow is very simple: Create or generate your Doctrine model (~30s) Configure it as resource and in routing (~20s) Default REST API is ready to use! Sylius resource layer can work with any persistence backend, but currently ORM (SQL databases), MongoDB and PHPCR are supported. Doctrine ORM is used in Lionframe’s tutorial. Why? PHP Community has some great tools to handle REST APIs, but we need more rapid development and we decided to combine these tools with Sylius resource management bundle and provide you with a robust API framework.

In this talk I will explain the differences between different types of noSQL databases. I will then progress to illustrate which paradigm shifts are necessary to successfully implement noSQL, using MongoDB as an example. The approaches to schema design, fault tolerance, the network breaking and latency are all things that are inherent to scalability with noSQL solutions and with this talk you will learn how to use MongoDB effectively considering all the above mentioned situations. Covered subjects will be: schema design, dealing with error situations and architecture of multi-node set-ups.

We all know how good horizontal scaling is. We also know that PHP is born single threaded, and therefore it's not the best available tool for heavy processing or intensive batch jobs. In this talk we'll see how to get through these shortcomings, achieving parallel processing through native solutions such as Process control functions and POSIX functions, but also exploiting more recent techniques such as message queues and nonblocking I/O. We'll cover a wide range of examples from real world applications, and dealing with tools such as Gearman, Redis, RabbitMQ and ReactPHP.

The Standard PHP Library (SPL) has been an option in PHP since version 5.0.0 and always available since 5.3.0, yet few developers seem aware of the powerful features that it offers. From a comprehensive set of iterators and powerful classes, interfaces and abstracts that seem complicated, but are surprisingly easy to use; through a hierarchy of exceptions; and datastructures like heaps, stacks, queues and linked lists; to file handling classes; to the Observer design pattern: the SPL has something to offer that can simplify your code, improve its performance and reduce its memory usage. Despite its wide and varied uses, SPL has been largely forgotten: but now it's time that developers learned the powerful toolset that's available to simplify their work. The SPL provides a powerful and flexible toolset: yet few developers even seem aware of its existence, or of how they can use it to simplify their work and improve the quality of their code. It's time that changed; and SPL should take its place among the standard features of PHP that we use on a daily basis. This talk is aimed at reminding people that SPL provides real solutions to daily problems, and that it isn't simply an esoteric collection of tools that only belong in a Computer Science theory classroom.

Deploying code changes continuously to your production environment has many benefits. New features get to your users much faster which enables very short and quick iterations on them. And due to the small change sets you tend to encounter less bugs and regressions. In this talk I’ll present what Continuous Deployment means, and what you have to do, step-by-step, to make it work successfully for your project. We will cover topics like trunk based development, feature flags, partial roll outs, continuous integration, deployment automation and application monitoring.

PHP 7 is right around the corner, with the development team aiming to release it in a few weeks. With the previous major release of PHP having happened more than a decade ago this is a very exciting milestone in PHP's history, that promises to bring both far-reaching performance boosts for real world workloads and a host of new features. In the keynote, Zeev will share the evolution of PHP's major versions, the behind-the-scenes story of how PHP 7 came to be and its key benefits and features.