Dynamic Model

1. Introduction

The dynamic model programming method is based on cognition. It believes that a thing can exist first, and we can recognize and use it through object-oriented methods.

Before knowing a thing, it can be called a thing. Since a thing can be in motion, the dynamic model believes that anything can be transformed into action. The concept of dynamic model starts from things and actions.

Here, the concept of "thing" is basically the same as "dongxi", but "thing" is used when we don't know what it is or don't need to know what it is.

2. Basic concepts

Model (Thing)
Models are structured data, and models can be used to represent various things, sometimes called models things. The structured data here refers to tree-structured data, such as XML and JSON.
Action
The dynamic model believes that any model can be transformed into an action, and the action is equivalent to the function and method in programming, and the action can be executed. Dynamic models assume that any model can be transformed into an action.
ActionContext
Sometimes also called variable context. Used to store variables and maintain execution state during action execution.
World
The container for the model. Generally, the model is obtained through World. Concepts correspond to things, and the container containing various things is called the world.

3. Object-oriented

The two concepts of things and actions are abstract. To be able to program, you need to use these two concepts to implement object-oriented programming methods.

3.1. Object

We need to use the model to represent the object, the following is the method to use the model to represent the object.

<Person name="zhangsan" age="40">
     <actions>
         <GroovyAction name="helloWorld" code="println &quote;hello world&quote"/>
     </actions>
</Person>

If the above XML is a model, it can be used as an object:

Properties of an object
Nodes in XML can have their own attributes and child nodes, which can be regarded as attributes of objects.
Object Behavior
In the dynamic model, each node in XML is regarded as an independent model, and the dynamic model stipulates that any model can be converted into actions for execution, so some sub-nodes of a model can be artificially specified as object behaviors.
For example, in the above XML, the sub-nodes under the actions sub-node are specified as the behavior of the object, then the object whose name is zhangsan has a behavior named helloWorld.

3.2. Type of object

A descriptor in a dynamic model is equivalent to a class in an object-oriented model.

In a dynamic model, a model can use any model as its descriptor, and the model inherits the behavior of the describer.

For example, the description of the <Person name="zhangsan.../> model below is the <thing name="Person".../> model

<?xml version='1.0' encoding='utf-8'?>

<Person name="Zhangsan" descriptors="xworker.doc.dyanmicmodel.examples.Person" age="40"
      sex="0">
     <Child name="Xiaoming" age="10" sex="0"/>
     <Child name="Lili" age="5" sex="1"/>
</Person>

<?xml version='1.0' encoding='utf-8'?>

<thing name="Person" descriptors="xworker.lang.MetaDescriptor3">
     <actions>
         <GroovyAction name="sayHello" descriptors="xworker.groovy.GroovyAction" code="println self.name + &quot; say hello world&quot;;"/>
     </actions>
     <attribute name="name"/>
     <attribute name="age"/>
     <attribute name="sex" inputtype="select">
         <value name="male" value="0"/>
         <value name="female" value="1"/>
     </attribute>
     <attribute name="description" inputtype="html"/>
     <thing name="Child" extends="xworker.doc.dyanmicmodel.examples.Person"/>
</thing>

In the above example, the describer of zhagnsan is Person. Person can be used to describe the behavior, attributes and child nodes of zhangsan.

Behavior
Person defines the sayHello behavior and Zhang San also inherits this behavior.
Attributes
The <attribute nam="xxx".../> child node of Person can be used to indicate which attributes zhangsan has.
Child nodes
The <thing name="xxx" .../> child node of Person can be used to indicate which child nodes zhagnsan has.

3.3. Inheritance

In a dynamic model, a model can inherit any other model except itself, thereby inheriting the behavior of the inherited model. If the model is used as a describer, it also inherits the description of attributes and child nodes.

Inheritance is useful for complex models and frameworks. For example, in the following model, the Child child node inherits the root node Person, so Child is also Person, and it also has the behaviors, attributes and child nodes described by Person.

<?xml version='1.0' encoding='utf-8'?>

<thing name="Person" descriptors="xworker.lang.MetaDescriptor3">
     <actions>
         <GroovyAction name="sayHello" descriptors="xworker.groovy.GroovyAction" code="println self.name + &quot; say hello world&quot;;"/>
     </actions>
     <attribute name="name"/>
     <attribute name="age"/>
     <attribute name="sex" inputtype="select">
         <value name="male" value="0"/>
         <value name="female" value="1"/>
     </attribute>
     <attribute name="description" inputtype="html"/>
     <thing name="Child" extends="xworker.doc.dyanmicmodel.examples.Person"/>
</thing>

