Low-code development platform

Project Brief:

CodeGlide was a low-code enterprise application development platform that allowed users to quickly build and deliver powerful Web applications, services, and cool little widgets called Prontlets in most cases without writing a single line of code.

Under the hood, CodeGlide relied on the X# programming language and the XUIML cross-platform markup language, both of them developed at Minter.

 

What is X#?

X# (pronounced X-sharp) is a domain specific language designed to quickly create Web applications and services. In X# everything is represented as a hierarchical structure or tree and instead of using functions to manipulate information or perform actions, all possible operations you can think of are done by adding, removing or changing nodes from this tree. Since there are no functions to learn and everything is done intuitively, even inexperienced developers can create complex Web applications and services in record time.

Object abstracted

In X# objects, relational databases, file systems, mail servers and any other data structure or repository is represented using a document object model. Just by manipulating the DOM using four simple operations (append, remove, update and execute) any complex action can be performed. Developers don't have to learn hundreds of functions to work with different technologies, repositories or protocols; any possible action you can think of can be performed by manipulating the object representation of your data using just these four operations.

Easy

Unlike other similar DSLs which require developers to learn hundreds of libraries and thousands of functions, X# is simple, intuitive, and easy to learn. It only uses 30 statements and four data types (node, string, number, and boolean) to create any application or service you can think of.

Powerful

X# can be used to write virtually any type of web application or service. Includes native support for multi-threading, exception handling, SOAP and RESTful web services, IMAP4/POP3, SMTP, SQL databases, Excel documents, HTTP, WebDAV, FTP, Windows Shares (Samba), ZIP compression, DNS lookups, encoding/hashing and many other features.

Fast

X# code is compiled to Java Byte code and has the same performance as Java applications. X# byte code is compatible with all Java virtual machines.

Portable

X# programs can be executed under Linux, Windows, Mac OS, BSD, Solaris, or any other platform with Java support. X# can be deployed to any Java application server such as Tomcat or Jetty. Users without a Java application server can download the X# application server which includes everything needed to create and utilize X# programs.

Open Source and Free

Released under an open source license. You can freely distribute or sell the applications you create using X#.

An introduction to the X# concept of building WebApps

Instead of relying on functions as application building blocks as many other frameworks do, X# replaces those functions with four basic node operations (append, remove, update and execute) on a DOM that represents the actual information. Let’s say we want to create a multi-threaded application that shuttles data to and from SQL databases, email repositories, and Web services:

To insert a record into an SQL database, a node representing the table in the database is instantiated and another node representing the record is appended to it to perform the insertion.

 append-child document('xdbc:mysql://192.168.1.27:3306/ncc1701')/crew {
    <row>
       <id>"100";</id>
       <name>"James T. Kirk";</name>
       <occupation>"Captain";</occupation>
       <age>"30";</age>
       <email>"[email protected]";</email>
    </row>
 }

To send an e-mail, a node representing the SMTP server is instantiated and another node representing the e-mail is appended to it to send the e-mail.

 append-child document('smtp://smtp.gmail.com') {
  <mail importance="high" subject="Test message"
     from="[email protected]" to="[email protected]">
     "Hi James,\n\nThis is my first X# plain text message.\n\n-- Spock";
  </mail>
 }

To create a file in a directory, a node representing the target directory is instantiated and another node representing the file is appended to it to create the file.

 append-child document('file:///home/jkirk/documents') {
    <file name="proposal.txt">
        "This is the content of the text file...";
    </file>
 }

Other operations just as intuitive:

