Agent-oriented programming is a new kind of software engineering where applications are built as a collection of autonomous computational tasks. These computational tasks are more or less independent from each other and can often be executed concurrently. It is this concurrency aspect which can make agent-oriented programming practice difficult. For example, it can be difficult, even for an experienced programmer, to detect and/or resolve well-known problems such as deadlock or livelock which generally occur in concurrent computational environments. Particularly, the use of complex dynamic interaction mechanisms make problems more difficult to solve, because even simple local computations that interact in a dynamic setting may result in a chaotic collective effect.

In reaction to the above problem, we suggest a simple adaptive agent-oriented kernel called the Abbey. The purpose of this kernel is to separate the design and implementation of computational tasks from the strategy that is used to execute these tasks concurrently. The idea of this approach is to gain more control over the complexity of distributed systems, because it releaves the programmer from the difficult task to take both functionality and concurrency into account simultanously. This allows experts in concurrency to work completely independent from experts regarding the application's functionality.

By no means, we intend to have the final word regarding the idea above. We only set out a direction into a new kind of concurrent programming where functionality is detached from concurrency. For this reason, we publish the Abbey, to provide everyone opportunity to build distributed applications and let others design the appropriate concurrency strategy for it. And, vice versa, to provide the opportunity to build an interesting concurrency strategy and let others build an application that will benefit from this strategy.

The interesting part is that it is not difficult to build an application that can run on the Abbey kernel. To design a good concurrency strategy is more complex, but the complexity also brings in the fun and satisfaction when you see your strategy in action on an arbitrary application. The good news is that this document provides a very quick way to get started. We will show how the famous Towers of Hanoi can be implemented and show some interesting concurrency strategy for it. And, one that can implement the Towers of Hanoi with the Abbey, must be able to implement any recursive function with it as well.

Knoppix User 2006-03-15