Yet Another Object Request Broker

Goals

YaOrb is a "pet" project, and has plenty of goals:

Having fun.
Implement things the right way, with tools to enforce that (tests, code coverage, code audits).
Use first hand all kind of tools and techniques while playing with the code, to see how far things can go.
Having fun.

History

1999

Coding can be very addictive, to the point of being a drug. Not working on something challenging for a long time can create a strong desire to just DO something, and so YaOrb was born (it was just named "Do It" at that time).
The project had to fit the following criteria :

Functional: functionality had to be specified already, so that WHAT to do is known,
Technical: implementation had to be un-specified, so that HOW to do it is the challenge,
Challenging: if it looks impossible to a sane person, it's perfect !
Equipment: hardware and software needed should be of good quality, and accessible to a home user,
Rewarding: not rewarding with $$; rewarding intellectually, more skills learned on the way a bonus,
Fun: no dead lines, no commitments, no boss, code when I want, how I want, only if I am in the mood for it.

To fit this list :

Middleware in general fits 2,
CORBA in particular fits 1, 2 and 3: the CORBA specs are thick (to say the least) and extremely detailed,
A decent PC for the hardware, and free, good quality, open source for the software fits 4.

So, it all started like this (with the sound of key strokes that still echoes today)

got a PC ? Check !
got a GNU/LINUX distribution CD ? Check !
got an internet connexion ? Check !
got plenty of time to invest ? Check !
insane enough to give it a try ? CHECK !

2000-2003

The code development happened with a peak in 2000, a peak in 2003, and very little in the middle. It's amazing how someone can be extremely productive in one week-end when implementing a very hot topic, or extremely lazy for months playing games (that's also the down side of having a PC and an internet connection).
During this period, several components were implemented in parallel, like the tooling side with the IDL compiler, and the network stack with the IIOP, GIOP, IOP and CDR implementation. The idea was to start from both ends to alternate topics, problems, and see how each side can be helped by the other (Oh, i need this data at runtime to drive the communication protocol ... wait, that's something the compiler can generate too). If an issue delays development on one end, just put it aside and work on the other end for a while ... Most of the time, a solution would appear by itself later when not thinking about it, and development would resume at full speed.

2006

After a long pause that involves buying a house, moving, other life events, and finally finding again a back-up CD with the most recent code base, the project is now public:

Thanks to

The reason for going public is that the code base itself is well advanced and has some intrinsic value (I hope), so that others can benefit from it or choose to contribute to it.
As was mentioned in the introduction, the project is to play with implementation ideas, and there are a few that I would like to experiment (time permitting), so development continues ...

License

YaOrb is not the first project that attempts a CORBA implementation, and most likely will not the last one either. Some ORBs are commercial, others are Open Source.
Looking at existing Open Source implementations of CORBA, most of the time the licensing is as follows:

The design time tools (like the IDL compiler) are covered by the GNU GPL,
The run time code itself is covered by the GNU LGPL.

This matches the licensing used by GCC and GLIBC, which basically allows someone to build a commercial application that uses the runtime.
For the entire project life cycle and until now, the implementation has been done on my own time, using my own equipment, and has never be disclosed or published, so that in effect, I (Marc Alff), the only copyright holder of the code, can make now in 2006 a desision about what licensing to use, even if the project really started in 1999.

Considering that the project has not reached an alpha release yet (it's very close for a subset of features), and that there are already Open Source GPL/LGPL implementation available at a mature state, releasing the code with a mixed GPL/LGPL license will not achieve anything.

As a result, the decision is as follows:

The design time tools are covered by the GNU GPL (no surprise),
The run time code is covered by the GNU GPL (not the LGPL, that's the surprise).

Let me rephrase that in a clear statement:

The entire code of
Yet Another Object Request Broker
is released under
the GNU General Public License.

The way I see it, the following can happen:

either YaOrb will never be known or will soon be forgotten ("Yet Another ..."), regardless of the license choice,
or beeing the only project with a GPL only license will turn to be an advantage for Open Source community in the futur.

This is a very far shot, but after all why not, so the point is to take another path and see where it leads. In the mean time, I still enjoy playing with it :)

Statistics

As of the first public check-in in the SourceForge CVS tree, the code base consist of:

137 folders,
1,073 files,
114,064 lines of code (as measured by wc -l).

These numbers by themselves do not mean anything, as only the content matters. However, you can see that some work has been done, so you are encouraged to take a look for yourself and see what this is all about :)

About the author

Marc Alff was born in France, and now lives in Denver, CO.

If you are curious about this project it's hosted on sourceFORGE.net. Look there for more info, to post in the forum, or to contact me.