• Moving Out: What I Packed in My Suitcase

    When moving to the Netherlands, I had very limited luggage space, which meant I could only take the most essential items. Besides a few clothes, I ultimately chose a compact setup that’s easy to carry with me wherever I end up 🙂

    (more…)
  • Projections – Transforming Events into Read Models

    In an event-sourced architecture, the entire history of changes to the application’s state is stored as a sequence of events. However, to effectively work with this data, we often need optimized read models. This is where projections come into play. In today’s post, I’ll show you how to set up and implement projections in Ecotone, allowing you to easily transform events into the current state of your system.

    What Are Projections?

    Projections are mechanisms that allow you to “replay” the state of the system based on historical events. With projections, you can:

    • Maintain read models optimized for specific queries
    • Separate the write logic (command side) from the read logic (query side) – an approach known as CQRS
    • Preserve a history of changes so that you can rebuild the system state if needed

    Ecotone provides built-in support for projections, making them easy to define and manage.

    (more…)
  • PoC: Cooking with Flutter, Dart, and ChatGPT

    Have you ever stood in front of your fridge, staring at its contents, hoping that a ready-made meal would suddenly appear before you? I have. Too many times. But instead of accepting my fate and ordering pizza, I decided to harness the power of machine learning.

    In this post, we’ll build a simple—but fun—proof of concept. Here’s the idea: we’ll snap a photo of some ingredients, send the image to ChatGPT via its API, and hopefully ChatGPT will recognize what’s in the photo. Then it will shoot back three recipes that you can make with those ingredients, complete with step-by-step instructions.

    Let’s begin by giving a well-deserved round of applause to the Flutter and Dart ecosystem. Flutter is Google’s open-source UI toolkit, and Dart is the language powering it. Together, they let you create slick, cross-platform apps using a single codebase. The community around Flutter is absolutely fantastic—if you search for “Flutter” on YouTube, you’ll be greeted by tons of videos featuring the Flutter team themselves. They do such a fine job that these videos can work as an excellent intro not only to Flutter, but to programming in general.

    (more…)
  • Strategic DDD – Key Building Blocks and Their Role in Architecture

    Domain-Driven Design is an approach that helps build software reflecting real-world business logic. Within DDD, we distinguish building blocks – essential elements of domain modeling. Here’s their breakdown and application:

    Core DDD Building Blocks

    1. Bounded Context (BC) – Defining Model Boundaries

    A clearly defined part of the system where a specific model and business rules make sense.

    Example: The “Orders” module in e-commerce has different rules than “Invoices” – they should have separate bounded contexts.

    2. Ubiquitous Language – A Shared Domain Language

    A unified vocabulary used by both developers and business stakeholders within a specific context.

    Example: In a logistics context, “shipment” means something different from “goods” – precise definitions eliminate misunderstandings.

    3. Aggregate – Consistency and Integrity

    A group of entities and value objects forming a logical whole. The aggregate has a root, which controls access to other objects within it.

    Example: In an order system, Order is an aggregate, and its components may include OrderItem or Payment.

    4. Entity – Unique Domain Objects

    An object identified by a unique identifier that changes its state over time.

    Example: A customer with ID 1234 who can change their address and order history but remains the same person.

    (more…)
  • Introduction to Domain-Driven Design: What Benefits Does It Bring to Business?

    In the world of rapidly changing business requirements, creating software that effectively meets user needs is a key challenge. This is where Domain-Driven Design (DDD) comes in—a methodology that places the business domain at the center of the application design process.

    What is Domain-Driven Design (DDD)?

    Domain-Driven Design is a software development method that focuses on modeling business problems in close collaboration with domain experts. It was introduced by Eric Evans in the book Domain-Driven Design: Tackling Complexity in the Heart of Software. Its main principles include:

    1. Domain-based modeling – The application should reflect real business realities and use a language that is understandable to experts.
    2. Ubiquitous Language – A shared language between developers and business stakeholders that reduces misunderstandings.
    3. Encapsulation of domain logic – Business logic should be enclosed within appropriate structures rather than being scattered throughout the application.
    4. Bounded Contexts – The application is divided into logical modules (contexts) to avoid unnecessary dependencies.
    5. Application of strategic and tactical patterns – Such as Entities, Aggregates, Repositories, and Domain Services.
    (more…)
  • Welcome to my blog!

    Hi! My name is Ernest, and I’m happy to have you here. If you’re interested in programming, Domain-Driven Design, Symfony, or simply want to learn what life in the Netherlands is like, you’re in the right place!

    On this blog, I will share my knowledge, experiences, and thoughts on both technology and everyday life in Zeeland. You’ll find content about software architecture, backend development in PHP, Ecotone, Sylius, as well as more casual posts about my passions and exploring the Netherlands.

    Want to learn more about me? Check out the About Me page!