Offsiders are persistent, object-like entities that can be accessed from the Unix shell. All interaction with an Offsider is by means of messages passed to that Offsider.
Alternatively, you can think of an Offsider as a computer system which has been wrapped in such a way that it responds to messages in an object-oriented fashion.
Powerful, flexible and easy to use, Offsiders provide a novel way to organise, manage and access data and software within systems of any size. They provide object-oriented capability to the UNIX shell in a natural and intuitive way. No need to learn a new programming language. Offsiders just work.
They are simple to create, and work immediately. Methods can be written using any programming language, compiled or otherwise. Data or methods can be accessed at any time by any process, and from any language (UNIX file permissions permitting).
Can You Contribute?
This project is keen to hear from people interested in helping out. If you have skills including web-site development, project management, testing, quality assurance, technical writing, promotion, community-building or programming then let us know.
Email us at
The Offsider framework consists of a collection of executables. They are currently implemented using shell script and some compiled C, (although the choice of language has little bearing on the result).
An Offsider is a persistent structure created at some point in the file system. Each offsider has its own directory, and is completely contained within that directory. Typically, when an offsider is created, an executable is also created which acts as a named reference to that directory.
An executable called
offsider (typically residing in
/usr/local/bin) provides the
primary point of entry, and acts as the equivalent of a language engine. This script delegates to other scripts as required to
provide the object-oriented functionality for any particular offsider.
offsider is also aliased to
this to provide a familiar idiom within method definitions.
Individual Offiders are created by the user, either by building a new offsider, or by cloning an existing one.
Numerous methods are provided by default, which all offsiders understand. These can be over-ridden as required, or new methods provided as appropriate. Offsiders can be nested within each other, and it is also possible to create offsiders that have non-typical data structures embedded within them.
Offsiders are completely language-agnostic. They can be called from any programming language, and the methods can be written in any programming language.
In as much as an offsider is a collection of related executables and data, an offsider can be thought of as a computer system. In fact, any existing computer system can be wrapped inside an offsider to provide an object-oriented interface to that system and its related files.
If you have any ideas or opinions for how the API should look, now is the time to have your say. The API will be fixed as at version 1.0. Any feedback is welcome.
This immediately leads to the problem of how to explain the concept. This rant is an attempt to address that problem by comparing offsiders to some existing concepts, and elaborating how they are similar, and how they are different.