Hexagonal architecture seems like a smart idea anyway, but wait until you find out how it helps with your automated tests.

In this talk I’ll show you how different types of tests could target different parts of your hexagonal (or layered) application.

Together these different types of tests will help you build a high level of confidence in the correctness and usefulness of your application.

• 11/11/2019 DP Tech Talk BCN meetup, Barcelona (ES) website video slides

Value objects, Entities and Domain events. These design patterns from the Domain-Driven Design discipline deserve some explanation, and most of all: some practicing.

This workshop offers both. We’ll talk about the characteristics of these objects in your application. I’ll provide lots of design tips and tricks. Switching all day between theory and practice, we’ll work on improving the design of existing classes as well as creating classes from scratch.

You’ll leave the room as a better object-oriented programmer, ready to apply design principles like command/query separation, immutability, and encapsulation to your domain model.

In this 2-day workshop, you’ll go back to the basics of object-oriented programming and learn to apply core principles of Domain-Driven Design to your domain objects: aggregates, consisting of entities and value objects.

You’ll learn how to progress from domain knowledge to a functioning domain model, and use unit testing along the way to describe the expected behavior of your objects.

The program

• Object-orientation, distilled

• Event storming session: the warehousing domain

Many web applications out there don’t get the testing love they need. Some test suites only have unit tests; they run fast, but will never prove that features as a whole function correctly. Some test suites only have functional tests; they run very slowly, they often fail for no reason, but they can prove that all the wiring is correct too. There is a middle ground, which we’ll be aiming to reach in this workshop. We take an existing application with only functional tests and “tease out” other types of tests. We thereby:

Of course, you should read all you can about SOLID, Design patterns, Patterns of Enterprise Application Architecture, etc. Once you have a basic understanding of these topics you still have to write that code though, and write it well too! What is good code? Are there some guidelines, or rules of thumb, which you can follow while making your everyday coding decisions?

In this talk I’ll cover many of these coding guidelines, which aren’t usually covered by patterns or principles books. They should help you write better code and give you a richer vocabulary for reviewing other people’s code. Some of the subjects that we’ll discuss are: state, mutability, CQS, one-method objects, domain-first, API-driven, functional programming influences, object boundaries, (de)serialization, and many more!

Working effectively with legacy code isn’t all about creating test harnesses before refactoring algorithms. The “safety first” strategy doesn’t always apply. Not if the code you’re looking at is LYING IN YOUR FACE anyway.

In this talk I’ll show you what brutal refactoring is. I’ll show you the red glowy eyes of the Churn. And I’ll hold up some big warning signs that should prevent you from producing legacy code today.

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.

• 06/14/2018 De Internet Jongens/Ode aan de Code website video
• 06/09/2018 Dutch PHP Conference, Amsterdam slides feedback video
• 06/06/2018 Drukwerkdeal meetup, Deventer (NL) website
• 01/26/2018 PHPBenelux Conference, Antwerp website slides feedback
• 12/21/2017 AmsterdamPHP meetup, Amsterdam website slides feedback video
• 12/21/2017 AmsterdamPHP meetup, Amsterdam website slides feedback

The ideal occasion to finally get started with Docker! You’ll learn everything you need to know to start using Docker in a professional environment. I’ll provide some general background information, but we will mainly take the time to make ourselves familiar with the docker command line tool and the Dockerfile configuration format.

To keep your sanity, you’ll also need to learn Docker Compose, which lets you define multiple containers and their images as services, with lots of interesting configuration options, all in one silly Yaml file! We’ll cover this configuration file format, the docker compose command line tool, and we’ll take a closer look at Docker networking and volumes.

Let’s have some fun while we entertain the idea that maybe - just maybe! - a microservice architecture would be a great fit for our (next) project. After all, we’re almost past the microservices hype. It’s time to prove that this can work!

Starting from the premise that a microservice architecture is only viable if we focus not only on the speed of change, but also improve the safety of change, we can learn a lot from the early adopters who have already scouted large parts of the unknown territory before us. Tools and platforms are maturing pretty fast too, so it’s safe to assume that we are now (almost) past the peak of impediments. Let’s start enjoying those microservices!

Spend a full day learning about Docker and related tools with Matthias Noback and Lucas van Lierop.

• Use this day to finally take a deep dive into Docker,
• Or bring your own Docker-based project and leverage the combined knowledge of all participants to make it better.
• Work together, or alone.
• Don’t follow along with the teacher, find your own path instead.
• Not limited to PHP, use the language of your choice.

We’ll offer interesting and useful material: articles, exercises, tips & tricks.