MetaGenesis - The MetaCode CDE

Information on this website is more aspirational than functional.

The goal of MetaGenesis is to help individuals and teams, build web applications quickly and easily.

MetaGenesis is a "Meta-Framework" or a "Meta Code" Cloud Development Environment. It is in intended to offer advantages over both traditional IDEs and "No/Low Code" application builders. MetaGenesis takes less development effort than traditional IDEs and yet provides the development team more control than no-code application builders.

What is a "MetaCode CDE" ?

A Meta Code CDE is a Cloud Development Environment where:

  • The application functionality is described separately from the implementation technology. This is the meta-code or application meta-data.
  • The application meta-data is then applied against implementation templates to generate the application.

What is MetaGenesis?

MetaGenesis at it's core, is a Cloud based, application development environment that allows teams, including product managers, UI/UX designers, and software developers to collaborate in building web applications. It is a forms based web application that helps define, document and generate web applications. MetaGenesis accelerates the software development, while still allowing programmers the ability to choose the technology and to easily modify and maintain the application.

In addition to standard IDE or No-Code functionality, MetaGenesis provides tools to extract meta-data from existing code. This allow the existing code to be imported, and the extracted data to help generate a new application.

  • HTML Scanner: Scrapes an existing website, extracts all the forms, separates the form layout from the form inputs, and allow editing of the forms or layouts.
  • SQL Scanner: MetaGenesis can read SQL schemas and automatically import all the tables and fields into MetaGenesis.
  • SQL Replicator: Using the defined tables MetaGenesis generates the source code for each persistence/table class.
  • Servlet Replicator: It can take CRUD and other back-end operations and replicate them using existing or custom templates, reducing server side code development to next to zero.

A key advantage MetaGenesis provides is it allows the developers to drive the tech stack, not the No-Code application builder.

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

MetaGenesis supports iteration at any time and both top-down and bottom-up implementation.

Comparison of MetaGenesis, IDEs and No Code

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 filed 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.

MetaGeneis

Data Input

MetaGenesis supports defining forms and their inputs. The user inputs a form name, form field names, types and data ranges. MetaGenie generates both the .html and the application run-time code to validate the data. The UX designer can provide a simple form example (.html) and all forms, associated with that template, will be generated in that style. These templates can be changed and forms using the template will be regenerated with the next press of the "Generate Application" button. Similarily fields can be added or validators specified and it will be automatically recoded.

Data Persistence

Most B2B and B2C applications revolve around providing and gathering data. There are two parts to defining the back-end, one is defining the data store and the other is conveying the data to the application data store. MetaGenie supports user input of table names, and table fields including data types, sizes and defaults. With this information it generates SQL tables and the code to access the tables. MetaGenie allows the user to pick the operation they want to perform, add the related data and the appropriate back-end code is generated.

IDEs

Each form is hand crafted in .html. Any form validation requires matching custom back-end code. Each time a form is changed changes must be hand made in the .html and back-end code.

No Code

These builders typically provide a drag and drop form builder. The forms and field parameters are defined by entering values into the no-code forms.

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

MetaGenesis encompasses a lot of technology, here is a quick overview. We call the entire framework, including the technology stacks MetaGenesis. The web application (metagenesis.org) will be a SaaS platform that we refer to as MetaGenie. Here are the main parts:
  • 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.

On the client side a MetaGenesis application consists of standard HTML, css and JavaScript, along with MetaL variables and "directives".

MetaL:

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

Variables:

  • are simply: $variableName; and will be replace with the appropriate value string (or nothing if not defied)
  • They can be passed to and between HTML pages by url: somePage.html?thisVar=thisValue (accessed in the page as $thisVar;)
  • They can access session data for example: $Session.varX; and can be set with <mg-SET:Session.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

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 main directives include:

  • INCLUDE - Both compile time and runtime includes are provided.
  • EXEC - Execute (Java) code.
  • SET - Sets a page, session or app variable. Supports conditionals and defaults.
  • FORM - Presents a form, fills in any provided information. Example <mg-FORM:formName?userID=$Session.user{id};>
  • QUERY - Executes a named SQL statement. Captures any results in a register.
  • REPORT - Presents the named report.
  • TRANSFORM - Applies the named transformation.

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=$Session.myID;; 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=$Session.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>
The API only runs/provides the queries that have been built into the application. It is NOT a generic "run any query" against the database API. Note: the above example, along with a MetaGenPost call, is the entire client API for getting HTML from the server.

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

MetaLib is a core MetaGenesis library that supports MetaGenesis web applications.

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

MetaPlugin is a Java code template library for
  1. Servlet Templates
  2. Table Class Templates

Legacy Conversion Support

MetaGenie has import features that help support migration or modernization of legacy applications.

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.



This site is parked.
MetaGenesis.org an iClick.Media publication
Release A.000.001