Condense Technical Overview

Condense In Brief

Condense is a reliable event driven architecture implementation, leveraging a durable persistence store, with flexible integration options.

You provide an in-code description of your business data model and process in a regular .Net assembly project, referred to as your business domain. This domain assembly can then be hosted by a Runtime which fulfills the promises of the framework. This could be the in-process Condense Light framework, the SaaS Condense Cloud offering, or a private cluster.

Condense provides your application three key capabilities to in relation to your business domain. These are:

Storage and retrieval of your data,

Executing code in response to new or changed data,

Hiding complexity of underlying processes behind interfaces.

Additionally, the Condense framework records how each entity was created, the specific code that was run, and which entities were used as inputs to the process. This provides a strict causality tree (in conjunction with revisioning), which provides complete traceability for every piece of business data, and replayability for every part of your business process. It also provides significant benefits when it comes to selection of related data.

Condense also provides many other features such as data retention policies, and even multiple simultaneous code versions.

Condense aims to be a zero-boilerplate framework. For a simple business application there will be very little configuration - we only require you to positively identify your data classes and methods that should be executed in response to your changing data.

Data

Your business data should be declared as a plain C#¹ object, referred to as a business entity. This entire object is serialized and stored as a document - it may contain complex properties such as lists and dictionaries. These documents are able to be queried and retrieved as expected, contain references to other documents, and have their changes tracked. You identify these classes by adding the [Entity] attribute.

In addition to typical queries, you are also able to easily consider the causality of your entities, eg: selecting Purchase Orders which have not caused a Shipment.

Additional reading: Entities, Context, and the IUnitOfWork. This document will also describe the important concept of context in detail.

Execution

To have the runtime execute code in response to the arrival of new or changed data, you must declare a method with an entity parameter and decorate it with the [Lambda] attribute. These methods are referred to as lambda methods. They may take in additional entity parameters, which are filled according to various default rules, which you can change using attributes. If this method returns an entity or an enumerable, the resulting entities will be stored and may trigger additional lambdas to be executed. Execution may be reliably deferred in times ranging from minutes to months, as delayed actions, or to timeout waiting for parameters.

A lambda method runs asynchronously in an isolated transaction. When triggered it is guaranteed to execute and complete, on failure it will rollback and be retried. In a hosted cluster, your business process will become fault-tolerant, based on proven technology from Couchbase and AWS.

Additional reading: Lambda Execution. This document will detail how the context mentioned above is leveraged in selection of multiple parameters.

Integration

An entire business process may take weeks to complete, yet a given perspective may only be interested in a small subset. Applications that interact with a business domain may wish to simply create new facts for the domain to process, or to subscribe to specific events of new data arriving. Condense supports these situations.

In addition, a client application may provide an interface that describes how it wishes to view it’s interaction with the domain.

Condense will dynamically implement an appropriate method to fulfil the contract specified by the interface - for example a method which takes a Client and a LoanApplication and returns a LendingDecision. There does not need to be any direct link between these business entities. The runtime will store and publish the new data, subscribe and await the appropriate result. The application is isolated from the domain. The result the application is waiting on may not be the end of this business process; in fact the input parameters to this method could be the continuation of an existing process.

Nevertheless, code that is using the integration point is isolated from domain internals, not just in terms of reliability, but in relation to process changes as the business evolves. As long as the return type is still expected to be produced in a reasonable time frame, this client code will be unaffected.

Your interface definitions are plain C# interfaces. An implementation is provided to you by the Runtime in-process, or provided as a web endpoint for cluster based hosts.

Additional reading: Integration. This document will detail integration interfaces, and how to flow external causality and context into the Runtime.

Pricing — preliminary guide

A domain assembly built for the Condense Framework will run on any runtime, and will scale with it, without modification.