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.


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.


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.


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.


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://')/crew {
       <name>"James T. Kirk";</name>
       <email>"[email protected]";</email>

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://') {
  <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";

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...";

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://');
 <!-- 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://')/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 {
        <query>"xsharp manual";</query>
    } do {
        execute document('rest:');

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.


Drag, Drop, Done Development

With CodeGlide’s modern, web-based interface, you can create enterprise-grade Web applications, services, and Prontlets visually, with drag-and-drop, point-and-click ease.

  • Start developing on a blank slate or build on past work. Whether you design your application from the ground up, add onto existing applications, or combine applications to create a new application with more power than the sum of its parts, you’ll do it in the same environment your users see, moving you from drawing board to done quickly.
  • Just point and click to add menus, fields, forms, views, and relationships between other applications and data.
  • Prototype complex applications and work through “what if” scenarios quickly and easily.
  • Create components, then use them again and again in other applications.
  • Share data among applications with just a couple clicks of your mouse.

Embeddable Prontlets

In addition to rapid Web application development, CodeGlide gives you even more speed and flexibility by allowing you to create Prontlets that can be used – and reused –in any application.

  • Embed Prontlets in any Web page, wiki or blog.
  • Extend the capabilities of existing applications in minutes.
  • Drag and drop data sources, filters, transformations, application logic, and more to create full-featured services and Prontlets in minutes.
  • Drop in Prontlets, connect them with a click of the mouse, and deploy. Then, redeploy as needed.

Reusable Services

Not only can you build full-blown applications quickly and visually, you can create Web services that you can consume from any application. CodeGlide allows you to publish your information as:

  • SOAP 1.1 and 1.2 web services with WS-Security support.
  • RESTful web services.
  • RSS and ATOM feeds.

Device-Independent Applications

Why chain yourself to a desk? Develop your Web application, service, or Prontlet, then use it anywhere – from a desktop computer, iPhone, Blackberry, or any other Web-enabled device. With CodeGlide’s Application Builder and X# Advanced Builder, you get extraordinary mobile access without any extra work.


Flexible Integration

With CodeGlide, you can put your internal Excel, SQL, CSV, E-mail, and other data to work – and team it up with data from around the Web, like Yahoo! Search, Stock Information and other public web services. Our connectors give you the power you need to build the applications that will build your business.


Headache-Free Scalability, Maintenance, and Security

Managers of growing businesses have better things to worry about than scaling tried-and-true applications for additional users or wrestling with server upgrades and security. CodeGlide takes care of all that for you, allowing you to concentrate on what you do best.

  • Data encryption guards your data against unauthorized use.
  • Create safe and flexible data access protocols per user, per group, or per item.
  • Granular Access Levels.
  • Nested permissions among users and groups.
  • Business roles.

Prebuilt Applications and Templates

Whether you’re looking for a complete, full-featured CRM system or a time-saving template you can use as a starting point for custom applications, CodeGlide offers a range of prebuilt applications via the CodeGlide Solutions Exchange.


Sharp New Language, Powerful IDE, Amazing Results – Fast

Why should creating easy-to-use, yet powerful, Web applications and services require inflexible, hard-to-fathom development tools? For experienced developers, CodeGlide includes an intuitive and highly capable development environment, and our exclusive X# language, a high-level, XML-oriented coding that lets you build, test, and go live fast – without sacrificing features or usability.

  • Take advantage of X# XML oriented programming features to quickly create complex applications.
  • Code, test, and deploy all in one place with our CodeGlide IDE.

Comprehensive Reporting

CodeGlide gives you a wealth of ways to analyze your information.

  • Create summary, row-and-column, and matrix reports.
  • View reports on-line.
  • Create 3D charts.
  • Export reports to PDF.

Collaborate With Anyone, Anywhere.

Whether you’ve got two developers or 20, CodeGlide lets them collaborate across continents as simply and transparently as they could across a room. And once your application’s complete, users can collaborate and share information just as easily.