COHORTE in Nutshell

Service-Oriented Component-based Applications

All system processes are placed into separate components which communicate with each other via services.

Multi-Language Programming

COHORTE provides native support for dynamic Java and Python components and allows integrating .Net code using IronPython component facade. Other legacy code could be integrated using wrappers.

Components Distribution via Remote Services

Software Components are seen as black boxes and can be placed anywhere on the COHORTE distributed platform.

Heterogeneous environments

COHORTE supports multiple deployment environments in local area networks or across Internet. It uses an universla messaging framework to integrate the different parts.


Dynamic Isolation & resilience

COHORTE applications are able to recover and repair themselves automatically for seamless business continuity.

Development & Monitoring Tools

COHORTE developers can use their prefered IDE. We provide information about how to integrate COHORTE in their development process.

Learn More 

News

Application Domains

IoT

Internet of Things

COHORTE Helps create network of connected physical objects by encapsulating them within high-level software services which represents sensors, activators, controllers, software systems, etc.
Project planning

Data Collection Systems

COHORTE helps the creation of distributed flexible Data Collection Systems for different applications like :

  • Remote Monitoring
  • Financial / Retail
  • Energy
  • Transportation
  • Healthcare
Project planning

Continuous Delivery

COHORTE helps automate and improve the proccess of software delivery by providing a mechanism for self-deployment and self-instantiation of components. This ensures short-time deployment and maintenance periods and by then reduce related costs.


Using COHORTE

  1. Architect
  2. Implement
  3. Plan
  4. Prepare
  5. Run

Architect your application

  • Your application is designed following the Service-Oriented architecture approach.
  • You "specify" components providing and consuming services.
  • No information about the deployment constraints are given at this step (seperation of preoccupations).


Implement your components

  • Using Java (OSGi/iPOJO) - Python (Pelix/iPOPO) - C#, C/C++ (Pelix/iPOPO wrappers)
  • Write only your Componnets' business logic, not technical code for remote communications and life cycle management
  • Dependencies between components (even located on different machines) are injected at runtime
  • Package your components and their libraries on bundles


Deployment plan

  • Create/Update deployment and composition configuration file
  • You can specify that any Node with a given "name" should have an instance of a one particular component
  • You can have multiples isolates in the same node to seperate between components

Prepare your deployment environment

  • Create COHORTE Nodes on devices that will host your components
  • Each Node has a name. Several devices can have the same name if they have the same role in your application
  • Put your components bundles on the repo directory


Run your application

  • Choose communication transport (HTTP/XMPP)
  • Choose a Node to be Top Composer
  • Start the Nodes
  • Monitor your application
  • Application isolates are created automatically, and whenever a component fails it will be be placed on different isolate
  • Other nodes can be added dynamically. If it's name is referenced on the composition configuration, the Top Composer will order it to instanciate the related components.

Cohorte Technologies logo


Copyright © 2011-2016 Cohorte Technologies SAS
3 chemin du vieux chêne. 38240 Meylan, France

Cohorte Technologies is the principal sponsor of COHORTE footer logo