Welcome, Guest! Log In | Create Account

AgileWiki - Building Web 3.0

Two things are central to Web 3.0:

  1. Extending the web to include virtually all computers and
  2. Semantics, name scoping in particular.

Extending the web to include many more computers means that--

  • It becomes much easier to provide controlled access to content. Intelectual Property can be kept "in house" while still making it accessible to selected parties, and without the need for a static IP address or dedicated servers.
  • New applications can simply be deployed on a developer's desktop where it can be closely monitored and maintained.
  • Easier deployment and lower costs will open the doors to new nich markets for specialized software.

Now by Semantics we are not refering to the Semantic Web. The Semantic Web is a grand endevor which has yielded some fruit, but this is a major undertaking that will take much time and effort. And it may not always be the best fit for the needs at hand.

All developers are familiar with the concepts of scoping and extending namespaces by including other name spaces. We see such capabilities in both programming languages and XML. But these concepts now are also needed when working with information. A good case in point is the wiki.

Most wikis have a a flat namespace and, as the content grows they quickly become unmanagable. Wikis do not generally function well as knowledge repositories covering diverse topics due to name clashes. And they are difficult to organize because of the lack of distinction between structure and content. Hierarchical wikis are a notable exception, but the approach is too simplistic to be useful. Only we need to apply what we already know about programming. We need multiple inheritance and the ability to import namespaces.

Qualifiers (tags) and relations are also important and also need to be scoped. Without scoping, searching has become quite difficult. Conversely, when we add name scoping, type validation and access control to qualifiers and relations, something very interesting happens: application logic can now be written to use qualifiers and relations just as they use any other data. Knowledge-driven software becomes easy to implement.

Now Web 3.0 is, almost by definition, anything that can't be implemented in Web 2.0 due to the limits inherent in current software engineering practices. And one thing stands out above all others: There is no general, high-level model for software development.In the last 50 years there has been a lot of progress in the understanding of systems of systems, but this work has remained largely obscure. The result is that there is no way to design and implement a system (or service) with any assurance that it can interoperate with other systems. So we find ourselves rewriting almost the same code over and over, for a Swing client, a database server, a web server, and even for minor variations of these. Conversely, integrating pre-existing applications and servers has become a black art, and even upgrading to a new release is quite a challenge. This all makes software much more expensive than it should be.

A High-Level Model for Software: Rolons

Rolonic Theory by Norman Kashdan is a careful integration of current thinking on systems and systems of systems and which he claims contains not a single original idea.

Rolonics gets its name from Roles (every system, by definition, is composed of roles that distribute responsibility among themselves in order to do “their own thing” as well as to work for the greater good of the system) —and— Holonics (a theory of whole-parts) along with its subsidiary fields of Mereology (a deeper theory of parts) and G. Spencer-Brown’s Laws of Form (a deeper theory of boundaries). –Norman Kashdan

Everything is a Rolon, and systems are built using collaborating Rolons. Rolons have four aspects, which are comprehensive:

  • Wholeness - How a Rolon behaves as a whole.
  • Partness - How a Rolon is interconnected with other Rolons as part of a larger system.
  • Structure - The content of a Rolon and how that content is organized.
  • Stream - The changes made to and actions taken by a Rolon--its history.

Rolonic Software Engineering models Rolonic Theory. Rolons are user objects which implement services, hold content and serve as indexes to other Rolons. A Rolon is implemented as a kind of XML DOM with flexible bindings and is itself fully scalable, as elements which hold other elements are implemented using b-trees. Rolons share a common persistent store, a Rolon called the Ark, and a common life cycle. So it is relatively easy to compose complex systems.

Rolons are organized in a loose hierarchy called a bush structure, which allows a Rolon to have more than one parent. Generic qualifiers (tags) and relations are also supported, for fast searches and easy navigation of complex structures. Qualifiers and Relations are name-scoped, as are all Rolons, so a single Ark can encompass a wide range of subjects with otherwise conflicting terminology.

Journals and Journal Entries are two more types of Rolons. The parents of a Journal Entry Rolon are always Journal Rolons. Journal Entry Rolons record activity and other changes and when a Rolon is updated, a Journal is created, as needed, to record the changes.

The Element Model

The base platform of AgileWiki, Element Model, implements a fully scalable and robust Ark. The DOM used to implement Rolons allows different classes to be bound to each type of elements. Depending on the binding schema, the program defined by the Ark Rolon can be a Web Server, a Swing Client, a P2P node, a Back-End Server, or any combination of these. Plugins are used to define and extend the binding schema, bind Java classes and other meta-data to XML Element Names. A plugin can define new Element Names, but it can also extend the meta-data bound to an existing Element Name by another plugin.

Additional features include:

  • Scoped Qualifiers on Rolons
  • Scoped Relations between Rolons
  • Qualifier and Relation Searchs
  • Access Control
  • Navigation across Peers
  • Single Signon
  • Data Migration
  • A Database Validation Utility
  • A Swing Front End

Technologies used by the Element Model include:

  • Copy-On-Write (COW)
  • SMTP Server
  • Full-Duplex NIO Sockets
  • B-Trees
  • Namespaces and Namespace Imports (Applicative Context)
  • Meta Data driven GUI
  • Asynchronous Command Processing
  • Fibonacci-based Disk Space Management
  • Weak References and LRU Caches
  • Extensible/Scalable XML DOM with flexibles Binding.

Many additional projects are planned, including:

  • A File Proxy for providing controlled access to local files.
  • A Distributed Wiki.
  • A web-based browse.
  • JXTA integration.
  • Jetty Socket integration for access from behind firewalls.
  • An email client.
  • RSS feed and reader.
  • A Semantic Inferencing Engine

Starting Points


Copyright © 2010 Geeknet, Inc. All rights reserved. Terms of Use