Overview

Search…
Overview
How you can expect to benefit from the VLINGO XOOM platform's rich ecosystem.
The software industry needs to achieve greater success with cleaner solutions more quickly. Filling these needs is the vision behind the VLINGO XOOM platform. Achieving that vision has resulted in a software development platform that enables these vital capabilities:
Laser focus on business value and away from technologies
Rapid, bug-free software development and delivery with minimal source code
Minimal source code that forms a clean, robust, and flexible architecture
Here's how we afford that.
Laser Focus on Business Value
Our platform promotes and supports the Domain-Driven Design (DDD) approach to software development. By using DDD, teams are assisted with tools that emphasize software from the viewpoint of strategic innovation. The tools help pinpoint opportunities to reach competitive advantage through experimentation leading to deep learning and discovery of previously unknown value. The nature of the VLINGO XOOM platform SDK provides a sound foundation that does not interfere with these ambitions, but rather encourages them by assisting teams of business experts and software developers.
Further, DDD stresses the use of fluent language to model solutions in complex digital business problem spaces. Most technology frameworks greatly detract from this goal. The VLINGO XOOM platform SDK not only enables, but also enhances the DDD experience. In addition to helping teams reflect their business modeling language in the model, the APIs support fluency by expressing fluency that blends with the business software model.
Rapid and Bug-Free Delivery
By using the XOOM Designer, business-driven, bug-free software solutions, such as applications, microservices, and subsystems, can be delivered within several minutes or a few hours.
Use the XOOM Designer to accelerate software model development and delivery.
There is no better way to achieve this level of accuracy in business-critical software solutions that is: fully tested and bug-free, highly efficient, broadly scalable, as well as flexible and accommodating of change.
Minimal Source in Clean and Robust Architecture
The XOOM Designer helps you produce a software development project with minimal source code. It's a low-code solution that immediately transitions to a full-code software development life cycle (SDLC).
The XOOM Designer helps teams deliver a clean and robust architecture for each application and microservice project that it assists in producing. Emphasis is given to these factors:
​Compressed Ports and Adapters Architecture, making the solution flexible and accommodating of change, yet with only two layers that are "baggage-free."
Event-Driven Architecture that provides automatic translation and dispatch from incoming requests and event notifications to the business-driven domain model, and from the domain model outward to other applications and microservices.
​Type-safe and version-safe integration across applications and microservices with the assurance and confidence that seamless operations will continue deployment after deployment.
​Domain-Oriented Microservices Architecture (DOMA), inspired by DDD, focusing on the long-term delivery and maintainability of microservices.
With our clean and robust architecture focus, including DOMA, you and your team are availed the most powerful SDK to express your software models, subsystems, and whole system solutions with business-driven accuracy and innovation, loose coupling, along with the longevity of the overall system.
Platform Benefits
A generous toolset of prebuilt, clean and robust abstractions, designed for use in implementing Reactive DOMA- and DDD-based full system solutions, is yours when adopting the VLINGO XOOM platform. You gain an environment for rapid, low-code as well as full-code SDLC, supporting fluent, highly scaleable, and concurrent models, with precision and type safe integration across subsystems. Capabilities include Reactive REST services over HTTP, domain object aggregates, key-value aggregates, event sourced aggregates, CQRS with projections, compute grid, actor/object caching, object spaces, cluster cross-node actor messaging, enterprise message exchanges, and long-running processes (aka Sagas).
Simplistic Power—Actor Model Foundation
A charter member of the Reactive Foundation, VLINGO and the XOOM teams are leaders in Reactive software architecture and development. Whether with DDD or a different approach, you can count on our platform to help you deliver scalable and performant event-driven solutions. At the foundation of XOOM, our runtime is built with a combination of the simplest and most efficient way to delivery Reactive applications, microservices, and whole systems. That foundation is the Actor Model.
In 1973, Dr. Carl Hewitt and his colleagues formulated the Actor Model. In recent years, the inventor of object orientation, Alan Kay, has stated that the Actor Model retained more of what he thought were the important object ideas. So, when you think of the Actor Model, think of objects done right.
A Resource actor sending a command message to a Model Entity actor.
The XOOM Actors toolkit is an implementation of the Actor Model. The ideas behind the Actor Model are powerful, and the XOOM Actors toolkit elegantly implements the concepts behind it with simplicity. Components created with XOOM Actors are type safe by design. Services use Actors by defining and implementing domain-specific interfaces, known as protocols. This box shows how actors work and what they do.
How actors work and what they do
An actor receives messages in its mailbox, and processes one message at a time when a thread is available.
Fundamentally, actors are non-blocking and share none of their mutable state with the outside, not even with other actors.
Actors use available threads, and you can’t run more threads simultaneously than there are available cores, e.g. Runtime.getRuntime().availableProcessors()
The basic unit of computation is expressed through actors. Actors send and receive messages asynchronously.
As objects create other objects, actors can create other actors.
Each actor can designate the behavior it will exhibit for the next message it receives. With XOOM Actors this can be accomplished by actors implementing multiple type-safe domain-specific interfaces.
As objects are typically used, software developers have become accustomed, even addicted, to the blocking paradigm. In the blocking diagram a Client object invokes a method on a Server object. This is an in-process (in-VM) invocation, not a remote client and a remote server. The point is, when a method invocation occurs, the Client is blocked until the Server returns from the method invocation. This means that the Client can perform no additional operations while the Server is handling its request.
A Client object invoking a method on a Server object, which blocks the Client.
In contrast, the Actor Model works differently, as is shown in the message-driven diagram. When the Sender actor wants another actor to provide a service, it sends that actor a message. The message is sent to the Receiver actor and handled asynchronously when a thread is available. The Sender is not blocked, but continues moving forward with its current activities, and when those complete, it returns from its own message handling. As a result the thread previously used by the Sender is now available for another actor. This achieves maximum efficiency across all actors in your service instance. The more cores that are available, the greater the overall throughput and the greater the efficiency.
The Actor Model is message-driven and processes messages asynchronously.
With XOOM Actors, type-safe messages are the fundamental building block. For those that depend on static typing, a strongly-typed Actor Model implementation is crucial to reassure developers that they are sending the correct and intended message to each actor. This is guaranteed by the compiler, and adds no overhead beyond a typeless implementation.
There is far too much complexity in the software industry. The overarching vision for the VLINGO XOOM platform puts extreme emphasis on simplicity and rapid development. In a few moments you can download the platform components through your build definition, with the whole platform fully conﬁgured for common use cases. You can be productive within minutes, rather than the typical untold number of weeks or months. Try it!
The XOOM Actors toolkit is the bedrock on which our other platform tools are implemented. You don't necessarily have to use actors directly, but you still have all the advantages of the Reactive runtime.
More...
To read more introductory explanations about our platform, see Quick Reference, a brief guide to the components that comprise the VLINGO XOOM platform. Otherwise, jump to Getting Started.
Introduction
Quick Reference
Last modified 1yr ago
Copy link
Outline
Laser Focus on Business Value
Rapid and Bug-Free Delivery
Minimal Source in Clean and Robust Architecture
Platform Benefits
Simplistic Power—Actor Model Foundation
More...