Abstract Solutions – The Matrix modelling language provides an extremely high level of abstraction. Language semantics deal with modeling concepts not programming concepts. It is not a mere programming language.
Future Proof Applications - When a new language, database or software architecture must be adopted, update the Model Compiler, never the model.
Localise Application Change - When new business rules must be implemented, update the Matrix model, never the Model Compiler.
Theory Based - Based on the relational theory of data and communicating state machines. Supported by the Analysis Design Matrix Diagram and associated method.
Complexity Simplified - Very scalable, especially designed for large and complex concurrent systems.
Translational Code Generation - Model Compiler employs Translation not Transformation and has the single aim of producing source code and other supporting files as necessary.
Implementation Free Language - Matrix only has statements that capture the subject matter under analysis. Unlike a programming language, Matrix is free from any statement capable of specifying or constructing an implementation for a model.
Exposed Design Model - The application's Software Architecture design is made explicit by the Model Compiler.
Representation - Complies with the Single Point of Truth Rule. Every piece of knowledge has a single representation.
Non Redundant - No data is ever replicated as all navigated data is available immediately and is updated instantly (conceptually) by other processes.
Concise - Model Compiler refuses to accept any superfluous information that may exist in language statements.
Consistent - Rigorous language definition enables advanced model checking.
Organised - Language statements are structured in a highly consistent way. They are arranged as an indented, unordered, hierarchical list following relational principles.
Orthogonal - Primitive statements never overlap in functionality.
Pattern Language - Pattern statements enable intentional specification, increased checking and higher performance source code.
Pattern for Growth - As new patterns are discovered they are incorporated into the next generation of Model Compilers and become part of the Matrix language.
Relational - Defines and traverses unary relationships to access objects under the Closed World Assumption (what is not known is false).
Object Linking - Objects are explicitly linked together (while still obeying relational rules) unlike the true relational model that depends on implicit links based on attribute fields that happen to have a common value.
No NULL Values - Attributes never have NULL values since all access to attributes is governed by state machines. Referential attributes don’t exist in Matrix.
Contextual - Does not require the use of identifiers or handles, but depends on the current context. For the most part, only one object per entity is in context at any one point.
No Global Data - Selected target entity object data must be accessed through a defined relationship from the current object context.
Fully Textual - Although a graphical notation is required to properly visualise a model, a fully textual language provides a number of key advantages. Textual languages are more concise than graphical languages and it’s easier to perform refactoring, merging, differencing and searching using common tools. Configuration management is also more straightforward.
No Magic - Except for predefined zero and one, no magic numbers or constants are permitted in action statements.
Initialisation - Implemented not in the code but specified in data as Real World objects, relationships and events. Effectively captures a dynamic snapshot of the Real World at start-up.
Strict Layout - Coding style and rigid format rigorously enforced by the Model Compiler leaving little scope for customisation so all models everywhere look the same and parts of the model are easily located.
Pathfinding - Due to the way statements work together, Matrix exhibits the unusual property for a modeling language of subtly guiding the analysis to a better solution.
Transformable - Language easily transformed into an equivalent graphical language down to statement level.
Highly Parallel - Can fully specify a single model that can be implemented as a sequential or concurrent system. Communicating state machines are inherently parallel plus the execution of state actions can also be modelled as parallel.
Lock-Free Computation Model - Matrix models don't have the concept of resource locking. Instead, read and write access to entity attribute data is governed by the analyst through the event mechanism.
Architecture Duality - The Model Compiler's analysis model is the application’s design.
Software Architecture - The application's architecture is also written in the Matrix language thereby it giving the same flexibility as when designing applications.
Method Based - Firmly and proudly based on the graphical OOA/RD Shlaer-Mellor Method from the last century!