The extends attribute in the above XML code is used to indicate inheritance, such as: extends="xworker.doc.dyanmicmodel.examples.Person".

4. Interpretation and execution of models

4.1. Interpretation of models

What a model is can be explained using an object-oriented approach. That is, a model can be regarded as an object and explained using the class of the object. For example, what is this thing? It is a stool with four legs and a flat surface, which can be used to sit.

It should be noted that in a dynamic model, an object can be created first and then its class can be specified, and the class of the object can be changed at any time, or it can be used as its class.

In general, what a model is is determined by the user, and the structure, attributes and type of a model can also be changed at any time.

4.2. Model execution

As a programming method, the model must be executable, and the execution of the model can be seen as running a certain behavior of the model. Since the dynamic model is abstract, it needs to rely on other programming languages to be implemented. For example, the dynamic model engine X-Meta is implemented using Java.

The dynamic model is an object-oriented programming method. The model can be regarded as an object. Running a model can be seen as executing the behavior of an object.

In the dynamic model, the behavior of the model is also a model. To execute this behavior of the model, it needs to be converted into an action for execution.
When the model is converted into an action for execution, the behavior of the model named run is executed. To execute the behavior of the model named run, go back to step 1.
The above is an iterative process. To terminate the iteration, some models need to be executed directly by the engine instead of continuing to recursively execute the behavior named run.

For example, the dynamic model engine of XWorker is implemented using Java, and the model with the class name JavaAction is directly executed by the engine. The function of JavaAction is to execute a Java method or compile and execute the code given in the model.

5. Metamodel

The metamodel is a data structure accidentally discovered in programming. It can solve the problem of model editing and also has a little philosophical meaning.

5.1. The principle of editing models

In XWorker, the model can be edited through the model editor, the principle is as follows.

In object-oriented, objects can be instantiated through classes. In the model editor, classes are used to dynamically generate an edit form, and users can edit a model through the form.
Take the class as an object, and you can edit it in the model editor through its (as an object) class.

The above is an iterative process. To terminate the iteration, an object is needed, which is its own class. It can edit itself or any other class by itself. This object is the metamodel.

5.2. Metamodel discovery process

In the dynamic model, objects are represented by tree-structured data. For example, XML can be used to represent an object, so an object can be represented as XML.

When using XML to represent an object, we define the structure of the object in the following way.

Use <thing name="xxx"/> to represent an XML node.
Use <attribute name="xxx"/> to represent an attribute in an XML node.

For example, the following XML.

<Person name="Zhangsan" age="40">
     <Child name="Xiaoming" age="10"/>
</Person>

The structure of this XML is as follows.

<thing name="Person">
     <attribute name="name"/>
     <attribute name="age"/>
     <thing name="Child">
         <attribute name="name"/>
         <attribute name="age"/>
     </thing>
</thing>

Through the above definition of XML structure, then we can calculate any XML structure, we can find that the calculated result is still XML, and then we can iterate the calculation, and finally find that it can be iterated to an XML, this The XML is as follows.

<thing name="thing"">
     <attribute name="name"/>
     <thing name="attribute">
         <attribute name="name"/>
     </thing>
     <thing name="thing">
         <attribute name="name/>
         <thing name="attribute">
             <attribute name="name"/>
         </thing>
         <thing name="thing">
         ....
         </thing>
     </thing>
</thing>

This is an XML with the same nodes at each layer and infinite layers.

Since this XML has infinite layers, it cannot be expressed directly. In order to be able to express it, we introduce the concept of inheritance, so that it can be simplified into the following XML.

<thing name="thing"">
     <attribute name="name"/>
     <attribute name="extends"/>
     <thing name="attribute">
         <attribute name="name"/>
     </thing>
     <thing name="thing" extends="_root"/>
</thing>

Here we add an extends attribute, in <thing name="thing" extends="_root"/> child node, extends="_root" attribute indicates this node Inherit the root node, so that this child node also has child nodes under the root node, so logically it is an XML with infinite layers.

Because it is a structure of any XML structure, in an XML editor that uses the structure of XML to edit XML, it can be used to directly or indirectly edit any other XML, so it can As the first model in the system, the metamodel.

Development Platform
1.Create Project
2.Create Category
3.Create, edit and run a model
4.Publish an application
4.1.Example: Run the model directly
4.2.Example: Export to Executable Jar
4.3. Example: Export WAR
4.4. Example: Export executable WAR
4.5. Example: Export native applications
5.Toturials, Documents & Examples
Advanced
1. Define a new model
2.Framework
Example 1: HTML
Example 2: SWT
3.Model Library
4. Dynamic Model Theory