The Original Pile Engine Demystified

If you´ve followed my postings on associative/relationalistic approaches to information representation and were interested in implementations of the Pile concepts (see [1] and [2] for words from the horse´s mouth) you might also have stumbled across a C implementation of a so called Pile Engine at the sourceforge site of the project. (You can find my implementation there, too. But it´s in C#.)

Now, the C implementation has boggled quite some mind for quite some time. It was fast and used little memory - but was very, very hard to understand due to a couple of reasons. Unfortunately this has led to some misunderstandings of the basic Pile concept. To some it seemed, as if the concept/theory somehow was tightly coupled to this specific C implementation. It seemed as if "something magic" was happening in this Pile Engine which was essential and needed to be understood first or even be copied by future Pile Engine implementations.

Well, to make a long story short: this is not the case! And to prove it, I wrote up my findings in a paper you can read here.

I undertook the effort of explaining the Original C based Pile Engine (OPE) in order to finally and clearly separate theory from implementation. Any research on the potential benefits of the Pile concept needs to be independent of a particular Pile implementation - even if this implementation stems from the Pile originators.

After digging into the unfortunately not well documented intricacies of the OPE I can now say: It´s interesting and still holds some records in terms of performance and memory usage. Well done, Erez and Miriam! But there´s nothing in it, that couldn´t or shouldn´t be done differently (within a certain range) in order to get a working Pile Engine.

And I´m relieved to say: The Pile concept nevertheless is very interesting and needs much more research. View Pile relations as a different kind of bytes, i.e. smallest unit of information processing, and take a Pile Engine as an API on the same level of abstraction as System.IO of the .NET Framework.

Then: How would working with and "thinking in" relations change how we do information processing? Think of the implications... What would it mean to easily connect any (!) piece of information with any (!) other piece on any (!) level of abstraction? And such connections would be the only thing to worry about. No dichotomy of data and connections anymore. But I´m getting carried away... :-)

Links

[1] Pile Systems - the commercial side of Pile, www.pilesys.com

[2] Pileworks - the open source Pile forum, www.pileworks.org

 

Comments

# re: The Original Pile Engine Demystified

Wednesday, March 29, 2006 1:44 PM by Martin Lercher

Hi,

I've recently read an article in the dotnetpro about Pile. I didn't go to the original site, but in my opinion I've seen these "central" concepts long before: Lisp (or the more modern Scheme language or Prolog) implements these concepts since the 1960s. Think of Atom as "any piece of information" and List as a representation of "relation". Do some variable binding of lists (containing lists or other atoms) to atoms and you're done. Engine prepared, ready to do some information processing.

So where is the new concept of Pile? What new thinking can one do that couldn't be done with the very very basic language elements of lisp?

Best regards,
Martin

# re: The Original Pile Engine Demystified

Wednesday, March 29, 2006 2:05 PM by Ralf

@Martin: I´m not saying that relations are new. They don´t even have to do with programming in particular, as I tried to make clear in my postings.

However, (to put it a little bluntly) Lisp is, well, about lists. The interesting part being that lists could be programs in itself.

And Prolog is about knowledge inference using nested structures. (If I remember correctly.)

Both are about single hierarchies of information. They are about single trees.

But none is about an alternative way to represent any data. However, Pile is. Its radical view: There´s no data (inside the system), but only relations. And Pile´s question is: How could information processing be done differently if we started to connect everything?

Pile thus is more low level then Lisp or Prolog. It´s a different way to represent information, not a different way to just model programs or data, or to just infer knowledge.

-Ralf

# re: The Original Pile Engine Demystified

Friday, March 31, 2006 3:16 PM by Martin Lercher

Well, if there are only relations consider this point (dealing with finite sets exclusively):

A relation is a subset of a cross product of some sets S1-Sn. Now write down each element of this relation (a single product) by noting each component in order of their apearance in S1 up to Sn in a single line. What do you get? A list of n-ary lists (plus an ordering of the lines, which you want to drop, as this is not important for a relation).

Hm. That's one relation. Now for the interesting part, just as what pile does (at least what I think it does): The set of relations of S1-Sn is a (finite) set as well. So you can have a relation on that and some other interesting sets as well, what do you get? A relation that relates some relation with other relations on data. Put it the Lisp way: a list of lists of lists which are constructed of lists and atoms.

So where is the difference? IMHO a Pile relation is a specific Lisp list and Pile data is either an atom or an atom bound to a list (a named realtion). It's equivalent: all I can do with relations I can do with lists as well and vice versa. So Pile is not about an alternative way to represent any data. It represents informational units and calls them relations, Lisp calls them lists.

That's the very basic data structure Lisp deals with and that's the kernel of Pile. Things get interesting, when the operations on that data structure get specified. You'll probably get some basic retrieval, traversal and searching algorithms from Pile as otherwise it would be completely useless.

One last word: I strongly feel that Pile has great values as a datastore+retrieval framework. But, and here is my central thougt on this topic, Pile can not introduce new thinking paradigmas or even new knowlede to the field of data representation, *because* this research has already been done in the 60s by the Lisp people.


Martin

# re: The Original Pile Engine Demystified

Friday, March 31, 2006 3:47 PM by Ralf

@Martin: What distinguishes Pile from Lisp is, I´d say: 1.) No data in a Pile, 2.) multiple trees of relations interconnected. As far as I´m aware of, at least the Lisp community has not researched how to best represent information in an associative manner (which avoids redundancy) using just relations.

# Constitution of its Citizens: Home

Sunday, May 31, 2009 10:52 PM by Constitution of its Citizens: Home

Pingback from  Constitution of its Citizens: Home

Leave a Comment

(required) 
(required) 
(optional)
(required)