Computing Relations
Pile System White Paper
By Peter Krieg[1]
Abstract
The current computer software paradigm is based on a logically closed (monologic) architecture and a redundant method of representing events as data. This approach is generally considered as given, but has severe consequences on the performance and abilities of computers, since it fundamentally restricts computers to non-adaptive and non-scalable machines unable to cope with complexity. The Pile System is a new and different approach to both the logic architecture and method of representation, liberating computers from the current restrictions and enabling generically adaptive, scalable and complex computing.
Logic and Representation
Computers represent external events (translated into digital signals), structure and record these representations as data and operate upon and with these data using algorithms coded in programs. In the 60+ years of modern computing history we have taken the fundamental architecture of computing, i.e. the logic governing the way we represent, structure and operate as well as the method of representation we use to register events, for granted. We rarely become aware that these are mere design decision from the early days of computer technology, neither naturally given nor possibly the best of choices. As in architecture generally, it is the foundations that determine what kind of building can be constructed and how many floors can be added over time. In computing, it seems, we have reached the maximum floors that can be built on the existing foundations. But new application fields like bio-informatics, data mining, the simulation of non-deterministic dynamic systems like the weather and other processes in nature, including social and individual behavior, create challenges that drive computer software as well as hardware to their limits. These limits seem not so much set by the economics of building ever larger supercomputers or ever more complicated software programs or microprocessors. As has been observed by many researchers and industry leaders especially in bio-informatics, the problems lie deeper: “We don't have the computers, the database systems, or the computational tools to deal with this information now, let alone for what's coming.”[2]
A time of crisis has always been a time where we are willing to take a closer look at foundations in order to find long term cures that go beyond patches and band-aids. The current crisis of computing – an economic as well as a technical crisis- is also an opportunity to reconsider the very basic assumptions that this industry has been built upon and reflect on possible alternatives that hold the promise of curing the systemic ills of computing. Although there have been many critics inside and outside the field over the last 50 years that have pointed at some of the philosophical and technical roots of the problem, computer science and industry remain mostly in denial. Attempts in the 1960ies and 1970ies to address these issues have been silenced by the onslaught of Artificial Intelligence, for over 40 years the “Great White Hope” of computing. Only now that the failure of AI has become evident – as was predicted early by its critics- and even the mention of it becomes a liability to anyone seeking publication or funding, can we revisit some of the arguments and take a fresh look at the foundations…
The ultimate goal of computer science has always been to formalize the processes of the human mind and thus eventually build a “thinking machine”. Such a computer was expected to be able to calculate arguments in a logic way to reach ‘reasonable’ conclusions, conduct dialogs with human beings and adapt automatically to natural environments. A dialog basically requires to integrate the arguments rooted in the logics of others into one’s own logics and to ‘compute’ conclusions and arguments from different contexts and logics. As one contemporary put it: "The test of first-rate intelligence is the ability to hold two opposed ideas in mind at the same time and still retain the ability to function"[3]. In other words: a thinking machine would have to be able to cross any context, relate different contexts to each other and eventually build new contexts independently. Contexts are environments of arguments belonging to a common “subject” or “theme” defined by axioms. We could say that a context is a language belonging to a domain of logic or ‘contexture’[4].
To be able to know anything about anything, we need to
compare it with something else in another context. In a universe with only
apples we could not say anything about apples, because we could not compare
them to ‘not – apples’. This trivial observation begs a radical conclusion: to
describe anything we need to approach it from more than one viewpoint or logic.
In other words: a machine that has only one logic at its disposal, principally
cannot produce any new information, i.e. it cannot understand, learn or adapt –
all it can do is record and manage what other, more complex systems, have
understood and learned as new information first, and then have translated from
their logics into the system’s one and only logic. Processing the information
of others is what our monologic computers today are restricted to. They do it well
and fast, but they are limited to the knowledge of others. They are not
“thinking machines” and never will be as long as they rely on one single logic.
The expectation by computer scientists, that “intelligence” will emerge
automatically when computer chips become faster and contain more and more
transistors, has always been an illusion: a clock hardly grows intelligent by
adding more and more cogs… In fact, computers today are just that: extremely
complicated, highly integrated yet fundamentally stupid clocks. They are
neither adaptive nor even scalable: in spite of ever speedier and more
complicated chips, in spite of even faster growing memories and storage
devices, their operations keep drowning in data and complexity. The reasons lie
in the very foundations of their architecture: logic and representation.
One
Root (Axiom, Logic)
Classical machines are mono-logic
= all children have one parent only &
the system has only one beginning
A logic is defined by an axiom as a set of rules or statements that create a form to punctuate a stream of signals in such a way, that we (or the machine) can interpret it. Punctuation is what creates order in a continuous, seemingly unstructured and chaotic stream of events or signals. If our computer knows only one axiom, then all punctuations of incoming signal streams have to be translated first to that logic defining the punctuations the machine can read. This requires us to know beforehand which punctuation ‘fits’ the input stream so we can interpret it. When this is the case, we have a deterministic system. Unfortunately, such systems are very rare in this universe. If we trust quantum physics, they are actually impossible… But, in a limited way, we can create such systems by constructing a closed system of rules that determines all possible steps within. Today’s computers are exactly such closed deterministic systems. A closed system has the knowledge of all that can happen within it. The trouble with “knowledge of all” is, that there is nothing left to learn. Deterministic systems by definition are incapable of learning, as learning would change them in unpredicted ways – turning it into non-deterministic systems…
Learning is based on adapting, but since adapting also requires the integration of arbitrary logics, deterministic systems by definition are non-adaptive as well. This is the reason why we, as computer users, first have to adapt to a statistical “common user” whose logic conforms to the logic of our machine. Adaptive systems (like all biological systems) on the other hand do not (and cannot) have or require pre-knowledge about the signals they detect, but build “fitting” punctuations or logics through “trial and error” interactions with the environment. Because of that, they must be described as poly-logic systems[5]. The concept of polylogic is essential to understand living systems and phenomena like learning, adapting or complexity. If we agree that the ability to learn and adapt sets biological systems apart from traditional machines, we can also distinguish complexity from complication: Complexity is a polylogic description, complication is a monologic description. Polylogic is not, however, “another logic”. It is another ‘architecture of logic’, as it integrates different classical logics. Integration here does not mean bringing these different logics under one common axiom or root – this would again produce a mono-logic system – but to both unify and distinguish different logics in one system of reasoning (or computing). This enables every node or datum of the system to act as a root or new beginning for the entire system. It is quite easy to see that we as human beings (as all other living systems) operate as polylogic systems: we can change our point of view or mode of operation at any moment and harbor many logics that we apply as they fit: “Do I contradict myself? Very well then I contradict myself, I am large, I contain multitudes.” (Walt Whitman)
The problem of polylogic is as old as logic itself: Socrates saw it already in human dialog as the intersection of two different logics he called “dialectics”. In contrast to logic, dialectics could never be mathematically formalized. This is probably the main reason why in the Western culture we have been educated from Aristotle to Descartes and beyond to believe that the “correct way of thinking” is monologic thinking: True or false, black or white, tertium non datur… Eastern philosophy, in contrast, started with a polylogic concept of Yin and Yang, where white always comes with black…
A
complex description
requires
two or more logics
Yin &
Yang Symbol Pile Symbol for Polylogic
The second problem of current computer architectures is representation. Representation deals with the way we represent events in a computer as data. Events (as seen by a sensor or interface) consist of signals and their relations to other signals. In the current computer approach we represent only the signals themselves as tokens. Tokens are chunks of bits that result from punctuating the signal stream at predefined points (e.g. 8 bit in ASCII). Today the relations of these tokens (e.g. their connection to their neighbors in a sequence) are not represented and only implicitly recorded, but get lost as soon as we break up the recorded sequence, e.g. when we put tokens in different fields of a database. Even worse, we represent recurring events (like recurring words) in a redundant way, without representing or recording the fact (as another relation) that the system at some time(s) has seen this event already. This creates a lot of “real estate”, because it requires to record all events, regardless of whether they already have been represented in another context or not. Computers tody basically record input like tape recorders – the main difference is that they can access these data faster and in a non-linear fashion.
Still worse, we record these data into non-transparent containers that are hierarchically structured and organized. These hierarchical container structures are predefined normative categorization systems and have no longer any explicit associative relations to the context of the original events. So traditionally we represent only events fitting the single logic of our machine and we represent these events only in normative context but not in associative contexts. As a result of this approach, representation in today’s computing architecture is both redundant (producing ever growing amounts of data) and lossy (not representing associative relations or context). Since punctuation has to be predefined as a specific standard (like ASCII) in order to represent incoming signals at all, we also loose the ability to view data with other punctuations that might be useful to interpret the original signals in another way. This is especially important when we do not know all about these signals beforehand, as is generally the case in biosignals or any signals we detect from non-linear dynamic or chaotic systems like the weather or the stock-market.
Data representation is also at the heart of much of the scalability problems of today’s computers: Since we currently compute with data, this real estate always piles up in memory, when we actually just search for relations. Iterative next order operations which are natural for us in language or thinking – like making the result of a query the argument of the next query- are impossible or extremely expensive in computing today, because we always shovel real data. (try to make the result of a query the next query in your favorite search engine…)
The lack of relational representation also creates huge problems in data mining, pattern recognition or simulation: Relation is about context, because events happen in context and their meaning –as in language- is always context dependent. What we usually care about in computing is not so much data shoveling, but finding relations across contexts. This is why so many tools are on the market to help us find something that could have been available originally but that we have neglected to represent and record in our traditional computing approach.
A purely relational and adaptive (polylogic) computing system would indeed be the dream of every computer user, but has not been feasible using traditional architectures. The reason is that recording relations also produces a kind of data (or meta-data) and since we would have to relate everything in a system independent of context, form, logic etc. to really benefit, this would require exponentially growing memory and disk space in traditional approaches. Anything that produces exponential memory growth in computing will sooner or later (mostly sooner) overflow memory and become non-computable…
A relational and adaptive computing architecture for this reason must solve both problems of polylogic architecture and non-redundant representation. This has been the major puzzle since the first attempts to develop such a computer architecture were made in the Biological Computer Lab (BCL) at the University of Illinois in Champaign/Urbana in the 1960ies. Scientists like its director and founder, Heinz von Foerster and logician-philosopher Gotthard Guenther understood the need for a new approach to logic and representation, but could neither convince their peers nor come up with a working solution before the lab was closed down for lack of funding in 1976 [6]
Independent from the BCL approach the Israeli inventor Erez Elul since the early 1990ies attempted to break monologic inclusion and developed the Pile System as the first functioning architecture that indeed solves both problems of logic and representation. It has now reached a solid and stable implementation, and after independent testing this version is available for evaluation and application development.
The Pile System represents events purely as relations, expressed as connections in a complex, polylogic system of address spaces. All objects in Pile are complex addresses. Complex, because they connect the objects in several separate logical address spaces but still unify these logics in each address. Every object in Pile therefore has two or more parents, in contrast to just one in traditional technology.
In Pile, 2 (or more) trees intersect in every object. Pile trees are not binary trees, but hold many possible objects in every layer
To understand this approach, we must first overcome our traditional monologic way of looking at a mechanical system (like a computer) in terms of a tree. Pile can only be seen as a forest, because every point (node, object) is an intersection of two or more independent trees. This actually allows to break out of the inclusion of the hierarchical structure: A hierarchical structure can only be entered from the top (root) and allows no shortcuts or traversing of trees, unless we provide special shortcuts (pointers) and keep carefully track of them when structures are changed. By intersecting independent trees at every node Pile transcends hierarchy altogether: it becomes a heterarchic system whose trees (as chains of dependencies) are free from hierarchical restrictions.
The
Pile “Brain Forest”: a transparent,
fully interconnected space of complex connections. Any node can be an entry
point (many beginnings)
=
navigation is fluid
This space can be entered at any point and be traversed from any point to any point in a defined low maximum of steps. The max of steps is basically determined by the log of the number of conditions in the system, with currently only max 32 steps required to get from any point to any point. As a result, we get a fluid and fully connected computing space, like an idealized connection machine in software. We can see Pile as a generic substructure, which interconnects all representations in the system. Having such a fully connected generic substructure allows to simulate any other structure, form or standard without requiring the permanent creation of data, data structures or forms. Instead, simulated data in simulated forms are dynamically assigned to simulated structures.
Having two or more parents for every object represents an interesting dilemma: at every step the system has to make a decision which path to follow – the normative or the associative path. This decision creates a “manner” of operation, which can be predefined by the programmer or user, but can also be left for the machine to decide. Whenever we leave such a decision to the machine, it seizes to be completely deterministic. Along comes the notion of error, as a decision might prove to be wrong at a later point. The machine must therefore be able to recognize a mistake, retract its steps and change the original decision. The pattern of these “trial and error” decisions can be seen as the “ethics” of the machine, as has been pointed out by Heinz von Foerster. We are now in a completely new domain of “trans-classical” machines, which do not follow just one logic, are not deterministic and prone to error. On the other hand we must understand that it is precisely the capability for error that enables adapting to unknown, arbitrary logics. We have been told too long that computers are superior to humans because they cannot err. Quite the opposite: only because we are able to reach inductive inferences through trial and error, are we able to adapt, to learn and to develop intelligence of any kind…
The other major breakthrough relates to representation and data. Pile holds no data in the traditional sense of representation at all! Programmers, who take a look under the hood of Pile, usually ask first: “where is the data?”. Pile only holds relations and computes data dynamically from these relations – generally much faster than traditional systems access their data. The approach can be compared to a video game as opposed to digital movie recording: both display data as moving images at app. 30 frames a second. But while the game dynamically computes these frames on demand, and thus can generate zillions of different versions of a “movie” from very little, a movie on a DVD is basically stored frame by frame (compression aside) and accessed frame by frame, able to display just one version...
The secret sauce (and pending patent) of the Pile Systems is its complex addressing technique: Pile treats data, relations, structures, code etc. strictly as addresses, not, as traditional systems do, distinguishing between data in containers and their addresses. Pile distinguishes between data and structures (yet representing them in the same way), and therefore can still simulate containers. But since dimensions and complexity are not tied to actual data, any number of dimensions or any degree of complexity can be simulated as well. Data structures are simulations in Pile that do not actually hold data. Data (another simulation, since data in Pile are always virtual) are assigned to structures, and such assignments can be in all possible forms – multiple assignments of the same data to different structures, or structures assigned to other structures, or code assigned to data and structures etc… Whatever can be described can serve as a data structure. Changes of structures, one of the nightmares of current database computing (remember Y2K?) are trivial, dynamic and on-the-fly with Pile: just build a new structure or change an existing one and re-assign the data. The same applies to data migration and related tasks.
We can see Pile also as a pattern index system. Data in Pile are patterns of relations. These patterns are visible across all contexts of the entire system. Bio-informaticians appreciate such an open, transparent relational space, but so do data-miners and pattern-discovery experts in general. Patterns of relations can be related in Pile to other patterns of relations, thus creating second order patterns. Again, by not being restricted in size, dimensions or complexity, it becomes feasible to compute with signatures and to develop highly complex relational computing techniques. The key for such operations is the connectivity that the system provides, as well as its memory use. Any system that relates anything to everything it represents, produces an exponential growth of connectivity when new input is added. If this growth translates to exponential growth in memory use as well, the system is doomed. The behavior of the memory usage curve therefore is the decisive test for the viability of the Pile System also. The following drawing shows this behavior in the Pile System: the more data are represented in the system, the more the curve flattens! This can be verified experimentally also, of course. Since the flattening effect is mostly due to similarities in the events represented (e.g. English text alone is more similar as it has more recurring identical words or sequences than text collections in many different languages), the shape of the curve varies statistically rather than mathematically, approaching linearity in the worst case (when all represented strings are unique).
Files added to
system Memory use
Pile Memory Use: Curve flattens with more
data added to system.
Curve geometry depends on similarities
in the data (Compression effect).
Dotted lines: connectivity provided by
system / per object
Being able to compute with relations instead of data and still remain scalable certainly represents a major breakthrough in computer science. This is slowly being recognized by leading computer experts[7], once they take a fresh look at the very foundations of computing – logic and representation- and accept the possibility that a very different approach is indeed possible and desirable. The first application field where such an open mind can be found today is bio-informatics, because, as most bio-informaticians today agree, the available software tools are inadequate to represent or compute natural data. Bio-informatics is about relations and only about relations. Shoveling genomic and proteomic data in huge quantities is just neither feasible nor efficient. Since living systems, even the most “primitive” ones, do not seem to have any problem representing and “computing” these data as well as events they experience as environment, nature obviously has a solution. The engineering solution Pile provides has many analogies to biology[8], the most obvious being the fact that it too is both complex and simple:
Complex, because it provides a generic architecture and system that
- integrates as well as distinguishes different logics in independent structures under different roots without required pre-knowledge (open logic[9] and polylogic)
- represents signals and relations in a non-redundant way (virtual data)
- interconnects all representations (full connectivity)
- provides transparency to the entire system of representation and connection (visibility)
- linearizes memory growth as more events are represented and connectivity in the system increases exponentially (logically, however not physically!)
- universally represents all possible input (signals/data, structures, forms, standards, relations, code…) in the same way, so that all is comparable, visible and interoperable, making the system open and self-reflective
The Pile solution is also simple, as it achieves all the above (and more) with few equations and just 50 KByte of code. In fact, the solution that Erez Elul has developed is very elegant in the way it integrates complexity and simplicity – as had actually been foreseen by the early protagonists of the idea that such a computing system was actually possible and desirable… Biological computing systems – if we want to call living organisms that - have only been able to survive and evolve because they make similar scant use of their resources.
In order to avoid confusion with prior and existing technologies, it must be said here also what Pile is not. It is not
- yet another “data scheme”
- another implementation of Artificial Intelligence
- an Artificial Neural Network
- a tagging scheme of any kind (like XML)
- an indexing scheme or method
(Pile can, however, simulate and use all the above methods and schemes)
The possibilities in terms of harnessing both computational complexity (complication) and true biological complexity are immense with such a purely relational system. There is hardly a field of computing that would not benefit – from database computing to robotics, from language computing to communication… Yet the Pile System should not be seen as a threat to legacy systems, but rather as an opportunity to enhance existing applications and platforms. In this sense Pile is not so much a disruptive, but rather a promotive technology, enabling the vast knowledge, experience and investment manifested in today’s computer hard- and software to be promoted to a much higher level…
When Restrictions Do Not
Apply…
Computing polylogic relations instead of monologic data is a concept that has broad practical consequences. Not only does it allow to create applications that can adapt to complex external logics like those of biological systems, social systems, and generally non-linear dynamic systems, it also creates a fluid and dynamic connection space where computing is only restricted by the hardware environment. This space has many analogies to our own brain, which also seems to function as a polylogic, heterarchic and fluid connection space which does not record external events as data (e.g. images or sounds), but represents, integrates and generates them through relations -in ways we do not fully understand yet[10].
The immediate application areas of Pile are found where our current computing methods fare badly or fail altogether. Bio-informatics is such a field, because the traditional way of representing data does not correspond to the nature of biological events or signals, which change dynamically, do not follow a single logic and tend to overwhelm any redundant system of representation. Biological systems are composed of complex relations between molecules, cells, organs etc, and biologists and medical researchers are mostly interested in these relations. Any computing architecture that neglects to explicitly record relations and concentrates instead on the redundant recording of tokens, is hiding more than it reveals. This is at the core of biologists desperate cry for better and more adequate tools…
The Pile System can be seen as a dynamic and active architecture that allows lossless representation of all relations within an input sequence as well as within the entire system, yet does not collapse under an exponentially rising data load as should be expected. This will eventually allow us to store, mine and compare the genome of entire populations, find patterns like faulty genes instantly and analyze this database dynamically during research. Since any digital description can serve as a (simulated) data structure, it is foreseeable that we can model and at the same time simulate genes in a very complex, multidimensional database and not only dramatically speed up diagnostics and drug discovery, but also testing and even the process of drug-approval.
Pattern recognition and discovery are tools to see relations in a system or a process. As such they are not limited to biological computing, but are employed in all areas, where such relations are important. Data mining in personal computers, the Internet and enterprise transaction data is another area, where we try to represent, find and manage knowledge and information. Here also, current architectures do not emphasize relations, and thus require expensive and resource hungry tools to only partly make up for the “missing links”. A Pile knowledge system can relate patterns representing data sequences of any size to any size across any context. This allows not only to analyze and compare cross-contextually, but also to implement next order operations, where results from one operation become the arguments of the next. We then can automate complex processes of evaluation, trial and error, mixing data with code instructions in an inductive process of complex reasoning. Contexts can be automatically identified and constructed and eventually knowledge can be built by the system itself. We are only beginning to see the potential…
Computing data on demand and not having to access and retrieve data real estate from a maze of hierarchies allows us to assign data dynamically. This opens a completely new approach to applications, where rapid data access is vital – like project management, transaction computing or enterprise resource planning (ERP), but also language and speech computing. Machine translation is still in its infancy, because language is always ambivalent (polylogic), linking meaning to the context of sentences and paragraphs. A contextual dictionary that links not only words but sentences or paragraphs cannot be realized with current architectures, as the possible combinations would require astronomical memories. But with a virtual data architecture these restrictions do not apply as the contextual dictionary would be generated dynamically and on demand. Today we try to alleviate this problem using libraries of indexes, keywords and semantic tags (like XML) without fundamentally solving the problem. Extensive tagging necessarily will lead to tags of tags and so on, requiring authors to struggle with volumes of tagging catalogs in a Sisyphus exercise of “structured writing”. (Pile would represent such tags just like data…)
Artificial Intelligence, on the other hand, ignores the need for a polylogic adaptive architecture, focusing instead on mono-logic models of the environments which the machine is supposed to adapt to. This obviously allows the machine to adapt to the model, but not to the environment. Since the model itself has to be formalized in the (mono-) logic of the computer, it cannot model any complex (polylogic) non-linear dynamic system. In addition, the more complex the environment, the more data and code the model will require to describe it in its monologic reductionist way. This again causes the system’s memory to suffocate. Pile is able to use models as well, but can also dynamically change and adapt models to their dynamic environments. It would eventually even be able to generate automatically a dynamic model by analyzing the environment and detecting regularities in its relational patterns. This will open a completely different and much more effective approach to complex adaptive computing, autonomous robots or interactive machine control…
Adapting to unknown logics might seem like an esoteric problem, but it is in fact very common and immediate: every computer user is a complex system with logics unknown to his or her personal computer. Since our computers currently cannot adapt to such logics, we as users have to adapt to the machine. The term “user friendly” tries to obscure this fact -using up much of the computer’s resources as a consequence. Future polylogic computers will be able to adapt to their users in a very interactive way, eventually building up some form of “digital intuition” about their users and effectively reversing the current model, where users are quite literally “slaved” to their machine masters. Adaptive interfaces will be a new and challenging application field, completely changing the way we interact with machines…
The transparent and fully connected computing space of Pile allows to see and compare patterns of digital relations across any context, allowing to dynamically apply knowledge from well understood areas to identical or similar patterns in not so well understood domains. This will help to analyze unknown systems and to understand (and describe) their logics. With current tools we have barely begun to employ computers to such effect, since the computational and economic costs would be prohibitive. With Pile, desktops and notebooks will be able to be used in such complex operations, while mainframes and supercomputers will tackle tasks that we have considered non-computable up to now…
Some of these visions may sound outrageous or even preposterous today. They certainly would be when attempted with our current computer paradigms and architectures. With a relational polylogic architecture, however, many of today’s preconceptions and limitations must be revisited. Understanding this approach is the first step. Although there are good arguments for describing our own thinking as polylogic and relational, we have been educated for centuries –especially in Western Cultures- to think in mono-logic terms and to focus on objects instead of relations. Object oriented computing is the consequent implementation of this philosophy. Putting things in containers and boxes organized in hierarchical structures is the classical logic way we bring categorical order into an artificial world. This has been successful as long as we did not attempt to simulate or model the natural world. If the 21st century is indeed the era of bionics, of modeling complexity in nature and of biological computing, we must begin to look at things as results of relations to all other things, as a polylogic network of interconnected and interdependent systems. What is needed is not only to “think out of the box”, but to think beyond boxes altogether…
PILE APPLICATION FIELDS
Note: The generic properties
of the Pile System have wide application potentials in a variety of
fields. The following table shows some
of these properties and their relevance in some application areas
|
Property |
Enabling |
Applications |
|
Polylogic Architecture |
Overcomes restrictions of hierarchical systems and enables generic adaptation to arbitrary logics |
Adaptive
applications (bio-informatics, simulation, CAS, language/translation) |
|
Fully connected data space |
Any point to any point entry and connection in max 32 steps (in 32 bit address space) |
Very fast and effective data management and mining, CRM |
|
Representation of relations |
Patterns of relations are immediately visible across contexts, pattern discovery very easy and fast |
Pattern recognition and discovery solutions in many fields and across contexts |
|
Virtual data |
No restrictions of data sizes, no memory overflow due to data sizes |
New types of search engines, no query restricts |
|
Virtual structures |
No restrictions of structures (whatever can be described can be a structure) No restriction of dimensions and degrees of complexity |
New types of data modeling and complex data structures (e.g. 3D and nD models as data structures) |
|
Scalable address space |
No restrictions through limited address space, adaptive address spaces suited to tasks, yet fully interoperable |
Very large (Petabyte) yet fully connected databases (e.g. Genomes of entire populations) |
|
Separation of data and structures |
No “loading” of data into structures, just dynamic assignment = fluid, highly flexible structures |
Databases without need for restructuring or reloading, live migration tools etc. |
|
Unified representation |
System represents events (“data”), structures and code as addresses, thus allowing complete interoperability within and between systems. |
Compatibility and interoperability of all Pile applications |
|
Lossless representation |
Events are represented in contexts (neighborhood in sequence, seen before by system) |
Ideal representation of all natural data (bio, medical, dynamic systems etc) |
|
Dynamic computing (generating) of data |
Fast, dynamic assignment of data |
Dynamic transaction and process computing, dataless communication |
|
Perfectly ordered system |
Effective use of resources, fast operations |
New high performance hardware, HPCN, grid computing etc. |
© Pile Systems 2003 All rights reserved
Contact: Peter Krieg kriegpeter@aol.com www.pilesys.com