in search of prior art

While coding Inklog, everytime I run into a little problem that I don’t know the best way to solve, I get sidetracked and start looking for other projects that may have used a similar concept to see how they did it. This never really leads to me learning anything because, for the most part, I can’t find examples of the problems I’m trying to solve. However, this is starting to discourage me.

This morning I decided to try something new. I decided to look for similar code in the Python world. This led to my search for something similar to Inklog in Python world. Both searches turned up empty. Again, this is starting to discourage me.

Is the framework that I propose so radically different that no one has ever thought of doing it before? Or is it so incredibly difficult that no one has ever managed to build it? Or, is it just the worst idea ever that, in the end, will fail miserably?

The concept doesn’t seem that difficult to me. So, I’m going to ask you, my dear readers, if you have ever seen an application, in ANY programming language, that exhibits the following properties:

  1. Template based: all output is supremely customizable without knowing even the slightest thing about the programming language the application was written in. It’s okay if the template engine requires basic knowledge of programming control structures and variables. However, it should be designed in such a way that, only very simple programming structure is needed. There are a million template engines available in almost every programming language that’s ever been used in the web world. Almost all of them are well suited.
  2. Modular development: the code should be broken up into small pieces that allow massive amounts of code reuse and the ability to modify core functionality of the system without understanding every line of code int the entire code base.
  3. Displays content: the system should primarily function as a method of displaying content. In other words, the primary goal of the system should be to take data in one or many formats, and give it a common look and feel based upon the templates defined by the user.
  4. Modular content input handlers: the system should be able to easily learn how to display new types of content by authoring only a simple "model" to retrieve and/or convert that type of content into something the system expects. Example: if the system doesn’t understand what a Microsoft Word document is, I should be able to write a simple handler that converts a Word Document into a format it does understand (say, HTML). After inserting this handler into the system, it should then be capable of storing and displaying Word Documents with the same look and feel based on the templates.
  5. Modular content output handlers: the system should be able to easily learn how to output in different fashions by authoring only a simple "model" to render content in that fashion. Example: if the system doesn’t understand what a MIME encapsulated email is, I should be able to write a handler that knows how to create such an item and knows what is required to ship that item across the wire and format it accordingly. Additionally, if the content input handler isn’t capable of rendering the content in a format that is suitable for delivery via the requested output mechanism, it should have a way of alerting the user of this (for instance, if I request a PDF file to be output as a Microsoft Word document and the PDF content handler doesn’t know how to generate a Microsoft Word fragment (or something that can be converted into a Microsoft Word fragment) it should simply inform the requester of this.
  6. Storage: all content should be stored within the system, at least in some fashion. Even if it’s merely an identifier stating how to retrieve the object and where it can be found.
  7. Authentication: all content should be guarded by permissions. Certain users should be allowed to act on certain items in certain ways and all of this should be definable by the owner of each piece of content as well as the owner of the site at large.
  8. Searchable: the system should support an API in the template system that will allow specific items to be located for inclusion in the template files. Example: if the system is currently displaying item "A", the template file should be capable of requesting the most recent item of type "B" in a specific format.
  9. Hierarchical: the content should be stored in a hierarchal fashion, or at least contain some method of referencing the content in that fashion. It should allow a specific item to be the child of another item, the sibling of another item, and the parent of another item all at the same time.

So, I ask you: does this exist?

Leave a Reply

Your email address will not be published. Required fields are marked *


You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>