Get rid of big ball of mud with style
Software Developers & Architects familiar with PHP development, who wants to get toolset to build complex, large scale applications with maintainable with focus on business problem solving instead of struggle with microservices infrastructure ballast.
10% lecture, 40% hands-on modelling, 50% hands-on coding
2 days (1 day compressed version for conference workshops)
Developers life is not always a greenfield playfull time. Most of us find ourselves during our career in need to work with the big ball of mud system. There are several scenarios to use in that kind of situation. One of them is decision to move to microservices infrastructure.
In developers eyes, it looks like a bright, shiny solution for all our problems with messy code. In a happy case, microservices will become micro for real. They will have a pretty, clean and organised code. More likely their dependencies will be still hard coupled. That leads us to some kind of distributed ball of mud. And distributed mud is not something that we want to cooperate with. Same in our homes as in code. It’s easier to clean mud that we left in one place in our doorway, then spread through the whole house.
An alternative to that approach is what we called a modular monolith. It comes with most of the benefits of microservices as independent modules. Implementation of those separate modules can use a different architecture style for each. They will have loose coupling and should communicate in a well-defined way. Also, we don’t need to struggle with all the infrastructure things. And those are one of the biggest challenges in a microservices architecture.
During the workshop, you will see what techniques you can use to look for the boundaries of the modules. We will go through architectural styles that you can apply in different kind of modules. We will find some heuristics that help to choose the for a different kind of the bounded context purpose. You will learn how to use frameworks (on Symfony example) for the modular monolith. We will do that in a little different way than it’s shown in the documentation of the tool. This way will help us to have well-structured modules in our application. Loose coupling between them is a must.
- Define bounded-contexts in the process/application
- Chose architectural style for the context
- Implement independent modules in the application
- Loosely coupled communication between modules
- Use hexagonal architecture in a modular monolith application
- Use Symfony framework to support work with modular monolith application
- what is a modular monolith
- bounded contexts
- Domain space
- whole space visualisation
- defining context boundaries
- Architectural styles
- different types of architecture styles
- heuristics for styles usage
- Modules implementation
- framework agnostic approach
- communication between modules
- tools to keep eye on modules independency
- Hexagonal architecture
- isolation from tools and infrastructure
- isolation between contexts
- Integration with infrastructure
- integration with framework (Symfony example)
- integration with storage (DB example)
- integration between modules
- What’s next
- module as a future microservice
- Proficiency in programming in PHP language
- Laptop/notebook with a working development environment:
- newest PHP version
- relational database with the ability to connect to
- Ability to connect to the Internet
- Cabaret or boardroom style setup