Rational Modeling Language

This language is an abstraction and a free modeling of Computer programming language under license GNU General Public License, being based on the Graph theory and the Théorie of the groups. It also uses the work completed by the consortium OMG which has just published UML2. This model uses the concept of recursivity abundantly.

This language, unlike UML, is based on the graph theory and the relation between each représention. It has a teaching and mathematical vocation. This definite language a complete system by its representations. It initially defines the generating family and the free variables of the system. The free variables of the system are time, the structure, the states, the predicates. To define a representation it is necessary to combine at least two dimensions (variable free) of the system: classify, object, predicate, time, state, etc

Sights

Three-dimensional sight

To define a three-dimensional representation, it is necessary to select 3 free variables of the system.

Example a sight made up of the free variables: time, predicate and class.

Matricelle sight

To define a matric representation, it is necessary to combine two dimensions of the system. To have an overall picture of the system it is necessary to cross all the possible combinations of these dimensions.

The system must be seen as a matric system which can be seen only by " vues" , i.e. the observable ones on this system. It can be interesting to establish the link with the observable ones in quantum mechanics.

The first definite group is that of the objects. It enumerates the objects which the system comprises.

The second definite group the space of the predicates. It enumerates the prédictas system. In data processing a grouping of predicates is called interface.

Concurrent management is determined by the free variable " temps" and a projection requires.

Layers of abstraction (layers abstraction)

Why layers of abstraction? Because it is impossible to define a system by enumeration. All the functionalities (predicate or object) of the system do not have the same values and do not have the objectives. Should be made an abstract sorting. Losrque the system is defined, it positions in a specific environment. The actors of the system are positioned in the layer NR of the model. The layer NR definite all actors, objects and interactions which it can handle by this level of abstraction.

Foot-note: This concept of layer can be related with the concept of " domain" in Achievable UML, but without recursive dimension.

Nota2: a predicate is seen like a " use case" in UML.

Definition: A predicate can be public or private. A private predicate is seen only by the object which handles it. A public predicate is seen actors of the layer of abstraction which defines it. A predicate can call upon another predicate of another layer of absraction. The passage of a layer of abstraction NR in another N-1 is seen like a paradigm.

Each layer with its own ontology and all art resides in the connection of the layers between them.

For example if a management software should be modelled commercial, predicates should be defined directed trade (business activity). In this type of system, a database governs the transactions and the information storage. The commercial software uses a database but is not there to define what is a database, càd to model it.

It is concept of use is very important because it leads to the concept of interface. This Interface is proposed by another layer (N-1 for example).

If a database should be modelled, it is necessary to define the directed predicates database. It defines how information is stored logically and not physically. Here the software will use the operating system for the physical storage of the data. It is possible to go more in-depth to see than the manufacturers of operating system model the predicates specific to OS and bases themselves on the possibilities of the microprocessors. The microprocessor manufacturers base themselves on the physical and mechanical possilities. The physicists study the siciles, etc

Even if in this example the decomposition of the system is simplistic, it has the merit to objectively present the need for layers of abstraction. The perimeter of a layer of abstraction at present cannot be calculated (with the direction calculability and mathématiqque proof).

Groups

RML rests on 4 groups:

the group of the classes
the group of the objects
the group of the predicates
the group of the methods

Group classes

This group identifies each element like a class. This group is finished.

Group objects

This group identifies each element like an object. This group is infinite. Each object is an authority of a class.

Group predicates

This group identifies each element like a predicate. This group is finished. A predicate gathers the concepts UML of case of use and operation. A case of use is a predicate. An operation is a predicate.

Group methods

This group identifies each element like a method. This group is infinite. Each object is an authority of a predicate.

Range of the names

The name of the predicates and the classes is related to the layer of abstraction. The RML does not have ambiguous grammar. In Java as in UML for the classes, ambiguity is raised thanks to the concept of package (or parcelling). Each package with its own whole of name. The names of the classes are prefixed by the name of package.

For the layers of abstraction it is necessary well

For the predicates in language directed object the space of the names is defined by the class to which the predicate relates. A predicate cannot exist alone whereas a class yes: Classe1 C; // exists

Classe2.prédicat1 (); // exists

prédicat1 (); // does not exist

For stage impossibility of creating a predicate alone one passes by an interface, which is a class containing only predicates.

A name out of its context can have several directions.

Example: a predicate in two layers of abstraction

predicat1: definition 1 (in layer 1)

prédicat1 generates 2 methods méthode1 (directed processing time) and méthode2 (directed allocated space).

méthode1 and méthode2 are equivalent.

predicat1: definition 2 (in layer 2)

prédicat1 generates 2 methods méthode3 (directed processing time) and méthode4 (directed allocated space).

méthode3 and méthode4 are equivalent.

méthode1 and méthode3 are not equivalent.

méthode2 and méthode4 are not equivalent.

Graphs

The graphs rest partly on the concepts of UML. It is not a copy of the diagrams of UML but a rebuilding, brick by bricks in a rational way (from where the term Rational) the dependences between arc and top.

It is necessary to take, has minimum, two free variables to constitute a graph. Ordered reprensentant the tops and the X-coordinate arcs. For example following graphs:

a graph G1 (state, time)

Sat ---10 seconds---> Upright ---20 seconds---> Sitted

a graph G2 (state, predicate)

Sat ---seLever ()---> Upright ---to sassoir ()---> Sitted

a graph G3 (predicate, time)

seLever () ---10 seconds---> to sassoir () ---20 seconds---> seLever ()

a graph G4 (object, time)

Man ---10 seconds---> Woman ---20 seconds---> Man

a graph G5 (class, predicate)

Hat ---tranformer ()---> Straw hat ---tranformer ()---> Cap

One of the points to be approached is the duality of the graphs, as one can see it in the foregoing table,

For example following graphs:

a graph G1 (state, time)

Sat ---10 seconds---> Upright ---20 seconds---> Sitted

G1' (time, state)

10 seconds ---Sat---> 20 seconds ---Upright--->.

Recursivity

Concept of recursivity appears in the fact that a graph is made up:

- of a whole of arcs

- of a whole of tops

A top is either a free variable or a graph. An arc is either a free variable or a graph.

For the predicates:

For example the graph G1 " to open the porte" is in the following way made up: (the states and the arcs are not inevitably named)

--- to seek key -->. --- to insert key in the lock --->. --- to turn key --->

G2 " to return to soi"

--- to take subway ---->. --- to arrive house --->. --- to open door --->. --- to enter house --->

For the classes:

dog ---estun () ---> animal

Labrador --estun () --> dog

Iterations of the system

A system is " vivant" in the direction where a computer program evolves/moves unceasingly. The system by first iteration S (1) and is reiterated until nth iteration S (N). That is to say I (I) the operator (with the mathematical direction) who makes pass from S (I) to S (i+1), one obtains:

$S (i+1) = I (I) X S (I)$

Version v of the system corresponds to the nth iteration for which the system is judged to correspond to the specifications defines. $V (v) = S (N)$

Several types of version exist:

version of development and integration: where for each iteration I (I), the number of classes and predicates evolves/moves quickly.
version of receipt (or Release Candidate in English): where for each iteration I (I), the number of classes and predicates does not evolve/move. The versions remain with Iso-functionality. Each Iteration corrects the defects of the system noted.
stable version: this version is the last iteration of receipt where the system is considered to be stable and the defects major and blocking were corrected.

Category: computer programming language

Random links: