MetaGenesis - The MetaCode CDE

A key advantage MetaGenesis provides is: it allows the developers to drive the technology stack, not the application builder.

Click Here to see the main similarities and differences between a Meta Code CDE and a No/Low Code IDE.

MetaGenesis vs IDEs, No-Code, Vibe-Code and AI coding.

MetaGenesis and the other development tools provide the same coverage within a project, meaning they assist in generating the code, testing and deployment. MetaGenesis provides additional application documentation because every component is documented. Every form, form field, report, query, list or transform is documented. This level of documentation is often not done or done poorly with the other development approaches.

MetaGenesis offers several ways of using it. (Conventional IDE's are strictly code based and No-Code platforms don't support user coding.) MetaGenesis offers a mix of forms and conventional code editing. For instance it can automatically generate the code for a form and then the developer can edit it with the built-in HTML editor. In addition it will include

• User driven AI chatbot. A "conventional" AI chatbot that takes user direction to build the application.*
• AI driven user chatbot. This is a chat equivalent of filling out a sequence of forms. The chatbot (MetaBot) asks the creator questions about the application and builds it according the the answers. *

All of these interfaces use existing components/templates to build the application.

Traditional IDEs provide a desktop application with a file tree down the left side and a window to edit the code. IDE features include language support, including code formatting and code navigation. The cloud version moves this to the cloud, with essentially the same features. There is little to no connection between the application layers code. For instance if your application gathers a value, stores it and reports it, this requires the developer to edit the HTML, the server-side business code and the persistence code.

No-Code IDEs again provide a desktop application that feels more like a drag and drop graphic editor. The code is gone and the app builder (aka developer) drags and drops components. Much of the development work is forms based, i.e. entering field names and constraints.

MetaGenesis is a browser web application which provides the speed and ease of development provided by no-code platforms and the control provided by traditional development. It provides a forms based interface for the bulk of the development and traditional code editors when needed. Like no-code platforms MetaGenesis provides the server side code to build most application. Unlike no-code platforms most of the code is available to be reviewed and edited by the developer.

MetaGenesis is about Functional or Requirements based Application Development. It captures the requirements creating a metadata set that can be used to generate the server side of the application and potentially part of the client side.

MetaGenesis Components

• MetaGenie - The web/SaaS application for developing MetaGenesis projects.
• Metal A Meta Language that is added into HTML (and .css, and .js) and will be interpreted by MetalSrv.
• MetalSrv & MetalQSrv - Run time (server side) servers that serves HTML. MetalSrv is a classic server that processes the code before serving it to the client. MetalQsrv processes the same directives, but responds to clients request to serve them (similar to HTMX).
• MetaGenesis.js A very small JavaScript library that communicates with MetalQSrv to request directives, receives data and updates the HTML.
• MetaGen Libraries
  • MetaLib - Core MetaGenesis Libraries
  • MetaSQL - SQL OO Library (alternative to Hibernate)
• MetaGen Templates
  • MetaPlug.java Java Servlet templates to perform CRUD operations, email handling, sign-in-out-up.
  • MetaPlug.sql SQL Templates to generate MetaSQL compatible table classes.

What the components do and how they work together.

Metal:

Metal (Meta Language) is intended to be very, very... simple. Essentially it is variables and about a dozen web components or directives.

Variables:

• are simply: $variableName; and will be replace with the appropriate value string (or nothing if not defined)
• They can be passed to and between HTML pages by url: somePage.html?thisVar=thisValue (accessed as $thisVar;)
• They can access user session data for example: $User.varX; and can be set with <mg-SET:User.varX=$pageVar;/>
• Vars can be simple ($myVar;), hashes $myHash{}; arrays $myArray[]; and hash arrays $myHashArray{}[];
• They can be access in whole ($myHash;, $myArray; ) or in part ($myHash{keyName}; $myArray[2] ; or $myHashArray{key}[2];)
• Variables can be passed to directives, for example: <mg-FORM:formName?formID=$formID;/>
• Variables can be used for in-line HTML, CSS or JavaScript code.
• Example client code:
  • HTML Code: <div>Hello $firstName; $lastName; your checking account balance is: $balance{checking} your savings is $balance{savings};</div>
  • App Page: Bob Brown your checking account balance is: 1234.00 your savings is 4321.00

Directives (aka Server Side Web Components)

Directives fall into two categories:

1. Includes: These are instructions to "put some specific code here". FORM, REPORT, INCLUDE and LIST all "pull in" code.
2. Executes: These are instructions to perform an operation that does not return code. SET, EXEC, QUERY and TRANSFORM execute code.

Directives are coded similar to HTML elements, starting with <mg- and ending with ;/>. They include a type (see below), a name and optionally a "URL style" parameter string.
For example: <mg-FORM:formName?formID=$formID;&firstName=$firstName;;/>

The include directives are:

• INCLUDE - Both compile time and runtime includes are provided.
• FORM - Presents a form, fills in any provided information. Example <mg-FORM:formName?userID=$User.user{id};>
• REPORT - Presents the named report.
• LIST - Presents a list of data.
• AGENT - An AI component that allows access to a wide variety Artificial Intelligence capability.

The execute directives are:

• SET - Sets a page, session or application variable. Supports conditionals and defaults.
• QUERY - Executes a named SQL statement. Captures any results in a register.
• EXEC - Execute (Java) code.
• TRANSFORM - Applies the named transformation to the data.

Some of the directives are self described (INCLUDE, SET, LIST) and do not require any additional information to be processed by MetalSrv.

Many of the directives are supported by MetaGenie functionality that allows users to provide more code or details on how the directive should be processed. For instance:

• the FORMs directive is supported with layouts, data validation, input (metadata) management and mapping data from the form inputs to the application and/or database.
• the AGENT directive is supported by allowing the developer to choose the the interaction type (voice, text, none), add data to the knowledge base, choose the inputs to the AI and choose the AI model being used.

The directive type and name refers to information the developer has specified in the MetaGenie application.

A typical HTML/Metal example:
<div>
<mg-QUERY:myQueryName?myID=$User.myID;;/>
<mg-REPORT:myReportName;/>
</div>

Using MetaGenie (the MetaGenesis web application) the "developer" would add the query to the meta data specifying (via a form) the database, table, conditions, operation (SELECT, COUNT, DELETE), limit, etc. Then the user would define a report which is simply the HTML/Metal to present the query results.

MetalSrv

MetalSrv (Metal Server or Metal Template Engine) is a target app runtime component that acts to replace the Metal variables and executes the directives. It is comparable in may respects to Apache Velocity. For a more detailed discussion see MetalSrv vs Apache Velocity

MetalQSrv (Metal Query Server) is a target app runtime component that supports client calls to the server side. The client API is the same as the server side API, but wrapped in a small bit of JavaScript to send it to the server. For example:

• For delivery when the page is served (as shown above):
  <div>
  <mg-QUERY:myQueryName?myID=$User.myID;;REPORT:myReportName;/>
  </div>
• For delivery when requested by the client:
  <div>
  <button onclick='MetaGenGet("QUERY:myQueryName?someQueryVar=$usersChoice;;REPORT:myReportName;");'>Request Report</button>
  </div>

MetaGenie

MetaGenie is the web/SaaS development application that is used to manage both the metadata and the code. Metadata management is forms based and code management is through an online code editor.

MetaGenie functional highlights:

• Forms & (Data) Maps - Supports form definition including:
  • Basic form information like name, method and action
  • Input information like name, type, label, placeholder, defaults.
  • Buttons information like name and value.
  • Data cleaning and validation rules for each input.
  • Data conversion from text to app data type.
• Queries - Supports SQL query definition including
  • Database and table
  • Operation (SELECT, COUNT, DELETE)
  • Conditions.
  • Columns.
  • Group, order by.
  • Limit, origin.
• Reports - Supports report definition including
  • 0 Result Template
  • 1+ Result Template
  • Automated List support
• Servlets/Plugins - Supports creating servlets from templates/plugins
  • CRUD operations.
  • Sign-in-out-up-recover.
  • Email send and receive.

MetaGenesis Libraries and Templates

MetaLib

MetaSQL

MetaSQL is a OO SQL Java library that provides a Java interface to SQL databases. It includes classes for connections, credentials, databases, pools, queries and generates custom table classes. MetaSQL supports NoSQL in that SQL tables can have columns that are custom Java classes (documents). What sets MetaSQL apart from other persistence libraries is the business/table classes are inherently persistent. Meaning they all have instance methods like insert(), update(), select(), delete(), persists() and static/table methods like SELECT(sqlQuery), COUNT(condition), DELETE(condition).
more info...

MetaPlugin

1. Servlet Templates
2. Table Class Templates

Legacy Conversion Support

Forms Import: MetaGenie support importing forms from legacy applications. Point MetaGenie at the website and it will scrape the site and extract both the form metadata and the template.

SQL Import: Point MetaGenie at a SQL database and it will extract the metadata for all the tables. It will then generate a Java class for each table providing Java access to the legacy database.