John Catherino's Blog: Open Source Archives

Posted by cajo on August 30, 2005 at 07:44 PM | Permalink | Comments (2)

The cajo project is a very compact framework to enable completely transparent use, and transport of, ordinary unmodified Java objects; between Java Virtual Machines. It allows distributed computers to effectively coalesce; into a seamless, Virtual Virtual Machine. Its ease of use is undoubtedly its most intriguing feature.

The foundation of its operation is its transparent method invocation mechanism. It allows dynamic interchangeability of local and remote objects, with no source impact. As a result, the framework requires no interfaces, no XML, no annotations, and works with all JREs; 1.2 and higher. This makes cajo a unique, 'drop-in' technology; which can distribute literally any application, without re-designing it.

The framework applies four basic technologies; referred to as IPMB. Click on the links below, for more detailed information.

Items – Remote objects:
An item is an ordinary object, which is made remotely accessible. This can be done with as little as one line of code. The framework allows the public methods of the object to be invoked remotely.

Proxies – Mobile objects:
A proxy is an ordinary object, which is transparently duplicated inside another VM. A proxy allows otherwise remote code, and data, to be accessed locally.

Multicast – Object discovery:
Multicasting provides a mechanism whereby a remote object reference can be broadcast, and be received, by all listening VMs. It provides the ability to both transmit, and to receive these broadcasts.

BeanShell – Object scripting:
BeanShell provides an interactive, or file driven scripting environment, using pure Java. It is extremely useful; for quick jobs, experiments, and debugging. Items and Proxies integrate cleanly, as regular objects.

All these capabilities, and several more very interesting classes, come in its 38kB codebase jar. It has no dependencies on any frameworks; other than a Java Runtime Environment 1.2+, and optionally, the BeanShell jar.

The java.net community really works!

Posted by cajo on August 19, 2004 at 06:44 PM | Permalink | Comments (0)

Some of you may know me as the host of the cajo project. In fact, the topic of my blog entry today is that thanks to java.net; there are a lot more of you than I thought!

I was just informed about the logger project; it allows java.net project owners to view access statistics for their projects. What I found out astonished me. So much so, that I thought it important to share this discovery with you.

I started my project after a lot of introspection, (pause for geeky-Java-pun laughter :) For those of you who have not yet visited, the cajo project deals with virtualizing barriers between virtual machines; it allows objects to both interoperate, and travel between them, transparently. While implemented simply, I thought; this is sort-of abstract, and I wondered: Would anybody be interested?

Well, I was amazed to find more than 25 thousand visitors, just this year. On top of that, over 350 thousand page views this year. I never expected anything like this! (Some must be search engine hits, but unless Google got infatuated, it is still a lot of people)

So First I have to sincerely thank all of you who came to visit. Now instead of wondering: Will anybody notice? I am starting to think that this is an idea with some real peer-reviewed merit. I truly hope this project helps you; and I am very glad to be of help. And oh yes, please, spread the word!

Secondly, I am also delighted to have the opportunity to bring this idea to so many interested people! My deepest thanks to Sun, who made this possible; with this site, and through the development of Java; both at no charge! You have given the little developer all the tools of the big-guys, and as result; a real chance to make a difference.

Thirdly, for those of you thinking; is my idea good enough to be a project? There is only one way to find out; please try it! For those of you already running projects, if you have not already; please check out the logger project, it has very interesting information. And finally, as dutiful project leader: for those of you who have not yet visited the cajo project; please give it a look. The odds seem promising that you will find it enlightening.

Inside the World Wide Virtual Machine

Posted by cajo on August 01, 2004 at 10:08 AM | Permalink | Comments (0)

As I mentioned in my previous blog, the World WideVirtual Machine is a very exciting free space for the development of robust scalable fault-tolerant distributed applications. The cajo project is a small free framework defined to simply and easily realize this vision. Its reception by the java.net community has been both strong and positive. So in response to this, I thought it would be worthwhile take a little time to explain the philosophical concepts of the WWVM.

For the developers of the World Wide Virtual Machine, there is a fundamental viewpoint, which can be stated as follows:

The network is a vast collection of objects, ready to be used to create other objects.

If you stop to think about it, this is not too different from what exists in a typical single Virtual Machine design: There is the runtime library, and a collection of other local objects, both used to create applications. In fact, any application can be defined as follows:

An application is an object, which itself is composed of, a collection of objects.

As you can see, the WWVM is not a really large conceptual jump, especially considering all the exciting possibilities it enables. So let's take a look at some more WWVM fundamentals.

It has been stated that an application is a collection of objects, and it has also been stated that the network is a collection of objects; so necessarily the WWVM must have a very clear definition of what an object is:

An object has 1 or more public methods,
An object has 0 or more non-public member objects,
An object's public methods interact with 0 or more private member objects, with 0 or more argument objects, to return 0 or 1 result object; or to throw an Exception.

