HomeOverviewLearn MoreBenefits
Hierarchy combines the world's most popular language, Java, with its most useful technology, XML, and with its most important tool, databases. It completely changes the way you create your systems, and is the easiest database you'll code with, ever.

What are the Benefits of Hierarchy?
In our test samples, we found developing database-driven applications with Hierarchy results in 15% to 60% less code than comparable applications developed using standard database-development techniques. And, yes, "60% less code" seems like typical, self-absorbed marketing BS:), but we (humbly) believe this actually makes sense. The main reason is because your application data is your database.

This means there is no writing of queries that pull a copy of the DB results into your system. And, this also means you avoid the often painful process of transforming these results into model objects. The data in your application is already your database. Pages and pages of code, complexity, and wasted dev-time are now gone.

To see a simple comparison of a standard, database-driven application with a version done in Hierarchy, please click this link.

Frictionless Persistence (currently in alpha testing)
Above, we just mentioned that in Hierarchy, "your application data is your database." We call this feature Frictionless Persistence and it allows you to enable persistence at the flip of a switch. More specifically, we've added a native data-structure into Java that can instantly be turned into a database. No more dealing with connection issues, setting up tables in a database, or configuring Hibernate mappings - To enable persistence on a matrix, you simply add one setting to the matrix, make sure the internal persistence-server is running and you're done. It must be one of the easiest persistence-solutions of any language, ever.
Both the Easiest and (Once Frictionless Persistence is Ready) One of the Fastest Database-Solutions
The fastest DB's we have today are in-memory databases (where the information is mostly stored in RAM). But almost all of these run in a separate process from your application's, and to work with a set of data, you still need to query the DB, copy the results back into your own application, then run some code to process these results.

In Hierarchy, because your application data is your database, all that overhead is gone: Your code collects and processes your data at the same time (using regular for-loops, just like you'd use with a regular Java-collection). As mentioned on previous pages, this is called NoDB persistence, and once Frictionless Persistence is done, this will make Hierarchy if not the fastest, one of the fastest databases in the world.

"The Missing Data-Type" - One Technology for Many Uses
Consider the laundry list of technologies we need to use in development:

   JAXB, Hibernate, SQL, XML, Axis...

For us developers to learn a large, complex system, we often feel like we have this gray soup of frameworks mixing freely in our heads. Now, with Hierarchy, we need to learn only one technology in place of five. The key to all these different technologies is hierarchical data, it's the data-type we've been needing for these years. This is why you can use Hierarchy for so many different situations, and why it does each one so extremely well. Hierarchical data is missing piece to all of these!

Hierarchy flattens the learning curve, clearing our minds, letting us focus on building simple solutions for our ever-increasingly, complex systems.

Super-Charged Hierarchical-Data
There's been a recent trend of developers returning to Java after having worked with other, higher-level languages. It's often because we want that balance of power vs. ease-of-use. This was our top-most design-goal with Hierarchy and we spent a ton of time trying to get the proportion of each just right. For instance, we designed our schemas to be as easy to create as possible. We hope, that after looking through our tutorial page, you found that unlike XML schemas, you can intuitively see how they work, understanding their structure with just a glance.

Lightweight and Optimized for Java
High Performance was a major design-principle we followed throughout the development of Hierarchy. We wanted the generated code to be extremely lightweight, and so we designed the accessing of data in matrices to perform with as little overhead as possible. So you'll be able to use the Java primitive types in your matrices, which means little space usage and fast access times. We could have just made all the data in a matrix as object types, but it wouldn't have performed nearly as well.

It's just regular Java
You may be a little worried that these language extensions actually make it more difficult to work with Java. Hierarchy should be 100% compatible with Java, because it is a translator that "translates" code written in our extended, Java syntax, with its new, hierarchical data-structure, into pure Java (actually, we don't call it a translator, we call it a meta-compiler that "meta-compiles" the code into pure Java). There are some complications with setting up the meta-compiler, but it's not too bad. During the development of Hierarchy, ease-of-use was another, fundamental design-principle we followed from beginning to end, from the syntax of these new language extensions to the configuration of the meta-compiler. And, since the meta-compiler is meta-compiling the code into pure Java, you'll be able to use all the class libraries and Java tools that you're used to. There's nothing special about the meta-compiled Java-code, it's just regular Java.

Future Plans...
This is only 30% of what we had planned. We won't go into too much detail, but just to give you an idea, here's a few technologies we're currently working on:
  • Language-Independent Frictionless Persistence! - Right now, you can only use Frictionless Persistence in Java, but in the future, persistence data will be in a standard format supported by multiple lanaguages. This will allow Frictionlesly Persistent data to be accessible by not just Java, but by Python, Javascript, or Scala ... Imagine, you'll you'll be able write multi-language systems all sharing the same data and each piecewritten with the easiest persistence ever. Lanaguage-Independent Frictionless-Persistence is one of our major goals for the future of Hierarchy.

  • An Excel-like editor that would let you edit matrices in a nice, easy-to-use IDE. It'll even let you modify matrices dynamically, at runtime!
  • New, language extensions to support software design.
  • A JSP replacement that allows users to generate code for any type of language (not just HTML)
  • And many other new features...
We'll be rolling out these new features over the next year.

What To Do Next? The next step is for you to download the beta. The meta compiler is free! Please click the link below to get started.