ZenWave 360º

The critical complexity of most software projects is in understanding the domain itself. - Eric Evans in Domain-Driven Design

👉 ZenWave360 Helps You Create Software Easy to Understand

Being easy to understand should be the gold standard of good and maintainable software.

ZenWave 360º is a set of tools built on the foundations of Domain Driven Design and API-First principles for Event-Driven Architectures.

Domain Driven Design and API-First for Event Driven Microservices

The domain model is a powerful communication tool. It provides a shared vision of the structure and behavior of the system.

Event-Driven Architecture reflects how we conduct business in real life - asynchronously and in response to events. That is why it is gaining popularity as the go-to architectural pattern for building enterprise applications.

Our lives and businesses are a continuous sequence of events. We are perpetually responding to these events and initiating new ones. This is a reflection of how we operate in the real world. Therefore, Event-Driven Architectures (EDAs) are ideally suited for creating software that accurately represents and empowers our business processes.

Domain-Driven Design (DDD) is a software development approach that emphasizes the importance of understanding the business domain in order to create effective software. Design, in the DDD sense, is really about understanding, not inventing. Focusing on creating software that matches the mental model of the problem domain.

With a good understanding of the business process we want to model even the simplest architectural pattern suffices for crafting software that's straightforward and maintainable.

On the other hand with a poor understanding of the business process we want to model, there is no amount of clean code, clean architecture, SOLID principles, hexagonal, event-driven... that will make your code easy to maintain and to evolve because with a poor understanding, new requirements will spring as a surprise shaking the foundations of your previous design.

ZDL Domain Model Language as 'Ubiquitous Language' format

ZDL is a developer friendly domain model format, that can map the discoveries of Event-Storming workshops capturing the essence of Event-Driven Domains while maintaining the business language brought up during Event-Storming sessions.

ZDL Domain Model Language is

Developer Friendly: compact and concise format resembling a very lightweight programing language.
Retaining the Business Language discovered during Event-Storming sessions
And because it's also Machine Friendly it can be converted into multiple software artifacts propagating that Common/Ubiquitous Language automatically and effortless.

Efectively closing the Gap between Domain Experts, Technical Experts and Working Software & Tests

ZenWave SDK Accelerates your Development Cycle

Code is not the center, but merely one expression of the model.

Because the most effective way to model is to do so in the context of a running system that can demonstrate whether the model actually works. ZenWave SDK helps you convert your Domain Models into working Software & Tests.

ZenWave SDK accelerates your development cycle by converting your Domain Models into well crafted software artifacts you can assemble into a running application.

With ZenWave SDK you can quickly convert your models into working software:

API definitions: OpenAPI and AsyncAPI v2/v3
Multiple backend implementations with Spring-Boot and Spring-Cloud: with JPA and MongoDB flavors.
SpringMVC RestControllers from OpenAPI + ZDL: complete controller skeletons with their mapstruct mappers, connecting the inside of your backend with the external world through your APIs.
API-First code generator for AsyncAPI v2/v3 for producing and consuming async events.
API-Testing with Spring WebTestClient and KarateDSL.

ZenWave SDK main purpose is to help you produce successful software projects by dramatically shortening the feedback loop between the expert domain knowledge and working software and its tests.

In this way all team members: Domain Experts, Product Owners, Software Architects, Developers and Testers can provide early feedback based on an Ubiquitous Language (ZDL) and the software and tests generated from that model.

ZenWave 360º Landscape

ZenWave 360º is a set of tools that help you create software that is easy to understand, maintain and fulfill the requirements of your users.

ZDL Domain Modeling Language
- ZenWave SDK: CLI and Maven Plugin
- ZenWave Editor: IntelliJ Plugin
- ZenWave Models Catalog: <coming soon>

Business Domain Modeling

A good model is a foundation that can accommodate change in the direction and perspective of business experts.

ZenWave 360º Business Domain Modeling is sustained in three pillars:

Understand the Mental Model of the Business Experts.
Use ZDL Model Language to create and Ubiquitous Language that reflects the mental model of the Business Experts.
Use ZenWave SDK to convert the ZDL Model into different Software Artifacts.

Understand the mental model of the business experts

This approach emphasizes the importance of understanding the business domain in order to create effective software.

The first step is to understand the mental model of the business experts because all requirements and assumptions will come from this mental model. Embedding the perspective of domain experts into your model is by far the most important aspect to create good maintainable software.

If we don't get right the mental model of business experts, no amount of Clean Code, Clean Architecture, Hexagonal Architecture, etc... will help in creating good and maintainable software.

Event-Storming is the method we employ to grasp the mental model of business experts. Because it's technological low entry barrier, and because is a perfect fit for modeling Event-Driven Architectures.

Create and Ubiquitous Language to reflect the mental model of the Business Experts

It is not the domain experts’ knowledge that goes to production, it is the assumption of the developers. - Alberto Brandolini

The goal of Ubiquitous Language is to create a common language that reduces misunderstandings and improves communication between technical and non-technical team members.

Shared and Common: The language is shared by all team members, including developers, domain experts, and stakeholders. It's used in all forms of communication, from meetings and emails to code and documentation.
Model-Based: The language is based on the domain model. It reflects the structures and relationships in the model.
Explicit: The language is explicit, meaning that each term has a specific and clear definition. This reduces ambiguity and misunderstanding.
Used in Code: The language is used in the codebase. Class names, method names, variable names, etc., should all be based on the Ubiquitous Language.

ZenWave ZDL Modeling Language is a Domain Specific Language that allows you to create a Conceptual Model that reflects the mental model of the business experts following DDD and Event-Driven Architecture principles.

It can map the discoveries of an Event-Storming session, retaining the language of business experts. It's designed to be developer friendly, and because it can be converted into different software artifacts, it will propagate that Common Language to code, tests, api definitions...

-> As a technical expert you can use this ZDL Modeling Language to communicate within your team, and narrate the story expressed by the model back to domain experts in their own language.

Convert the Ubiquitous Language into different Software Artifacts with ZenWave SDK

The best way to validate a conceptual model is to implement it.

Working software is the best way to evaluate the validity of a conceptual model. It allows for early feedback from all members of the development team, including developers, testers, and others, which can be crucial for the iterative refinement of the model.

ZenWave SDK is a set of tools that allows you to convert the Ubiquitous Language into different software artifacts, like:

API Definitions: AsyncAPI v2/v3, OpenAPI...
Drawings and Documentation: PlantUML, Mermaid, Markdown...
Multiple Backend Implementations for Spring-Boot, Spring-Cloud, JPA, MongoDB...
API-First Code for AsyncAPI and OpenAPI
API-Testing...

Automatically propagating the Ubiquitous Language across code and providing the building blocks to put together a working implementation of your domain in no time.