We work with large organizations who want to reduce the cost of software development and deliver new features rapidly while ensuring safety and reliability.

Their computing platforms can be highly specialized with unique interfaces and multiple processors. The platform design typically evolves and eventually results in varied configurations to support different levels of features and spin-off products.

But even if the hardware is fixed, frameworks, network protocols, data storage formats, and other relevant software technologies are ever changing.

So it makes sense to separate the application logic, our client's valuable intellectual property, from the implementation details as much as possible.

That's why our clients preserve their application logic in platform independent models. These models are built, debugged, tested, documented and maintained separately from the platform. During implementation, the models are combined with markup files that map model elements to particular design patterns and platform specific implementation features.

Why do our clients build models?


Development can proceed at top speed without having to wait for details of the platform design to be settled. In fact, separating out other concerns, such as the user interface technology, makes things go even faster.


Models that exclude platform specific features can be focused exclusively on the application logic. So you have a clearer picture of the essential requirements and can evaluate, communicate and validate them without distraction. And this also contributes to rapid development.


When, not if, the platform changes, only the markup files need to be updated. Our clients change the models only when the application itself changes. So small changes to the platform don't require reworking the models.


And this means that our clients can freely experiment with platform design alternatives without having to worry about breaking the application logic. So they deliver superior applications on superior platforms.


The same models can be redeployed to multiple platform variations without having to change the models. Only the markup files change.


Once our client's application logic is modeled, it can be deployed on multiple platforms. This means that the same rules and constraints are deployed on each platform.


Concurrency is increasingly important. Most development languages introduce arbitrary sequencing. So when added concurrency becomes available on the platform, it is not obvious how to leverage it without tearing apart the application logic. Executable UML captures your application logic without embedding any unnecessary sequencing. So the models can be easily mapped to a wide variety of concurrency schemes without ever having to change the models themselves.