Model Driven Development
Cogility’s model driven, visual approach allows the solution to be expressed closer to the problem domain. Whereas code based solutions do nothing more than mechanical syntax checks at design time, Cogility’s holistic model additionally allows more meaningful semantic checks to be performed at design time. This increases confidence in the solution and reduces the testing cycle. Domain analysts are able to participate more directly in the development process and the development teams are smaller. The traditional barriers between domain analysts and coders are removed. Solutions are easier to create but more importantly, easier to evolve and maintain over time.
Integration Infrastructure
A suite of integration features such as automatic database persistence, web service and messaging connectivity, XML document handling, and background task management are built into the system and exposed at the modeling layer so low level coding is not required.
Composite Application
Cogility’s long running visually modeled processes are not used just to create automatic processes by stringing a series of web services together. They are used to create arbitrary combinations of automated and human assisted processes. The domain specific application that is being supported by these processes is itself in the model creating a seamless composite application that is easy to extend.
Rapid Prototyping
The combination of model driven development along with the fact that the entire application (the domain specific logic as well as the integration aspects) lives in the same model, allows for rapid prototyping.
Parallel Execution
The Cogility approach leverages con currency in processes and can utilize multiple processors or multiple servers to execute the con currency modeled into the system. Con currency is addressed using transactional programming, proven over the last 30 years, rather than difficult to use low-level techniques like threads, locks, and semaphores required by code based solutions to utilize multi-core systems.
Development Methodology
An iterative development process is a natural complement to the rapid model driven prototyping approach. Thin, end-to-end solutions are quickly created to allow the end user, early visibility into the system. This allows the system to be modified and corrected early on and reduces later more costly rewrites. Cogility typically delivers a project or the first phase of a longer project within 2-4 months of the project start.
Operates on Standards Based Infrastructure
Rather than creating esoteric systems, Cogility’s innovative model driven approach is layered on top of existing technologies, thereby reducing personnel training time and risk of maintaining the running system. Cogility’s dependencies are limited to Java, J2EE compliant application servers and JDBC compliant relational databases.
Adaptability
Cogility’s built-in artifacts provide a powerful set of capabilities that can be adapted to a wide range of problem types. This flexibility, coupled with the model driven approach, allows domain specific solutions to be created quickly. Cogility has created solutions for the finance, telecommunication and health industries. More recently, the same techniques have been applied to defense industry problems like Time Sensitive Effect Operations and Counter IED projects.
Rapid Deployment
Once the design time modeling activities are completed, the model can be deployed to the execution platform with a single button push. Re-push of modified models can take as little as 15 seconds and typically takes no more than 30 to 60 seconds, depending on the number of changes. Cogility has developed processes to allow hot deployment of models, eliminating the need to stop the running application while a new version of the application is being deployed.
Runtime Scalability
Cogility applications run inside J2EE application servers but they are meta-data based, instead of code based. This allows the application server to be a simple caching, computing device and all the data and application state changes are preserved in the database. A theoretically unlimited number of app-servers can be pooled together to increase processing throughput without requiring special design on the modelers’ part. The other part of the running applications is standard relational databases. These can also be maintained and scaled using traditional techniques.
