Ruminations

A Brief Glimpse - Publish Once

This is the second post of our A Brief Glimpse series, which is a sneak peek at some of the notes that make up the cacophony of our own little soundtrack. Marching to the beat of our own drummer is part of what makes us a little different. You can read the first post in this series here.

These posts will get a little (or maybe a lot) technical. If you start hearing the adults from Peanuts while you read this, that's not uncommon. Just take a deep breath, quote your favorite Stuart Smalley affirmation, and take things one paragraph at a time.

Software development is much more than writing code or knowing what design patterns or algorithms are best suited to solve the problem at hand. There's a delicate balance between the level of difficulty, the amount of cursing and the looming deadlines. We have to consider usability, performance, personnel, budgets, schedules, migrating data, training and much more — all while trying to communicate new concepts to clients while fighting the urge to over engineer the solution.

This post will cover a performance-related concept that also touches on usability and budgets.

Getting lost in the weeds can be counterproductive. As a software developer I am often counting the spots on the wings of the ladybugs who are on the leaves of those weeds. It is just the nature of the work.

Dealing with programming at this level of detail is necessary to develop highly efficient code. Efficient code increases speed and reduces hardware requirements. This keeps costs lower for us, which keeps costs lower for our clients. Faster response times directly affects usability, new system acceptance and performance momentum.

Hardware performance has increased exponentially over the last two decades. This, along with decreasing price-to-performance costs, has resulted in a lot software bloat. The expectation that the hardware will make up for poor system or software design has more than planted stakes in the software industry. It has set up shop and invited all its friends. Low standards produce slow, inefficient software.

One approach to increasing speed is caching. Caching works by using content the system has already prepared rather than recreating it each time it is requested. This can have a very positive impact on performance, depending on how it is implemented. Caching is generally an improvement over dynamically creating each page from scores of code files and hundreds of function calls and database requests. But not all content caching implementations are remarkably efficient as they still rely on executing quite a bit of code and accessing the database to serve their content.

At ElixWare we try to use the "publish once" paradigm whenever possible. Publish once is a simple concept: spend the resources to create the content once, save it as static content and reuse it until the content changes. This approach, when combined with our Constituency Inheritance Model (CIM), allows us to efficiently take advantage of published-once static content intertwined with dynamic content.

This blog post, and all the others on this site, are the product of "publish once". They merge two pieces of static content automagically via our CIM.

We use two approaches to creating "publish once" content. One is to build the static content at the time the data or content changes. Examples of this are menus and navigation, the content of data-based dropdown menus, data and/or markup used in dashboards, lists of content (such as the letters available in a letter writing system, or blog posts on a website), and many others. Rebuilding these at the time their source data changes ensures everything is up-to-date and efficient.

The other approach is implemented by our CIM. The CIM runtime checks for valid "fresh" content very early during execution and serves up the cached content using minimal resources. This, combined with late loading of page data, allows us to serve up content quickly, and often without ever opening the database (which also has security advantages). By using the server's own caching (built into the operating system) we gain even more speed resulting in faster response times. You click, and it just works.

Efficiency isn't the most important feature of business software, but it can make a noticeable difference. Whether it's refreshing dashboards, loading pages or using our One-Click reports, the instant response of your ElixWare solution helps you maintain momentum in your workflow. Efficiency is something you may not notice, but you'll definitely notice when it's gone.

It's our job to anticipate your needs, and meet them efficiently, in order to serve you better. Publish once is just way we strive to achieve that goal.

---