Improvements to software development

• The software of the future needs to be situation adaptable => Enable real-time changes through process libraries and agile development.   
• General lack of the comprehensive picture => Focus on processes - not data.
• Gap between users and developers => Force users and developers to use the same framework.
• Under-utilization of existing knowledge => Exalt hidden "if...then...else" rules.
• Productivity and quality issues => Align development method and multi-dimensional high level language.
• Islands of automation => Developing true automation is impossible without a process view and process tools.

Improvements to software products

• High costs for changes in time and money => A process engine enables dynamic high level programming.  
• Under-utilization of measurements => A process engine enables automatic tracking and measurement.
• Lacking all forms of intelligence => A rule engine enables inference capability.
• Lacking support for compliance => Get it right every time by having compliance rules where they matter.
• Lacking support for collaboration => A wiki is both an easy-to-use and advanced collaboration platform.
• Lacking support for advanced real-time behavior => Real-time customization by analyzing live data instead of reading static data.

The general picture

Edit mode

Monitor mode

Processes

A process can be defined in Exalt script language by text or by BPMN (Business Process Modeling Notation) drawing.

A text example of a high level project plan could look something like the example below:

! 1 Project X
! 1:1 {workflow} Milestone 1
! 1:1:1 {workflow} Activity 1
! 1:1:1:1 {workflow} Task 1
! 1:1:1:2 {workflow} Task 2
! 1:1:2 {workflow} Activity 2
! 1:2 {workflow} Milestone 2
! 1:3 {workflow} Milestone X(n)

Implior Exalt Process & Knowledge is based on a patent pending theoretical integration between logic calculus and process calculus. Rules are used to determine branches (one or more) and within process elements.

Rules

Assume the following facts:

• link(a,b)
• link(b,c)
• reachable(a)

Making the conclusion that there is a path from a to c can be done by forward chaining or backward chaining.

Forward chaining:

• reachable(From) and link(From,To) => reachable(To);
• Adding conclusion: reachable(c)

Backward chaining:

• trip(From,From,Path) --> Path(From):
• trip(From,To,Path) --> link(From,X) and trip(X,To,Y) and Path=[From|Y];
• answer(Path):=trip(a,c,Path)
• Path=[a,b,c]

A human being immediately makes the conclusion that there is a path from a to c but even such a simple conclusion is impossible for almost all existing software products of today. Just a few lines in a rule engine can change this.

Multi-dimensional programming

What Implior is exploring is some kind of multi-dimensional programming.

• Processes in one computing space.
• Rules in one computing space.
• Security in one computing space.
• Resources in one computing space.
• Application code in one computing space.

This multi-dimensional programming is combined with our own form of agile software development.

An elegant theoretical integration between logic calculus and process calculus (i.e. predicate calculus and generalized automata theory).