In a single-VM design, there is only one general category of object: local ones. These run in the address space of the host VM. However, in the WWVM there are three fundamental object categories:

Local Objects: existing in the local VM address space.
Remote Objects: existing in the address space of a remote VM, linked by the network.
Proxy Objects: existing in the local VM address space on behalf of a remote VM, and may (or may not) be communicating with it.

Each of these objects, being fundamentally different, are obtained in different ways:

Local objects are instantiated, either via a new or newInstance method invocation; or are deserialized from an ObjectInputStream.
Proxy objects are obtained via a remote object method result, or exception.
Remote objects are obtained via a request from a remote VM; or via a remote VM broadcast. (sometimes called listening to radio station WWVM :-)

While each category of object is used identically syntactically; the objects themselves exhibit fundamental properties, based on their category:

A local object can be passed to a remote object, only if allowed by both sides, where it will exist there, as a proxy.
A remote object reference can be freely passed between all objects and Virtual Machines.
A proxy is unique to the runtime in which it exists, and cannot be passed to another VM.

Objects are passed to other objects, either as method arguments, method returns, or in method exceptions. A proxy may even provide a distributed user interface, by instantiating a Window, as needed, at its hosting VM.

In the WWVM there are no primitive types per se; such as char and int. These are considered purely special case optimizations, of value solely within a local Virtual Machine. Also there is no inheritence of network objects. The WWVM focus is solely on the use of objects, by objects. Distributed objects are used solely via their public method interface.

The following security philosophy is inherent in the WWVM:

It is expected that all proxy objects will be hosted in a JNLP/Applet-type sandbox.

This makes the development and use of the WWVM no more risky than using ordinary applets, or WebStart applications; in fact, proxy codebases are typically unsigned. In other words; using the WWVM is safe.

At the cajo project, we are delighted to welcome new developers into the WWVM. It is a fascinating free environment that will only grow richer with greater participation. We welcome you to come look inside. It really does create some very exciting opportunities for an entirely new type of Internet.

(And of course, it also works equally well for the development of powerful distributed LAN applications :-)

A treatise on open source development

Posted by cajo on June 27, 2004 at 04:21 PM | Permalink | Comments (0)

Why become an open source developer? I think there are probably as many answers to this question as there are developers. I can only tell you about my decisions. I have been actively developing software professionally for nearly twenty years. I feel, as it is with many of us; it is not only my profession, but also my passion, and my hobby. I delight in learning useful new technologies. In the mid-90's, Java struck me like nothing I had seen before. I began to realize that the network could actually become the computer! (If anyone still remembers that slogan)

I was a very enthusiastic, and early adopter of the nascent 'object-oriented' technology. Having done a lot of assembly language network programming, I immediately saw the benefits it offered in many cases, compared to modular 'procedurally-oriented' programming. I saw in the Java environment, an opportunity to turn networked physical machines, into logical 'objects'. I spent several years actively exploring, and developing the concept; and it steadily continued to astound me. I searched the net exhaustively: did such an approach to simple dynamic clustering of machines already exist? As far as I could tell, it did not. For a moment, selfishness set in; I thought hey, I could lock this down, and cash in!

However, after a lot of consideration, my personal motivation to open the source was that the benefit realized by greater cooperation, was more valuable to me than financial gain. I thought I was already a lucky guy, enjoying an excellent standard of living, and standing on the shoulders of giants. I felt a need to 'give-back', and to help advance the state of the art. I also thought community input would make the framework even better; as I certainly do not have a monopoly on good ideas. Besides, I personally knew I wouldn't have the heart to exclude users of this technology, though I could willingly fight to keep it free for everyone.

Once I decided to create a project; a strange multitude of concerns set in. First I felt a strong sense of urgency. I worried that if I delayed, some company might come up with a similar technique, and assert proprietary rights. I worked day and night, on my most dreaded of tasks: thorough documentation. I knew without that, the project stood no chance at all. Next I realized that even more importantly; people would need an example: simple, extensive, and fully functional. I found this to be even more challenging than the documentation!

Finally: My project site was ready.

Next came fears to which I think every open source project leader can relate:

Would people flame my work?
Even worse; would some company steal it?
Much worse; would no one care?

Fortunately, I can say none of these came to pass. To my delight, initial reception was very positive. However, the challenges were far from over. At times, community input was so active; I worried that I would not be able to keep up. I was after all, doing this on my personal time, and for no money. These typically seemed followed by periods of such light activity; I thought the project had died altogether.

My next issue was how to get the word out; especially with no marketing budget. Every successful design requires mindshare, every bit as much as innovation. Adopting a framework requires not only awareness, but effort on the part of developers. Here I believe open source excels on both sides of the equation: Projects have to be genuinely interesting to justify so much effort, and the community is actively looking for good new ideas.

