JCSE Architecture Forum - September 2013 - The Cohesion Framework

Cohesion is a Java based framework for the implementation of event driven systems. For example, it is currently used within the telecommunications industry as the basis for a distributed sensor network, and is being used to simulate and develop new VOIP services.

The design principles guiding the architecture of the framework are to address the impedance mismatch between network communication, in-memory communication and persistence while providing resilience and high performance. As such, the framework cleanly abstracts out the transport layer, so that in-memory communication versus network communication is transparent to application developers. Persistence is supported by similarly abstracting out the notion of message representation, allowing object storage versus in-memory state manipulation to be transparent to application developers.

These abstractions are achieved by providing 'entities' as the basic building blocks of systems. Entities are event driven objects providing a context in which serial execution is enforced. Dispatch to the logic handling events is via structural typing. This is essentially partway between the typical nominal typing, used in RPC style frameworks to invoke named methods or types, versus full content addressed mechanisms. This approach provides loose coupling, and an expressive means of describing entities.

With these basic principles, the Cohesion framework allows application developers who are building distributed systems, to take a "simulation first" approach to development. That is, users of the framework can focus on the logic of their specific systems, by first building a large scale event driven simulation of the complete system. Such systems will involve large numbers of entities, interacting via events, that may be marshaled into in-memory storage. Once the application specific logic is proven to be sound, the framework ensures that it is simple to distribute this across multiple nodes on the network, without code changes to the core logic. In-memory event passing is cleanly substituted with a high performance TCP based binary protocol. Furthermore, state can then be marshaled into persistent storage in a file system. For UI interaction, events can similarly be marshaled into JSON representations and consumed by HTML/JavaScript based web applications.

Depending on the underlying hardware and the work load, the framework can handle 1000000 in-memory messages per second, and 10000 TCP messages (on localhost) per second. The framework can support millions of concurrent entities (restricted by heap size).

Stewart Gebbie received an MSc in pure Mathematics from Wits University and has combined the rigorous analytical method and abstract thinking of this field with the field software development. This approach to development has led to a preference for producing business-relevant, quality software with an emphasis on testable systems and clean architectures.

Stewart has worked in the software development and architecture field for over 15 years, and has been running his company, Gethos Systems, since 1999.  Stewart's current interests are high concurrency distributed systems and decentralised event driven systems.

Stewart Gebbie, MSc, will introduce his Cohesion Framework: a Java based framework for the implementation of event driven systems. For example, it is currently used within the tele- communications industry as the basis for a distributed sensor network, and is being used to simulate and develop new VOIP services.

Location: 
Cost: 
Free
Venue: 
Tshimologong Precinct
Date: 
Monday, September 16, 2013 - 18:30 to 20:30