XOOM Ecosystem

We have invested heavily in the creation of a software ecosystem that accelerates the development and delivery of solutions to complex business systems that use leading-edge architectures.

The ecosystem described here is the open source XOOM platform SDK. There are a number of open source components available with the platform, but these are most easily used by means of the XOOM Turbo container.

XOOM is built on an Actor Model foundation, provides REST and RPC in a lightweight, embedded HTTP server.

Reactive HTTP
Embedded HTTP server is fully Reactive.

Domain models that scale over a data and compute grid are hosted by a scalable cluster component. The domain model can use any combination of Event Sourcing through the base type EventSourced, and two additional styles known as StatefulEntity and ObjectEntity.

Domain object types stores
Storage styles include event sourcing, key-value, and object mapping.

These base types are applicable to Aggregates and Sagas alike, and are supported by three types of different storage mechanisms.

Another important component of the XOOM ecosystem is SCHEMATA, the schema registry as depicted in the following diagram. This is generally missing from Event-Driven Architecture efforts, which causes very big problems as the system is built out with more and more subsystems, such as services and applications.

Schemata Schema Registry
The schema registry supports the Context Mapping pattern Published Language.

The XOOM SCHEMATA schema registry supports more than Domain Events. Also included is registration and version compatibility for Commands, Data (value types), Documents (query results, etc), and Envelopes (message metadata exchange).

The XOOM Designer is hands down the best way to jumpstart any Reactive DDD effort. The Designer presents a simple modeling environment that resembles the elements of EventStorming, but with a slice through the system.

XOOM Designer
XOOM Designer is hands down the best way to jumpstart any Reactive DDD effort.

After EventStorming in Big-Picture mode that leads to Design-Level detailed storming results, consolidate the Commands, Aggregates, and Domain Events into stacked sets as you see in the above diagram. Describe the Design-Level detailed sets in the XOOM Designer UI, select the architecture mechanisms and deployment container of choice, and adopt the results: a bug-free microservice fully prepared for Reactive, Event-Driven deployment.

The XOOM Designer support includes:

  • Platform
    • JVM: Java and Kotlin
    • .NET: C# and F#
  • Context
    • Bounded Context service/application naming and versioning
  • Model
    • Define Value Objects, Aggregates, Commands, and Domain Events
    • Integrates with SCHEMATA to provide and use Published Languages
    • Integrates with messages exchanges, such as Kafka, RabbitMQ, SNS, SQS, and many others (more than 300 total)
  • Storage
    • Optionally use CQRS and Event Sourcing
    • Choose a storage type for CQRS Command and Query models
    • Databases: DynamoDB, Postgres, MySQL/MariaDB, others
  • Deployment
    • Types: Native, Docker, Kubernetes
  • Generation
    • Generate full projects including a compressed Reactive, Event-Driven, Ports & Adapters architecture
    • Target: JVM with Java or Kotlin source
    • Target: .NET with C# or F# source

The components described in this post are only part of what’s available in the ecosystem. Additional platform components are available in the full SDK. All together, XOOM delivers rapid and low-code solutions to accelerate development of fully-tested, bug-free, high-performing, business-driven, cloud applications and microservices.

With the head start that we make possible, you quickly establish a significant gap between your software and that of your competition. The large advantage that you gain occurs in an industry that’s plagued by overly-complex solutions with upside-down focus, and throttled by slow delivery, that often lead to failing software projects. From your newfound vantage point, you transition the low-code into a full-code software development life cycle.

That’s just what a Reactive ecosystem should do for you, which describes XOOM. What’s available today in XOOM is really the start of the most powerful ecosystem for accelerated precision in software systems development and delivery.

More to explore

Reactive DDD: Modeling Uncertainty

Domain-Driven Design supports reactive architecture and programming. Still, reactive introduces uncertainty. Back in 2003, the way that Domain-Driven Design was used and

Scroll to Top