Developing an open source project requires a lot of time and effort. It certainly is not for everyone. I believe it is as challenging as bringing a commercial product to market. However, if you have an interesting idea, and community spirit, I unhesitatingly urge you to do it. I strongly encourage everyone to investigate, use, and contribute to open source software. I think it is both a social responsibility, and our legacy. As a project owner, I feel deeply indebted to my project's contributors, members, and users.

Rest assured, you will find me working on my project, for the long haul.

The World Wide Virtual Machine

Posted by cajo on March 17, 2004 at 08:29 AM | Permalink | Comments (4)

Disclaimer: This entry is in no way meant to slight the many other fine distributed frameworks out there. It’s just that this one is designed for us non-rocket scientists. :-)

I host a free project here on java.net called the cajo project. It allows any Virtual Machine to easily expose access to any of its selected objects to Remote Virtual Machines, as well as to send any of its selected objects to RVMs. It offers a very simple yet highly flexible framework for applications to work together. Most importantly, any existing object can be made remotely usable, with no changes to its source; an application simply adds this framework, not restructures around its requirements. I have found this unique amongst distributed frameworks.

A client can obtain a remote reference to an exposed object in one of two ways. It can request one explicitly, using just the name of the server, and the name under which the exposed object is registered, if it knows these things. In the framework, this is called static binding. It can also listen for object reference broadcasts, sent from RVMs. This is called dynamic binding. The references can then be freely shared in turn with other remote objects. Exposing an object for remote reference is done conversely; it can be bound locally under a name, or be broadcast to all listening VMs, even both.

Clients can invoke the remote object’s methods, and receive the resulting return, just as though it was a local object. How does the client know how to use a remote object? The object can implement a getDescription() method, it would provide detailed usage information. The object often implements a getProxy() method, it would generally return a graphical user interface component with which to interact with the remote object. The framework also features a standard generic client, which can be run as applet in a browser, or as an application via JNLP, to remotely host the GUI component.

Any VM can send an object (or remote object reference) to an RVM, as an argument to one of its methods, or by returning it as a method result. The objects will physically exist locally in the RVM, i.e. in the same address space, as its own objects. These objects are known as proxies in the context of this project, as they exist to act in a remote location, on behalf of their sender. The previously mentioned the getProxy() method is used to return a GUI proxy object.

The framework borrows from the best concepts of Jini, CORBA, and DCOM, but it is far smaller, as powerful, and much simpler to use. The core framework consists of only two packages; a total of only 13 small class files. It can be so small and easy to use, as it does not impose any application semantics beyond those outlined above. It comes with a detailed example file, ample documentation, and several support fora. It is completely free, licensed under the GNU LGPL, to allow both free and proprietary applications to operate together.

The framework is currently running on all Java Runtime Environments; J2EE, J2SE, and even J2ME. It is in active use on Linux, Windows, Solaris, and OSX systems. The goal of the project is to foster the creation of a WWVM. This is an exciting shared space of applications and object libraries, where they all appear and are used as though they were local, to foster the creation of new dynamic, interactive application networks. All VMs are free to join, from big mainframes, to tiny PDAs. (You can use any JVM compatible language, even Java)

Please come visit the WWVM community, all are welcome. Participants needed. :-)

Java raised to the power Linux

Posted by cajo on March 13, 2004 at 07:03 PM | Permalink | Comments (9)

For passionate Java developers, the network is the computer. However Java, and in particular its runtime environment, require a highly sophisticated operating system on which to run. Enter Linux; you would be hard pressed to find any system with more features. So, how does Linux increase the power of Java?

First let’s look at what Linux represents; it is a free, heterogeneous, network-integrated operating system. It runs on many hardware architectures (RISC, CISC…) and many platforms (ARM, PPC, x86, SPARC…). On the other hand, Java is a heterogeneous, network-integrated language. It is architecture agnostic, meaning no recompiling, and its code is network loadable. Together they can provide a ubiquitous standard environment, on a diversity of platforms.

Next look at all of the fine Java projects here at java.net, and other places, like Sourceforge and Savannah. Not only are our numbers increasing, but also another interesting thing is happening. You’ll see all sorts of projects to develop standard utility applications; browsers, mail clients, office suites, and even media players. Are we reinventing the wheel? No. We are inventing the ubiquitous wheel. Very soon all major utility applications will have been rewritten in Java.

Finally consider how easy it will be to make useful new devices. Design the hardware, bring up Linux, add in Java, and presto! A multitude of pre-written software, from enthusiastic developers, all dynamically loadable. Innovation and platform diversity is an exciting vision. Would all this flexibility require Java to be open source? I believe yes, to be as adaptive as would be required for this scenario. Linux combined with Java create the opportunity to easily and quickly create ‘JVMlets’, i.e. small fully functional runtime environments, on multitudes of devices, all working together.

There is no question, Java is huge, and I truly believe Java will reach even greater heights, standing on the exceptionally broad shoulders of Linux. Essentially, Linux abstracts the hardware, and Java abstracts the network.

This is where I want to go today, how about you?

Powered by
Movable Type 3.01D

java.net RSS Feeds