To delete a record from an SQL database, the node representing the record is selected and then deleted. Or, to change the value of a record column, the attribute representing the column is changed and then updated.

 <!-- Create a node representing our DB -->
 Node sql = document('xdbc:mysql://192.168.1.27:3306/ncc1701');
 
 <!-- Delete all crew members with a name ending in 'Borg' -->
 remove-node $sql/crew/*[ends-with(@name, 'Borg')];
 
 <!-- Update the name of a record stored in our DB -->
 set-attribute 'seen' from $sql/crew/*[@id = '100'] to 'James Tiberius Kirk';

To delete an e-mail message from an IMAP4 server, the node representing the e-mail is selected and then deleted. Or, to change the message status to read, the attribute representing the seen flag is changed to “true” and then the node is updated.

 <!-- Create a node representing our Inbox -->
 Node inbox = document('imap://imap.gmail.com?user=admin&pass=secret')/folder[@name='INBOX'];
 
 <!-- Delete all e-mail messages over 1MB in our Inbox -->
 remove-node $inbox/mail[@size > 1048576];
 
 <!-- Change to read all messages with subject 'Newsletter' -->
 set-attribute 'seen' from $inbox/mail[@subject = 'Newsletter'] to 'true';

To delete a file from the local file system, the node representing the file is selected and then deleted. Or, to rename a file, the attribute representing the file name is changed and then the node is updated.

 <!-- Create a node representing our 'documents' directory -->
 Node documents = document('file:///home/jkirk/documents');
 
 <!-- Delete file 'photo.jpg' under a sub-directory -->
 remove-node $documents/directory[@name='personal']/file[@name='photo.jpg'];
 
 <!-- Rename file titled 'report.xls' to 'sales report.xls' -->
 set-attribute 'name' from $documents/file[@name='report.xls'] to 'sales report.xls';

As you can see, it doesn’t matter if we are working with database records, e-mail messages or files; X# abstracts the developer completely using just four basic operations. Working with other repositories or types of information is exactly the same; for example threads are created by appending the program code node to a node representing the thread manager:

 append-child /threads {
    pi {
  
       <!-- My code goes here -->
  
    }
 }

Or, we could call a Web service function simply by executing a node representing the Web service operation and passing the nodes representing the parameters:

 with {
        <appid>"testSearch";</appid>
        <query>"xsharp manual";</query>
    } do {
        execute document('rest:http://search.yahooapis.com/WebSearchService/V1/webSearch?messagetype=x-www-form&httpmethod=get');
 }

What is XUIML?

The eXtended User Interface Markup Language (XUIML) is an markup language designed specifically for creating rich, cross-platform user interfaces and Web applications. Powerful and widget-based, the XUIML markup language is as easy to learn as HTML, yet much more productive and capable. User interfaces built with XUIML are instantly deployable to most operating systems, Web browsers, and mobile devices without creating multiple versions, making XUIML a truly write once, run anywhere solution.

What’s the Difference Between XUIML and Other Markup Languages Like HTML?

In contrast to a more general markup language like HTML, which is focused on describing Web page features like layouts, heading levels, and hypertext links, XUIML’s powerful, widget-based technology is oriented towards application artifacts such as windows, labels, and buttons. It allows programmers to define a set of top-level elements like windows and panels; textboxes, grids, buttons, and other customizable UI widgets; and events such as click, drop, or submit. Another difference between XUIML and other Web markup languages is that widgets created with XUIML are not as rigidly bound to client application logic, which gives them a greater degree of flexibility and universality.

XUIML Separates Presentation From Application Logic

When program logic and appearance are too tightly interwoven, flexibility and platform-neutrality suffers. In cases like these, a small presentation change, such as titling buttons in Spanish instead of English, can involve extensive recoding. XUIML, on the other hand, loosens the connection between logic and presentation so that minor appearance changes are just that – minor. Further, core application logic is left untouched, even when the entire visual layout of the application changes. This philosophy of functional separation extends beyond logic and presentation to rendering. By eliminating dependence on a single rendering system, XUIML brings widespread portability to applications created with it.

XUIML Keeps the Write Once, Run Anywhere Promise

XUIML is designed to be platform-neutral. With the appropriate renderer in place, user interfaces and applications function identically across a wide range of operating systems and devices. Whether XUIML applications are rendered with Adobe Flex 3 or using XHTML, for use on mobile devices like the iPhone or BlackBerry, they can be coded just once, then deployed anywhere.