Daniel Brookshier's Blog

JXTA Archives

JXTA at 5 Years Old

JXTA is just about to turn 5 years old. Hard to imagine. Those internet years at 7 to 1 seem to be in play, at least with my memory. A lot has happened in 5 years.

I got involved with JXTA soon after it was announces. Anything with the mark of Bill Joy had to have something smart associated with it, so I jumped in head first. I quickly started writing applications and doing small things. I learned a lot.

Soon after things started, I got a call from Sams Publishing to do a book on JXTA. It was a difficult book. Though I had some experience, we were still struggling with how to best write P2P applications. P2P is not the easiest thing in the world. The idea of publish pipes and all that was not an easy thing to wrap your mind around. The ping example in the book went on for many pages - now I can write ping in one.

One of the key advances was simply an understanding of how to write P2P applications. One of the best is just the simplistic well-known-ID or WKI for lack of something shorter. For all the indexing and advertising, there are simpler applications of WKI that make it very simple to implement many P2P applications.

The JXTA spec and platform evolved too. The original version was painfully slow. Just connecting to the network could take a couple of minutes. Now average boot and connect to a JXTA network is a couple of seconds. Transfer speeds are also way up. The C version of the platform is also doing well and had a lot of heavy rewriting. Nothing better than a little refactoring, except more refactoring.

The protocol changed slightly, making up for some of the speed. The key advances were in how the Rendezvous worked. But it seems that a lot of things sped up with little changes here and there over a few years. None of this was without a lot of dedication from the platform team.

The next bit of advancement was the addition of a Socket wrapper for JXTA. One of the tough problems with the base API was working with an API that was unfamiliar. The socket API is very familiar and it is easier for the average developer to understand what's going on. The socket also hides things like reliability a bit better. There has been a lot of churn in the design of the code under the wrapper, but those changes are completely transparent.

The business viability of JXTA also continued to improve. I have been employed by several companies that were using JXTA, including many fortune 500's. I have also worked with several startups. JXTA makes sense for a lot of applications and businesses see that quite clearly. There are still a few things that big business needs like out of the box presence, identity management, and a true P2P database. We do have presence in our commons project, but there is room to grow.

The market for P2P is still growing and JXTA is still the only viable multi-purpose solution. Don't get me wrong, there is a lot of P2P out there, but mostly for file sharing and not writing business critical applications. The only alternative is Groove and that's owned by Microsoft. It also costs quite a bit. JXTA is open source and it is simple to set up your own P2P network for pennies on the dollar.

Where is the market? Where are the applications? They are in a lot of places from the military to telecom. I have consulted with a bunch of companies, plus there are many listed at jxta.org.

The latest startup I've been working with is called Kerika. They have a really cool tool that is best described as a graphical wiki. The workspace is sort of like a drawing tool mixed with the ability to add text, images, and documents but also relate them with connecting lines. The symbols can be clicked to reveal an even deeper view. Sort of like mind mapping, but this tools also adds collaboration and sharing to the mix. I think it is one of the coolest applications for P2P and it is written in 100% Java with Swing, but has its own look that is very clean and professional. They have just started their beta program, so the product is free, so check Kerika out.

Overall, it has been an amazing 5 years. JXTA is out in the real world and is doing a great job. We have a lot to grow. But that also means there is opportunities everywhere!

Quick Links

Kerika - http://www.kerika.com/
JXTA - http://www.jxta.org/
JXTA Commons Project - https://commons.jxta.org/
JXTA Company Spotlight - http://www.jxta.org/companies/companyarchive.html

Continue Reading...

JXTA in Belgium!

JaDiMo is a very cool application that can do various things from finding an open parking space to booking a hotel room. It is written with JXTA and Java plus runs on everything from cell phones to desktops. What is really amazing is the number of business use cases they cover. They have very cleverly moved from their original goal of finding an open parking space to multiple patterns of time/space availability and reservation like hotel rooms.

I spoke with Steven Palmaers of the JaDiMo project to learn more about their application and the future of the project. So, on with the interview:

First give a quick explanation of what JaDiMo is and why it is important.

JaDiMo is a research project at the XIOS Hogeschool Limburg (http://www.xios.be), which is an institute for higher education in Belgium, comparable to a college in the US.

The project is co-financed by IWT and some commercial partner companies. IWT is the Institute for the Promotion of Innovation by Science and Technology in Flanders and was established by the Flemish government in 1991. They have a yearly budget which they use to support companies and research institutes financially. The JaDiMo project is financed by the so-called HOBU programme, which primary purpose is to research new, promising technologies. The proposed projects can have different subjects, such as medics, biology and ICT of course.

The main goal of the project is to research the use of JXTA in combination with J2ME. Most of the use cases have to do with the mobility problem. There is for example a carpooling system, a system to locate parking garages in a city and a system to locate restaurants or hotels. Most of the applications come as a web version, a desktop version and a J2ME version (both MIDlet as Personal Profile). The main purpose of the project is to provide our partners with a proof of concept of JXTA and P2P in general.

Tell us about yourself and the team.

The JaDiMo project team consists of three people: Marina Luwel, Nicky Eichmann and Steven Palmaers. Marina is the project leader, she’s also a Java teacher at the XIOS Hogeschool Limburg. Nicky and Steven work full-time on the project. Nicky and Steven graduated two years ago. Nicky holds a BS in Computer Science and Steven holds a MS in Computer Science.

How did it all get started? What made you think of the idea and use JXTA and P2P?

As we wanted to submit a HOBU project proposal, we were looking for a new, promising technology to do research in. A Belgian Sun employee pointed us towards JXTA, which was quickly becoming popular at that time (late 2002, early 2003). So the sentence “in the beginning there was JXTA” pretty much sums it all up. Once we had our technology, we had to think of possible applications. We defined several use cases, which all have something to do with the mobility problem. We also decided to use J2ME technology, as we wanted our applications to be usable on mobile phones and PDAs. After we submitted the project proposal, a jury rated the different project proposals. The JaDiMo project was one of the projects selected. January 2004 we started working on the project. All HOBU projects have a maximum duration of 24 months, so the project ends December 2005.

One thing that struck me as genius was how many of the modules are very similar like parking slots and hotel rooms. Do you look for matching patters to fit your first module or did you design your modules to fit multiple patterns?

As I stated before, in the beginning there was JXTA. We then looked at possible applications that could be developed in a P2P way. The first application we came upon was our carpooling system. This makes it possible to find a carpooling partner in real-time, without having to go through a cumbersome registration process on a website. One of our partners is an organization that organizes carpooling, lift services and home exchange services. So our first application can basically be seen as an electronic, mobile version of their system. The difference however is that our application is ad-hoc. As soon as I realize that I need to go somewhere, I take out my mobile phone or PDA and can immediately find other people travelling to the same destination.

Most other applications are also concerning mobility. For example finding a parking garage, finding a hotel or restaurant. So as it turns out, most applications can be send as “search and get” applications, which happen to be focused towards mobility. But it would be equally possible to create a self-organizing P2P dating agency. In fact it’s maybe not a bad idea to make the core functionality of our applications publicly available at the end of the project.

Another application that we developed is a bus application, that can be used by the bus companies to send delays to bus stops, track different buses (using a GPS receiver), …

On your web page, you list a lot of partners. What are you doing with them?

The project is co-financed by the Flemish government and some partners. We have one scientific partner, the Expertise Centre for Digital Media (http://www.edm.uhasselt.be) which is a research institute of the Hasselt University (http://www.uhasselt.be). The other partners are commercial companies or public organizations with up to 50 employees. In general those companies don’t have a budget to do research themselves. So in fact, we are investigating a new, promising technology, JXTA in this case, on their behalf. After the project finishes, the partners are free to use the applications that we developed. They can further adapt them to their needs and possibly commercialise them. Other partners simply see our research project as a ‘proof of technology’.
Every 3 months, we organise a user committee meeting, where we give a presentation about the recent evolutions of the project and the partners can give feedback or make suggestions. We also organized two technology days, which are in fact free courses for the partners’ employees. One was about JXTA and the other one about J2ME.

Has working with the partners helped the development and commercialization prospects for JaDiMo?

The primary purpose of our project partners, as outlined before, is to provide feedback during the user committee meetings. Our partners also have the right to further develop or adapt our applications to their own needs and possibly commercialise them.
In Hasselt (a town close to our institution) people are currently working on a wireless city implementation with all kinds of services. There have been some initiatives from one of our partners to propose some of our applications as services inside that project, but talks are still going on.

How do you describe P2P and JXTA to your clients and partners?

As we are a pure research projects, we do not have clients. Since JXTA is one of the main subjects of our project, we describe JXTA to our partners as a solid framework to develop P2P applications. We also organized a JXTA technology day, were our partners’ employees could follow a course to learn the basics of JXTA. So our partners have a good understanding of what JXTA is and what its possibilities are. Most people we talk to, and tell about P2P, almost always think of (illegal) file sharing or instant messaging when P2P comes up. We try to explain them that JXTA is much more than that.

What are you currently working on with JaDiMo?

At this time, we are fine tuning most of our applications. We are also working on some smaller applications that use JXTA. During the last weeks, we have also been working on a system for ‘event pooling’. The meaning is to reduce traffic problems around rock concerts, football stadiums, … Our system will allow people to register on a website or by mobile phone and enter their details (address, car available, …). The system will then automatically match users and send an e-mail or a text message to their mobile phones. They can then travel together to the concert or the sports event and so help reducing the traffic congestion that normally occurs. This application will be commercialized next year by one of our partners. It will probably be launched together with one of the major rock concerts in Belgium. JXTA technology only plays a small role in this application.

What are your plans for the coming years for JaDiMo?

The JaDiMo project ends December 2005, so we only have a few months left. After that, the project partners can further develop our applications to their own needs and possibly commercialise them. Unfortunately there will be no further active development on the JaDiMo applications. We will however keep an eye on the JXTA community evolutions.

Are you looking for help or certain types of partners for JaDiMo?

Currently, as the project is about to end in a few months, the primary aspect we are looking at is finishing the project up. So we are not actively looking for help.

What gets you excited about what you are doing with JXTA and P2P?

When we first looked at JXTA we didn’t really have a clue about what it was and what its possibilities were. Now, almost two years later, it’s amazing to see how many people are involved in the JXTA community and how much interesting applications are being developed. I hope that by working on our project, we can help to make JXTA more known in Belgium, and to prove that P2P is so much more than illegal file sharing. A lot of people just don’t realize that P2P can be applied in a lot of applications and domains.

Are you working on any other projects besides JaDiMo?

Currently we are not working on another project. However, when the current project ends, we are starting a new research project, again for 24 months. The (long) title of this new project is ‘OSGi as a framework for context-aware monitoring and updating software for mobile and embedded systems’. The short name will be OCoMIS. This project is in collaboration with the Expertise Centre for Digital Media, our current scientific partner. The primary purpose of the project will be to research the practical use of OSGi (release 4 specifically) combined with interactive television, mobile devices and domotics.

About the interviewer: Daniel Brookshier is seasoned Java veteran that is now a P2P/JXTA specialist. He has written several books on software and is currently working on a book about P2P patterns. He is on the board of directors for http://www.jxta.org and runs the P2P user group in Dallas.

Chinook: P2P & Web Services platform for Bioinformatics

Chinook -

http://chinook.dev.java.net/

I love it when a good P2P project using JXTA comes my way. This time it is Bioinformatics and JXTA. Project Chinook has just graduated from the incubator at Global Education and Learning Community (GELC) of java.net. The project's new home is the GELC research area. Let's take a look at it and talk to the project owner to learn more about what this project is about.

Chinook is a peer-to-peer (P2P) bioinformatics service. The goal of the Chinook platform is to facilitate exchange of analysis techniques within a local community and/or worldwide. Chinook operates by turning command-line applications into services which are broadcast over a virtual network. Currently, there are over 25 analysis services that have been made "Chinook-ready". These range from alignment to regulation prediction algorithms. Furthermore, Chinook is designed to make it extremely easy to add new services.

Chinook clients can be operated from Java, Perl, or within applications like Sockeye. (And soon Pegasys, and OrthoSeq)

I asked the developer(Stephen Montgomery) about how Chinook was built. Here is his colorful and informative response:

Arghhh.... you are also asking me how Chinook was built. Well, for half of it, I ate some hallucinagenic chili peppers and ended up extreme programming in the mexican desert with my spirit guide, Duke. It's all about the test cases, man ;) Anyways....

The best I have for a general overview is the architecture diagram http://www.bcgsc.ca/gc/bomge/chinook/images/chinook-arch.png And then there is a user guide (the latest one comes with the installer)

Basically, for the P2P though, I just have a PeerGroup called Chinook. Under it are two different MSA advertisements (one for web services implementations and the other for RMI implementations). Users pick up the associate MIA for these MSA which has the URI of the server specified (either http://foo:8080/axis/services/ApplicationServerImpl or //foo:1099/ApplicationServerImpl) and then they talk to the server using either web services or RMI. I had to build a bunch of utilities to maintain state of jobs, the size/frequency of uploads and downloads, etc. etc. But everything is configured using XML under the resources directory.

For connecting Perl to Chinook, I just use standard sockets from the client to pass rudimentary messages to and from a client instance between perl modules and then send off the job/process the report.

For services, I am building a wizard to help server peers install new tools (it is about 75% done). And then I will package them with the installer for RMI mode only.

I used your book a lot back in the day to figure out what this whole JXTA thing was about.

If you are interested in Bioinformatics or JXTA, take a look at project Chinook and the Chinook home page. Also, if you know of any projects using JXTA, let me know.

JXTA Yields an Application for P2P Backups

JXTA^TM For Business… Proven!

Well, I keep saying that JXTA^™ is where business needs to go to make a buck. Companies are indeed listening. 312 Inc. has just released a new JXTA product called LeanOnMe. LeanOnMe is a Peer-to-Peer off site backup tool. Simply, you choose the files you want backed up and choose another computer in the 312 Inc. peer network and your files can be backed up on demand or any time you specify. Of course you can also recover your files and all you need is the software and your password.

I’m all for backup. It is just hard to do. I was in Orlando last week for Hurricane Charlie. Lucky me. But my critical data was backed up despite the trees being snapped in half by the wind. But my data was backed up.

Caution: I work for 312 Inc.

Before I continue, under full disclosure, 312 Inc hired me to do some consulting. So I could profit from you buying this software. I won’t get much, but some, just the same. I am biased toward LeanOnMe and my friends at 312, so take this all in with a dose of salt and by all means, question my motives. It is more important to me that you understand that this a real live JXTA-based, 100% Java, Swing application. Buying a copy, more than helping me, will help LeanOnMe be a success, and thus helping JXTA be a success by proving P2P applications work. But only do it if it makes sense to you. Only you can know that you can’t live without a product.

If you like the idea of P2P backups, you can download the app and try it for a while for free. If you want keep on using it, use the discount code 312sun and you get 10% off. Like I said, I’m not as much interested in you buying than I am in you seeing that P2P and JXTA are real. Buy it or not, please try it to see how well JXTA performs.

I just want to talk about why JXTA was a good choice for this application. I'm pushing JXTA here. If you think LeanOnMe is cool too, tha's just a bonus.

JXTA and Backup

So, what makes LeanOnMe really different because of JXTA? Most backup systems use either a local tape/disk or an off site server. This system uses another computer, any computer running LeanOnMe software. That's 'any computer. and 'anywhere'. By using JXTA, 312 has avoided the problem with centralized systems and taken advantage of terabytes of unused storage. But there is more to it than that. There are indeed terabytes of unused servers all over the world left over from the dot bomb.

Why use JXTA? How does it work? How well does JXTA work in this model? Read on.

Why JXTA

First, why JXTA? The first reason is simple enough: JXTA provides the ability to find a specific computer anywhere on the internet. Another reason is that JXTA is stable and fairly quick now that we have reached JXTA 2.3.

JXTA is also general purpose. Unlike many other P2P systems based on file sharing, JXTA is communications based. Anything can be communicated, including encrypted backups or their status. Unlike file sharing, random replication of files is also not desirable. You only need a few copies and you need to know specifically where they are to recover them. There is also a need for a protocol specific to the application to manage the files. JXTA’s Pipe approach does not constrain communications and thus any protocol can be applied.

JXTA is also open source. In part, open source has made it possible for people like myself to understand a lot of the code and how best to use it. I won’t say I am all-knowing. JXTA is complex, but my knowledge has helped the development process. Open source has also helped because I have added a few pieces to the system, including the BinaryID that is used in the LeanOnMe application. The system uses the BinaryID to create a well-known-ID to connect pipes quickly with existing data about peers.

JXTA is also easily customized. In this case, 312 has created an isolated peer network. By isolating the network, 312 has further created a safety net that adds to security.

This is just the first version of LeanOnMe, so there will be many features added in the future, but the application is very solid and very familiar to anyone that has used a piece of backup software. Because it uses the peer network, adding innovative P2P functionality will be a breeze. This means some freedom to the developer too. For example 312 can add chat, workgroup management and almost any other network feature you might need. And more importantly they can add the feature without adding server infrastructure.

How Does it Work?

So, how does it work? First, in the first version it is not 100% P2P. There is a server component. LeanOnMe uses an LDAP server to keep track of where backups are stored. A couple of reasons for this are that you can recover because you can locate your backup through the data in the LDAP. Secondly, by controlling access to the LDAP, 312 can also ensure you are who you say you are. So this centralization gives your security and 312 a little control. Everything else is P2P.

Some more interesting aspects of the way the system works is that it uses the same presence mechanism as JxtaNetMap . Essentially the RDV reports peers entering and leaving the network on a propagation pipe that that all the peers subscribe to. This allows the application to know what other peers are available and online.

As for file transfers, 312 rolled their own and used the BiDiPipe for the transport. They have great features like the ability to restart a file transfer if there is an error. It’s fast too! If you have good bandwidth it is far faster than tape or some of the slower backup media.

Backup Security

Security is important in a P2P application. First, data is going to computers that you may not control. Secondly, there is no isolation from listeners. This is the internet, not a happily isolated corporate network. What did 312 do to make sure data was safe?

The security is interesting and seems airtight. There are two passwords. One key is used for access to the system and one for your key store. If you have these, you can unlock your files even if the original computer is totally destroyed. If you have your original data on a laptop (read easily dropped or stolen laptop), this is the kind of access you need.

Of course, the backups are encrypted. The act of encryption and decryption is done on the source computer and via the passwords entered at runtime. The result is that there is no spreading of passwords required. It also means that the computers where these files are stored do not have access to the keys. This prevents your friends from snooping around in your data.

But backups are about the source computer too because it can be destroyed, so we need an independent way of accessing our data. By having the mapping data to where our data is stored in the LDAP (with its own backups), even with all our primary computers destroyed; we could still locate and access backups. Yes, a centralized vulnerability, but it makes sense in this case. It is a minor convenience to keep the LDAP backed up and highly available compared to doing the same thing with a high bandwidth data storage center.

A second aspect of security is that of the warm fuzzy of trust. Because this is P2P, you can choose any computer. So, we can choose to back up to specific computers and thus to specific people. So I can back up to my friends and family’s computers because I trust them. My friend or my own computers certainly have a little trust than I can put to the average person. Even with an encrypted backup, some would like that extra security blanket or knowing the person that owns the equipment where important data is stored.

The third piece of security is communications. LeanOnMe uses JXTA's encrypted pipes to ensure that all communications are hidden from prying eyes. But why encrypt communications when the backups themselves are encrypted? This is just protecting the application itself. By encrypting communications you are hiding the protocol and the specific actions. Call it paranoia or being prudent, it certainly does not hurt.

P2P is Greater than Client/Server

The story here is that P2P with JXTA has provided a solution that was not possible before. The P2P model creates the opportunity and JXTA provides the possibility. Add hard work and a good design and you too can succeed with JXTA.

But what really changes when you move form client server to P2P? The first is freedom of choice. In the client/server model, there is only one place that the files can go. With P2P, the files can be located on any machine or even multiple machines. The freedom means that you not only can ensure that your data is in Idaho when Florida is hit by a hurricane, but also on your desktop and your laptop.

P2P also means that the applications still work behind your cable modem, NAT, and firewall. The evils of IP being changed by DHCP are also eliminated. Simply you can get to the computer with the backup data. This increases your freedom of choice. Back to your home PC and your laptop. Without JXTA’s ability to cross the cable modem boundary, you would not be able to access your data on that home PC if you were on the road.

P2P Does Not Need To Be Pure P2P To Work

LeanOnMe is using JXTA , but it is also using the LDAP. That’s not pure P2P, so what’s the point? It could be solved with a distributed system but in this case the data is probably better centralized.

Not all things need to be P2P. As it is, 99% of the work is P2P so the cost of the LDAP server is low for 312. Secondly, the scalability is much higher with less equipment. With 99% of the traffic between peers, the network scales itself as its members are added with their own resources.

Swing Scores Again

Another aspect important to developers is that it is written with Swing. I am a Swing advocate. I have used Swing since its early betas and because of my knowledge do not cow the rumors that it is slow and complicated. These rumors are once again put to the test. The interface is fast and looks great. It is successfully running on my Apple PowerBook and my dual processor G5 along with other machines running Linux and Windows. Stop bashing Swing, here is another example of a great application done right. There are hundreds of other Swing applications, including NetBeans. Nothing wrong with Swing in applications as I see it and as is seen by thousands of other dedicated Swing developers.

P2P is Greater than Client/Server

I have talked a lot about the aspects of why backup works in P2P and a little about the foundations of the application and how it uses JXTA . The warm fuzzy you should get is that JXTA is something that you can depend on to create a business on. Though 312 is cornering the P2P backup space, there are thousands more applications that can use JXTA .

You have fewer excuses now. JXTA is ready for prime time. Get out there and write something we will be proud to call ‘JXTA Connected’.

Java == platform independence
XML == application independence
JXTA == network independence

Save P2P by stopping the INDUCE Act.

I just received an email from Ray Gao of P2PJournal.com. Apparently the lobbyists are at it again. This time your MP3 player is at risk. This also opens the door to a lot of other anti-P2P shenanigans from other companies. The INDUCE Act is just plain bad to the bone.

But first, let me say that I am 100% legal. I don't steal music. I buy a lot in fact (you gotta see my iTunes bill). Stealing is stealing. But the music industry wants to stamp out fair use. That's why I am hot about this issue.

Please take a look at this anti-P2P bill currently being proposed at the congress. And, sign the petition oppose it. Tell your congressman that this bill should not become a law.

I just sent a free fax from the site urging my reps in Congress to stop the INDUCE Act. Convincing even a single Senator will force a real debate on the bill.

Check out: www.savetheipod.com which will allow you to fax congress with a few clicks (I used auto form fill on my browser to do most of the work).

www.savetheipod.com has more info about the INDUCE Act and a form to fax your Senators and Representative. It only takes a few seconds to send a fax and it is really important that we respond to this legislation quickly.

Take a look at www.savethe.com for more information and details on the lobbyists and specific congressmen that are paid to be lobbyists lapdogs.

JavaOne - Day four - 4 - IV - t-shirts via P2P and bling for java.net users

The awards were given out at the end of the main session today. The winners were "The Cyclists". I got to speak to the developer of the software. Silly me forgot to write down his name, but he can be reached at mrjava @ sprint.com and the web site is www.observeit.com (site is not up yet).

As Gosling said, the winner was built with a lot of weirdness and imagination. Here is the list of technology involved:
o J2EE web server for audience participation and media server to relay server link establishment.
o Java Applet for real-time sighting video display
o J2Se Swing app(media server) for graphics and sound rendering.
o J2Se bike relay server - off - bike communications
o Dallas TINI Java Controller = sensors and actuation or the drills A.K.A poor man's servos and light controls.
o JavaCard iButton computer thrown with t-shirts for Java enabled camera phone giveaway.

But there was more to the details! There were two computers in the system on stage that communicated via 802.11 back to the man server to find the IP address of each other. This is the poor man's Peer-to-Peer system. What happens is that the each PC calls the J2EE server (at the developer's house) to get the other peer's IP address. Just before they rolled out, the 802.11 was overloaded by all the attendees and in the last few minutes before they rolled out, they had to rewrite the code to use a hard wired connection that was hastily wired to the computes on the bike. With five minutes to spare the code was patched and tested. Not knowing your IP address is a bit worse than having the chain break (actually it was the master link on the chain that was popped off by two desperate competitors in front of a live audience ). I could not help with the chain, but I did sugest he use JXTA instead of the home grown solution. We will also host the code at Java.net in the Java Education and Learning Community.

I was running around with Bruno (the fellow from Brazil with the Brazilian flag cape and who runs the Java user group community on java.net) and met some guys that will donate free installation software to the Java.net community. No names yet, but look for an announcement soon.

Finally I talked to a fellow from a mining company. They use 802.11 to communicate between their heavy equipment. They have problems communicating and managing their various devices. We talked about JXTA as a solution. Looks like a lot of their problems and allow a multi-ton earth mover to call the office for an oil change via JXTA P2P. Look for JXTA in applications like this real soon.

JavaOne - Day Three - More friends, JXTA, epackaging of an app server and open source

Greetings!

We can't solve problems by using the same kind of thinking we used when we created them - Albert Einstein

I got to attend Brad Neuberg's tech session on P2P Sockets and Paper Airplane. Paper Airplane is a Mozilla plugin written with JXTA. It is a great example of extending a known metaphore into the P2P world. Brad talked about a shared Wiki and other services like SOAP via the JXTA network. Check out http://p2psockets.jxta.org/ and http://paperairplane.dev.java.net/ for more info. I really think this is a great way of doing things. There is a freedom from servers and a freedom to communicate. There are a few things to work out, but Brad has a lot of great ideas in this area that need to be explored.

Email==Face

Got to meet more people today. From the JXTA community, to my book readers, to business customers. Most I have never seen or talked to except via email. Some of these people have been emailing me for years and this is the first time I have seen them in person. JavaOne is getting to be a watering hole where everyone meets. Forget the sessions, it's about meeting the smart people of the world in person.

UML

I also got to teach a short class on UML today for NoMagic and ExitCertified (Sun's education partner). I had room full of people willing to learn UML and we had some fun too. Speaking of UML, I overheard someone say that the white-board is the best place to do UML. All I have to say is that is misleading. Using a white-board to think about a design is nice, but you need to capture the design for the long run. A white-board can't be emailed to your customer. A white-board can't be filed away to be referenced years later by a maintenance developer. You can't edit the same white-board to change the design over the course of ten years of maintenance. Use tools, free or otherwise and be a professional.

Creating an Artificial Einstein with JXTA

One of the more visionary people I met today (well... yesterday because it is now 2:00am) was Jeff Zhuk of ITS Inc. Jeff is using Open CYC and JXTA to create a distributed knowledge system and expert system. How cool is that? I have done similar things, but Jeff is going for a massive solution that integrates thousands of people to build an expert system via peer to peer computing. In addition, Jeff teaches Java, JXTA, and JINI. He has all the pieces and is looking for help.

Einstein and Java Enterprise Server

Spent the morning at Sun looking at Java Enterprise System (JES). JES is a new way to deploy and license the infrastructure of an internet business. Sounds innovative, but I would say it just shows that there are finally some smart people at Sun thinking about doing things right. JES is built on the idea that most portals are really built of a dozen or so applications like the portal application framework, web server, application server, calendar, email, instant messaging, LDAP, single sign on and many others. All of these pieces are usually put together one at a time and with a lot of work dedicated to getting them to actually work as a single unit. My past is littered with the with the wasted and long hours or complete failures because of applications not mixing well. What Sun has done is create a clean integration of all of these tools that runs smoothly and is tested as a unit to discover integration problems. The end result is a lot of the core business software is up and ready to use in a few hours. Think about the Integration of all the software components that make up the infrastructure. They are like building an airplane from little pieces and a blueprint. Instead, JES is a fully assembled and tested Lear Jet.

Like I said, not really innovative, but it takes a lot of work and politics to integrate all your standalone products into a single install, with a single interface for management, and one application to license, and get maintenance agreements on. My hat is off to the guy that proposed such a departure in the Sun way of doing business.

But now to the second part of the innovation of JES that might give JBoss a run for their money. The JES set of componenets in the common install management tools is available with a cool procing model. Think about having it all with a portal application framework, web server, application server, calendar, email, instant messaging, LDAP, single sign on and many others for just $100 a year per full time employee. This is just the business model for pricing and not some magic number that is part of the CPU count, the number of gigabytes of storage, email accounts, your first born child, and a chariot that turns into a pumpkin at midnight. The key is that this is just a way to price the system, it is not the price for the number of actual users. This just buys support for the tool and your software updates.

This is more cool and obvious if we look at a company that has 100 employees for a cost of 1000*$100 (it is free up to 99 employees but there is no maintenance). Now even though the company bought the 1000 employee license, they can have a million customers and their 1000 employees use the system without any additional costs(except for the pesky hardware). A good example is Google with 5,000 employees and 7 million customers would only need to pay for the 5,000 employee license. The economies of scale look like open source with maintenance.

The tools are all based on open standards, not open source. Seeing and modifying code is not an option. But when you have a good maintenance agreement, the risk and cost of maintaining open source verses a maintenance contract is about the same or better since most of the components are usually used as is and not customized. Because they are tested as a suite, there is even less need for the IT department to be fiddling with code that should be considered infrastructure rather than custom applications. Of course this is still a modular system and you can swap out almost any piece with an open source or commercial alternative (like the application server).

Is Sun really a winner with JES? Hard to say at this point. They have happy customers so far with the first release and a model that is hard to ignore. The application server and all those component parts are newly rewritten and running fast and seem scalable. They could be a market leader in their own J2EE market. Really! Stranger things have happened. Stay tuned.

One more day

One day to go here at JavaOne. Time to pull out all the stops and meet as many people as you can and collect ideas and business cards. Make friends, learn from them, and help them as much as you can. We are all in this together and we are a community. Get out there and make the Java world a better place!

JavaOne - Day Two - The Rise of Buzz

Today we got to see the sunny side of Scott McNealy at the keynote today. I have to admit that I like to hear that man talk. The key thing that he said that got my attention was that there were 14,000 developers at JavaOne. That is almost like before the crash! Almost everything but the requisite T-Shirt lofting at the end of the talk was just icing on the cake of the Java economy(the T-Shirt lofter self-destructed after 3 shots - but it did look real cool). Even making nice with Microsoft is less a happening than knowing that the developer community is thriving. If you can afford to go to JavaOne, there must be some money in the economy.

Tonight we also had our meeting of the minds for java.net. There were a lot of people there and the conversations were loud and hard to stop - even when we announced a few cool prizes. I heard lots of talk about opportunity knocking. There are a lot of new projects out there and a lot entrepreneurial work too. With a down economy the smart people are replacing the defunct companies. I heard of a lot of people making their way in small businesses with cool ideas. I was able to show off a few of mine too like 312 Inc's LeanOnMe P2P backup software, Quantum Chess (a P2P chess variant), and Venezia-Gondola (P2P ebay killer) all written in JXTA.

I also heard a lot of talk that Java technology is getting bigger and better. As an example, JXTA is now faster and easier. Tools and techniques are also improving. I also saw that Java is still bigger than you can absorb. There are a lot of API out there for all sorts of applications. Thank goodness we have Google or we would never find these great tools and products.

Today was also another day of meeting people. I must have met 30 people that know me, but only online. It is always a surprise to find that nobody looks like their smiley faces :o) I am amazed at how conversations always turned to business or succeeding with Java.

Education and Java started to become apparent today. I met several people form different universities. There were students and professors, all seeming to be working on very cool projects.

More to come. Tomorrow there is a JXTA session and a BOF. I'll be at the session and might make the BOF. I need to share my time with the NoMagic folks( makers of MagicDraw UML, a 100% Java UML modeler). If you are interested, I'll be teaching a short course in UML Wednesday night and will be signing copies of my JXTA book. Come by the NoMagic Booth and sign up, we have only limited seating.

Stay tuned! Two more days to go!

Killer Applications and JXTA

Serial Killer Applications

Some technologies don't gain wide adoption until there is an application used by a large number of users. We call them killer applications because they are so compelling or in fact kill a problem dead. For the personal computer it was the spreadsheet (Visicalc was the first and it was copied by the rest) and at about the same time, the word processor. What will be the killer application for JXTA? Is it already here?

P2P & File Sharing - Capture and Death of a Serial Killer

Napster was a killer application. Sadly it was done in a way that was not legal. I won't go into the politics of record companies and free speech - the fact is that Napster was taken out of play by the courts. Yes there are other music sharing and purchasing applications, but nothing as big as Napster. But the other problem is that it was only about music (at least the killer part). There was no real big application associated with general business or entertainment based on the P2P/Central-Index scheme of Napster.

Don't think that there are not other file sharing applications doing quite well. In fact, there are file sharing applications written in JXTA that support thousands of users in legitimate business applications. They may become the new 'next big thing' but I see it as just a better way to share files rather than the ultimate killer application.

People Like to Save Time and Effort

Sometimes a killer application just makes things easier. Struts is making it even easier to develop web applications. Ant makes it easier to build and maintain projects. XDoclets reduces labor via its code generation capabilities. All these examples are starting to be widely adopted because of their productivity improvements. Can JXTA make things easier?

JXTA has all the hallmarks of reduced effort. First, there is no real server involved. Imagine the time, money, and sweat equity saved by not dealing with the monolithic server and its support system. But that's just economics - where is the savings for the common man? Let's look a little at one of the key ideas about JXTA.

It's a Candy / It's a Breath Mint

What makes JXTA unique? It's not about Peer-to-Peer (P2P). P2P is just a fuzzy buzzword that means computers talking to to computers. What abut JXTA is that it places the Internet inside applications rather than the browser. This also means the gestalt of the application includes a real interface, storage, and can be run 24 hours a day if needed.

The quote below is from Juan Taylor, which covers this quite nicely:

What this means simply is that unlike client server, JXTA is client/server and server/client or even server to server or client to client. The information, storage, processing, and communications can start at either end. In the world of applications this also means that I don't have to work in a world of centralized resources where there are multiple issues. The worst problem of course is just the impedance mismatch between the world of application and the world of web applications.

Are You Thinking Differently?

So, what if every client was a server? Sadly it is not all about efficiency. I say sadly because P2P is all about wasted space and CPU cycles. The sad part is the knee jerk reaction many have to waste. But the fact is that replicating data and the power of your own CPU verses a shared server is far safer and can be orders of magnitude more efficient in getting the job done. The waste is insignificant in terms of the modern PC with their large disks and often idle CPU's. When you trade inefficiency in an area that is monetarily insignificant, the gain in productivity is essentially for free.

P2P Forum

The forum interface is similar to those on Java.net. Basically a forum is a threaded discussion. The oldest version of this is the old news forums which still exists but has been taken over by spam. Think of it as a server based email that anyone can read or submit messages.

What would a P2P Forum look like? First the history of the messages need to be available to anyone. This a great feature of the forum because it lets you search for a conversation in the past. Guess what, that has to be on a PC since there is no server. Here comes the duplication of effort: To make this work, keeping the history on as many computers as possible increases the speed of the search. The search is really fast if you have your own copy. If the forum history is very large, and is bigger than that free 5 gigabytes on your disk, we can share different sections of the data. We still need a lot of copies because some peers may go off line.

Thinking until it Hurts

Ok, does it hurt your sense of efficient computing yet? I remember being unable to use linked lists and hash tables for years because my professor in college was so anal that memory was the most important thing in the world. He put speed and ease of use far far down the list of importance.

Waste or efficient use?

Ok, now back to killer applications. What if we added a P2P forum to a development tool? First, because it is part of the tools, the focus is like a laser. The efficiency of use is very close to the tool because it is the tool. Have a weird exception? It is a click to add it verses cut and paste and a little reformatting. Wondering what the correct settings are for a task? What if the expert could reply with his settings which you can just use rather than interpret a poorly formatted and worded answer. Yes I have perhaps a couple gig of messages, but I have the world's greatest integrated help system. These ideas are Copyright Daniel Brookshier 2004, all rights and derivative patents can not be used by Microsoft or its agents. Free use to those that use 100% Java and JXTA to implement the solution. Ideas like this need to be free to make life less like walking on broken glass.

Killer Instinct

JXTA is a killer capability that will make a good application a great application. Making every a PC a server seems like a good idea. Not every solution will benefit, but there are a few thousand new ideas that JXTA makes possible. Look at the world upside down. Be the server.

Peer-to-Peer, JXTA, and Making a Lot of Money with Virul Marketing

.

Viral Marketing with JXTA

Viral marketing is a concept used in marketing and sales that describes how adoption of a product occurs and how it can be coerced to spread like a virus. Very simply, viral markets are those where one purchaser infects friends and acquaintances with their enthusiasm for a product or other wise causes them to use the product because it is required by the first person. Viral markets are coveted because they can create huge profits in a very short time.

The Viral License

With most software, you buy a single license. If it is a networked application, you can only interact with people that have bought a similar license. In open source, we just download the application, so there is no barrier caused by reluctant buyers. If you look at all the network applications that are widely distributed by commercial companies, they are all free to avoid this same problem. For example the chat applications like Yahoo, AIM, and MS Messenger. But what about commercial applications? How do you get people to buy enough copies so that there is a large group of interconnected users?

An alternative to selling a user a single license, is to sell several that they have the right to distribute to acquaintances, family, and coworkers. For example, have 3 to 5 licenses as your standard package rather than just one, In fact, never let a customer buy just one copy.

The Power of Giving

You are more likely to install a piece of software if a friend bought you a license. It is a gift. People accept gifts. Compare this to a single license. If your friend buys a chat program, you must also buy a copy to chat with them. That’s not a gift, that’s a burden that your friend is imposing on you. You will resist purchasing a copy because it is not your idea and the chat application may not interest you too much. As a gift however, you will willingly install it and try it out. If it does turn out to be useful, you may buy a copy for your other friends.

This type of license is a great way to push the other products because it only takes one person to bring in many others who in turn bring even more. This also improves the local share networking by getting the original licensee to get his friends to install the product as soon as they purchase it. That way network optimizations happen during installation. You can up-sell the secondary licensees by disabled functionality or just let them add 5 packs to share with their friends for a few bucks a pop.

Let’s look at the economics. This is buying in bulk, so the prices are smaller. Who is doing most of the work, the buyer. That means you are not working to sell 5 licenses for instance, instead one license pack to a guy that has 5 friends or coworkers. In fact those other licenses are possibly going to people that would never use the product and would probably not buy a license for themselves. But not you have 4 guys for the effort of one, You also have 4 people that have more friends. Economics? The economics are the cost of a single transaction for 5 users and free marketing. Of course, this also means there are possibly 4 people that know 4 people “each” or 16 people. Those 16 know 4 each for a total of 64 which leads to 1024 users and so on into the millions. That is a lot of sales for the infection of just one person if the application is compelling enough. That is very economical on a grand scale!

Small Worlds

This a model described by the small world theory. The world is made up of a web of interconnected people. Simply, the network of relationships links us all together. But small world theory says that the links between any two people averages out to about 6 hops on a chain of people that know the prior and the next person. The implication is that given something that can travel this network, the entire network will be saturated very quickly. If the whole world is connected by an average of 6 steps, I should be able to sell to the entire population after reaching 6 steps away from my original buyer.

A Real Virus

It is the same for very virulent contagious diseases. The more contagious, the faster it will infect the population. The fact that a large number will be infected is caused by the network which passes the disease from node to node or person to person because of the relationships whether it be friends, coworkers, or even customers and clients or merchants.

We can take advantage of the interconnections and the forward purchase of licenses to walk the network of relationships to populate the network based on the one-to-one connections between people. This also ensures a purchase for a group by selling to a singe person rather than having to sell everyone. Once the other users have it and are addicted, they buy licenses to interact with their other friends, family, and coworkers. By having a license pack rather than a single license, the network can grow at an exponential rate because it forces adoption both by original seed purchasers that were not a part of the network and by those that are given a license, but buy more to expand the reach to their own circle of acquaintances.

Did I mention that I study marketing, sales, and persuasion psychology along with P2P and JXTA? To survive in today’s economy it helps to think like Leonardo DaVinci. This is about leveraging a small set of facts to create a larger truth. And like many of DaVini’s inventions, the solution is based on a study of nature,

Viral Ideas

The world is a network. JXTA lets you write applications that live in the network. Always keep in mind that the power of P2P is not just about the improvements for users, but the improvements in how you can use that very same network to grow its self.

As part of your social network, you now know who I am and how I think. Ideas are infectious. Pass this one on and tell your friends that Daniel says, hi.

Daniel Brookshier is a freelance technology writer and JXTA Consultant. Daniel can be reached at Turbogeek@cluck.com.

Education And Research Community at Java.Net

Introducing the Education and Research Community

Java.Net is a very big place on the net nowadays. There are a lot of communities and hundreds of projects. But what is in each community? Why would you host your project in one or the other? Today I am going to tell you about one of the Java.Net communities I manage, Education and Research (E&R).

But first, Education and Research? Why? In part, education needs software too. There are actually many open source projects developing software related to education. Some of the older projects are beginning to migrate to Java.Net to take advantage of the community and services provided here. But there is more than software for the sake of education. There are also projects related to student thesis and school projects. There are also many researchers that need a space to work with their peers in an open way.

Face it, we have good tools, a great overall community and its all free. Why not support education and our researchers that need all the help they can get?

This community is used by students, teachers, and individuals to create software for all aspects of education and learning from classroom management systems to teaching tools, to hosting projects of students for projects and thesis work. We also host tutorials for learning various subjects, authors post their code and sample chapters for books, and we also host academic research and thesis work.

This community is also important for collaboration between educators, students, and developers of educational software. We host discussions and areas for exploration important for learning or exploring new ideas and new technologies.

Why Host a Project in E&R?

E&R is definitely a loose community as far as projects go. We focus on education, so project here relate to schools, students, educators, or even the ongoing education of developers and managers. So tutorials, code examples, books, educational software, school management, testing, etc. can all be hosted or found here. We cross a wide range of the other communities from J2EE to Swing to Linux. As long as it is related to education and research, you can see there are advantages hosting in a community of teachers and students.

But why not another community? Why host a JXTA tutorial here when there is already a JXTA community? Simply this area is the place to go to learn just like a school is a place to learn. If you are hosting a new project you will have the tools to create and manage learning systems for new projects. We will be cross-linking the communities so that the core community has a link to the educational community hosting its tutorials. This way we can concentrate on the education aspects of a project as a whole plus get help from the experts in the subject community.

Another reason to host your project here is if it is highly experimental. Trying to refine an algorithm, experiment with different designs, implementing a new type of user interface? E&R is open to the educational, the new, the cool, and the strange. Math, science, the arts, and other subjects that we associate with academic and scientific endeavors too.

Project Areas

There are a lot of subjects in education and even more in research. To create a sense of order, we have divided the E&R community into several project areas. See if you can find an area or a project in that area that fits your needs and interests. If you have a project proposal and need a new category, let us know.

Community Leaders for E&R: Dr. Robert S. Stephenson, Daniel Brookshier.

Dr. Robert S. Stephenson
Community Leader - Education & Research at Java.Net
E-learning Architect
Assoc. Prof., Biological Sciences
Wayne State University, Detroit MI
http://www.science.wayne.edu/~rstephe
rstephe@sun.science.wayne.edu

Daniel Brookshier
Community Leader - Education & Research at Java.Net
Author - 'JXTA: Java P2P Programming'
Editor: P2PJournal.com
President JavaMUG
Director on the Board of JXTA.ORG
turbogeek@cluck.com

Is JXTA Exciting?

JXTA - Is it important or just cool?

Software can be a bit boring. So where do we get our jollies? What is exciting in the software world? Well, we can all take up skydiving while doing code reviews** or we can use a new technology. Its hard to say why 'new' holds such a fascination for most of us. When a new technology saves us time or money it has a lot of pull. But something that can save time and/or money "and" be cool, well it just warms our hearts.

JXTA is new, gives us access to both the technology and to resources to use it at a price as good as free beer. JXTA is also a brain teaser. If you move away from the comfortable home of the application server to the edgy resources of the personal computer, most ideas don't survive. JXTA requires intelligence, creativity, and invention. Now that's exciting.

Application servers change things a bit, but they can't be used to develop for fun, research, small business, or even a charity. There is too much to pay for between hosting, bandwidth, support, and the hardware. Yes, you can do some web apps on the cheap, but not easily and often not easily scalable. JXTA goes the other way, so it is at least more accessible.

I don't want to learn another damned API. Really? Are you dead? Lazy? A traditionalist? Or are you 100% sure that what you are doing is going to be a marketable skill in five years? About the only legitimate excuse for not learning a new technology is time and resources. Since JXTA does not require that you have anything more than just your PC and perhaps those of your friends, it has no barrier to entry. That leaves time. The only way you get time is to make a priority and put something else off for a while. I think JXTA is important enough, but you need to make that choice for yourself.

I have called JXTA a revolutionary technology. It is like the first personal computer (mine was an Apple II). Before the personal computer appeared, software was written by only a small and privileged few. The reason was that computers at the time cost as much as a house. But with the personal computer, the number of programmers exploded. Compare JXTA to web and application servers. JXTA needs little or no investment to create useful applications. Web an application servers need hosting, hardware, bandwidth, and the costs increase as you scale (it is much cheaper to do so, but the average hobbyist can't afford a simple site).

Some architects recommend that you should develop with the least complex technology possible. Others recommend minimalist designs or least complicated methods too. How would JXTA fall into this?

JXTA is less complex then web apps because it removes or reduce the complexity of multiple languages(Java, html, JavaScript, etc), browser incompatibility, and the web infrastructure of servers and data centers. JXTA can use a real GUI (Swing, SWT, or AWT), which can save a lot of development time. There are also many more resources because of other computers in the P2P network. The downside is increased latency for some types of data and in many cases a more complex distributed design. Counteracting the bad is reduced equipment and reduced interactions between the pieces (like interfaces between html, srcipts, XML, and Java).

Sounds like JXTA uses less technology and reduces the touchpoints between them. But is there less code and a simpler design? Jury is out on that one because complex applications have not really been analyses. For simple applications it seems like there is less code.

New technology is sometimes a moving target. JXTA is no exception. The direction of change is toward less complex and easier to use. Some of the churn is also in how we design with JXTA. Turning any paradigm on its head is going to keep you on your toes for a while.

JXTA developers also need a lot more than the API. JXTA at is core is just a protocol. It is not a turnkey business solution. But that's another reason to lust after JXTA. There are a lot of important things to do, from crafting unique frameworks to modifying existing ones to fit a JXTA and P2P environment. Building a business solution with JXTA is still a job for a fabricator. It takes a craftsman to make his own scaffold when things get complex. What really makes this fun is that the solutions are like no other.

So, is JXTA fun? Yes! Is it hard work, yes again for some things. Is it good for your business? Yes, because despite some extra time developing, the benefits of P2P, and the reduced costs are enormous and they add up over the lifetime of a product.

**Most companies don't do code reviews so life is already exciting.

If you already know about a P2P service, is that bad?

They have been lead to believe that P2P applications should not start with any information and should only be allowed to discover things in the network. They fell in love with the idea of discovering treasures by looking in hidden places. Hard to tell if it is wunderlust or just an old idea that stuck in thier minds from old assumptions. The P2P literature has not helped much either because most discussed P2P in terms of searching. This is not surprising, considering that most of the current P2P is oriented toward file sharing where 'all' data is 'discovered'.

The second thing that many in P2P talk about is discovery of a service as opposed to a file. This is what I call a inverse software agent. Software agents usually get passed from computer to computer to do work. The inverse agent is one that you discover some place else and use on your PC to interact with other agents. An example might be a datin service that you discover and then use to interact with others that are single. The inverse agent makes sense, but there is very little support for it. Yes, it is a good idea, but the software and security support is not there. It is thousands of times more efficient to just write and distribute an application rather than a plugin to extend your network capabilities. An application that genericly finds and loads applications is overkill unles it is very generic - at which point it then loses its value. Catch-22.

Making all applications start with a search at a higher level of framwork is also not a JXTA strength. JXTA is multipurpose. It is not partcularly useful as a search tool(at least without a specific type of search). It is not even optimized for searching. Yes, there are search mechanisms, but they are very limited.

There is one area of search optimization that the JXTA team is working on very hard: Finding another computer listening to a pipe address. Simply, a computer that wants to accept information or create a two-way conversation. That’s what most network applications do, so that’s a reasonable area to optimize. That also means that even if we discover the application somehow, we still have the system to discover other computers in a P2P network.

But why throw away the purest view of ad-hoc networking? Well, I am not throwing it away. Just putting it back where it should belong. Applications should be applications - not a service.

Lets talk about the real crux of the argument, the well-known ID and how it is not a violation of a dynamic P2P network.

A Priori ID / Well-Known-ID

I was once taught a Latin phrase that has stuck with me but I have found difficult to follow all the time: “Eschew Obfuscation.” Translated it is simply, “avoid complicated language”. The problem with this sage advise is that when a new technology comes around we get ne buzzwords too. In JXTA, a well-known or a priori ID is an ID that is already known or can be created from known information. The best example of this is an email address. You know your email address, so does your email provider, and so do your friends. Because an email address is usually simple, like turbogeek@ cluck.com, it is simple for any application to require it as a way to identify you. In effect, your email address becomes an ID, plus it can be used for email.

But lets get back to confusing buzzwords for a moment. An ID in JXTA is a URN or Universal Resource Name. URN’s can have many formats, but they are just a unique identifier. The JXTA form of the ID is found everywhere in JXTA from groups to pipes and to identify versions and types of code or data. ID’s are everywhere in JXTA

But where is the discovery or ad-hoc cpability of this P2P system? Mainly in managing the network to discover peers and route messages. The network is created ad-hoc except for a few seeded peers that are used to discover the rest of the network. Beyond that, there is no requirement or preference that peers ‘discover’ information. Thus for well-know identifiers, the network is crreated on the fly to connect peers via an identical ID.

Discovery in JXTA, as I have said, is a little inefficient for data searches. There are many methods for creating efficient searches. I describe one earlier in a prior blog on a six degrees of separation search (a Kevin Bacon network search). The six-degree search used well-known ID’s created from email addresses to create connections between PC’s. Using the well-known ID increased the efficiency of the network.

This finnaly brings me back to the guys that think a known ID is 'not' a way to build an ad-hoc network. You should have seen that the ID is indeed a transiant thing - at least by clients when using an email address. The connection between peers is also ad-hoc and discovered via pipe routing whenever you are mathing peers with identical ID. In addition the ID can be formed to represent any subject, service, location, thing, or person. All you need is agreement between peers looking for the representation. Sounds like well-known ID are the poster boy for P2P.

I Dream of JINI

Perhaps it is the dream of JINI applications that lingers in the P2P purist's minds? If just walking into a room with a WiFi PDA connects you to a local printer is cool, why can't you apply the same thing to P2P? For example, if I log into JXTA, shouldn't it automatically guess I am not looking for a printer?

P2P is not as straight forward as JINI. Realizing that there is a printer is not the same as discovering a service that does printing and thus might be useful. To look at this another way, you could create aJXTA dating service. If we apply a JINI model, a PDA owned by a single person would aoutomatically load the dating service and start looking for a mate. Might be nice, but really a bit of overkill. On the other hand, if I run a dating application enabled with JXTA, I can use data about your likes and dislikes to create an ID that can match you to someone else like you.

The bottom line? Feel free to use JXTA ID’s created from known data. It is not against the spirit of P2P. The well-known ID is also an eligent way to solve many P2P problems. No one will call the P2P thought police. If they do, send them to me and I'll give them your Get out of Jail Free card.

Things change, but remain the same

Time for me to switch jobs. This time it looks like it is for the long term. After years of consulting I am now a full-time employee of Texas Instruments. I am in the Education and Productivity Systems group in Dallas. My new job is to lead TI into the next generation of collaborative software (and any thing else I think is cool and will make TI a company you want to buy products from).

What's that mean? Basically I am working on ways to improve education through non-invasive technology. Since TI is also in the general productivity business, it also means I'll try to make all our lives a little easier. How? Well, I'm working on that right now. I'll let you know when I can.

But things remain the same. I am still active in JXTA and will in fact help the open source movement via my position at TI. Though they are not (yet) a source of open software, they are a user and a contributer to many projects.

My old job at Verizon was fun and I was sad to leave. At least I saw my software live on stage at JavaOne this year (Digital Compainion).

Speaking of my old job, I am still looking for my replacement. If you know JXTA and are looking for a job, email me ASAP!

Stay tuned. More educational blogs to come.

Where's the Grid?

JXTA & Business - The catalog

JXTA Catalog - Saving Money or Better Business

There are a few that stick to the old tried and true. The nice thing is that the adventurous have a competitive advantage. The adventure seekers and mavericks are better thinkers too because learning exercises the brain and keeps it humming.

JXTA is a very new paradigm (20 cents) and not always simple to grasp and apply to business problems. Throwing out old client server ideas and replacing them with P2P solutions takes a little effort. Lets look at an online catalog for example. Some hard thinking ahead. Turn back now now if you are faint of heart.

Catalogs are not hard to implement on the web. Get a good shopping cart and you have it. One thing we would like to get rid of is the cost for hosting and bandwidth. It is expensive to run a web site that can serve millions of hits. But we would also like to get our customers together for contests, games, chatting, and even to help or support each other (a topic to be covered in future).

Look at the components of a catalog: pictures, descriptions, prices, on-hand in inventory, shopping cart, order processing, credit card processing, order status. P2P is not going to replace every function. Credit cards, order processing, order status, and on-hand in inventory need to be done in part at the data-center, in the servers. The peer can get the request ready though. Our unavoidable contact with the back office are done with a web service or even through a traditional web page. But what am I saving?

Let’s Go Shopping

Think about how most people shop. There are three modes: browsing, restocking, and impulse buys. All three can occur during a shopping experience. Mostly though, the user is moving from page to page, downloading your catalog's pictures, descriptions, and the navigation buttons, banners, backgrounds and other HTML flotsam.

What is happening? The user is downloading and re-downloading lots of data. Very little other work is done until the user wants to add something to the shopping cart, paying for the order, or looking at older orders. Essentially 95% of your bandwidth and hardware at the data-center is dedicated to just delivering copies of the online catalog. Worse, most of this is duplicated multiple times to the same user and then duplicated again for every customer.

So, the catalog looks like it might be a place for optimization. By giving each user their own copy, the size of your web operation is reduced by 95%. Sound good? But how?

First, use the P2P network to distribute the catalog. We could do this in the simplest way possible by just storing the HTML on the user's machine. The P2P application would look at other user's computers to see if they have the most up to date pages. This is like a web cache on steroids because your web server is not called until absolutely required.

Getting Your Neighbor’s Copy

Distribution of the catalog is a little tricky. When the application starts it sends out a signal to other peers to see if there is a new copy of the catalog. When the catalog is older than it should be, the web server is queried for updates to sections of the catalog and those that get the copy become distributors for the rest of the network. Very quickly there are thousands of exact copies of the updates available for others to update their data.

The ultimate version of the catalog would be a little more complicated. By using Java to create a full-blown application even the shopping cart and other functions can be implemented on the client side. Only the ends of transactions or queries need to be implemented as web services.

Who Said Java Was Slow?

But isn't Java slow? Well, how slow is a web page through a slow connection? Java is not slow in any case and even if it were, anything is faster than most web page requests. Plus you have the freedom to add all sorts of client side tools, business intelligence, bells, and whistles to enhance the experience and increase profit.

Fresh Prices

What about the pricing of items and discontinued products? First, customers are far more flexible than many give them credit. They accept change - the don't always like it, but they understand. Next, understand that prices for most retail goods do not change that often. Even sale prices are usually set far in advance. For volatile prices we update them at checkout time(Amazon does this with special pricing). We can also update the price changes at intervals that can ensure that the new prices are fetched either from another peer or a web service at a rate higher than catalog content. If you are extremely paranoid, the updated prices could be fetched each time the user starts.

Scaling the application is different with JXTA. Since the brunt of the work is done by the customer's computer rather than your servers, the scaling of the infrastructure is proportional to its contribution rather than 100%. There are some JXTA scaling issues, but these relate mostly to tuning and how the P2P network is used. Since JXTA has a notion of super peers to help increase the efficiency of some operations, you may want to add a few to increase the efficiency of the application. More about super peers in another blog.

More Bells and Discounts

There are other benefits to the P2P/Web mix. Here are a few:

1. One computer language – No need to mix javascript, DHTML, PHP, Perl, Flash, etc.
2. Auto Software Update – Software distributed with the same system.
3. Works On Laptop – Users can use the application without connecting to the Internet. The final sale can be queued for later transmission.
4. Reduced bandwidth cost – Peers talk between each other rather than through your data center. You only pay for the final transaction - not the entire experience.
5. User to user connectivity – Users can chat and share info like product choices like an instant messenger application with more features and without impacting the data center. This is great for products that have communities like collectors, hobbyists, and are passionate about your products.
6. Local Storage – A user’s own computer is used to store things like past orders, credit card info, and even info on when to reorder. This reduces the size of your storage and complexity of web apps and can improve security.
7. Local retailers participation - Since this is P2P, anyone can be a part of the network, including the local retailer. What if you ordered a book? The local retailer could reserve it for you via a message from your computer to the store's computer. You pick it up and save on shipping.
8. Extras - Now that you are on the desktop there are all sorts of things possible from games to integrating with the user's calendar applications. Just use your imagination.

A P2P catalog is just one example of how JXTA can be used to enhance an idea and save money. There are other things that are cool about JXTA and P2P. More to come.

Six Degrees of Seperation

It's a Small Small World After-all

August, 7 2003, the BBC reported that an article in Science had been published about an experiment that proves that by simply forwarding email among acquaintances, it only takes a chain of five to seven emails to reach a specific email user unknown by the original emailer. Why is that important? It helps prove that you can write P2P applications that let you find people or information by at most 6 steps away. This is known as Small World (first tested by psychologist Stanley Milgram) or its more popular moniker, Six Degrees of Separation (A.K.A. the Kevin Bacon theory).

Six Degrees = A Lot of People

But there is a problem with Six Degrees. There were actually a lot of people emailed in the course of the search. Think of a pyramid. You email ten friends and they email ten friends who email ten friends. At 3 levels about 1,110 might be sent with each person having ten friends. At 6 degrees it is a maximum of 1,111,110 emails. If each person knew 100 people, at 6 degrees of separation, it would be 1,010,101,010,100 people. More than enough to reach everyone on the planet. That's a lot of spam and a lot of network traffic. See the problem?

Searching for a Friendster

The six degrees problem depends on who or what you are looking for. It could be a specific person, a type of person, or even a someone at a location, a or a person who has something you want. The experiment would probably have failed if repeated too many times because the emails would be treated as an intrusion and thus spam.

www.friendster.com/ is a similar idea in connectivity (join and look for turbogeek@cluck.com). Friendster is of course a web site with a large database. They also have to pay for big servers and a lot of bandwidth. What if we duplicated a similar idea in JXTA? How could it be done?

JXTA Friends

Here is the concept. I have a JXTA pipe listening to an address that is the equivalent of my email address (one of the few things as unique as your social security number). I have a list of my friends and their email addresses. If you know me, then you know my email address and can access my friends in my address book. With access to the book, you can connect to the friend's address book to continue your search if I don't have the person you are looking for in mine.

To use the system, just connect to the pipe with my email address and ask for a contact with a person you are looking for. If I have it, I return it. If I do not have it, I can ask my friends via the same mechanism.

Too Many Friends

There is a slight flaw in this straight forward design. If we have a lot of a lot of people in the network, the number of messages could be quite large. In fact, this is the same problem Gnutella has with its search mechanism. But the answer is not too hard to solve. Just put more information on each peer and set limits on how deep searches can go. Start by replicating your friend's address books.

By duplicating address books we decrease the number of hops for each connection. Since there is a tendency for friends to flock together and thus have each other's email addresses we also reduce duplicate searches. So, in just one hop we access the close group of friends and those that are looser acquaintances (we know this by the frequency of duplicated entries among the friends).

Duplicating address books does add a little bit of storage. For example, 100 friends,each with 100 of their friends at say 256 bytes per entry is 2.5 meg. This seems like a small number with todays disk drives (my little Apple laptop has a paltry 60 Gigs). Yes, it is a waste of space to a certain degree, but is cheaper than a terabyte of disk space on a centralized web server. It also means you and your friends have a great backup mechanism for those all important address books. The best benefit though is that you save a little less than ten thousand connections for each peer contacted.

Of course there would be more to do. Security is one of the more important pieces. In addition, if we are really going to go after true 6 degrees, that's still a lot of connections. Luckily the six degrees network finds the right guy within just two or three hops. No one said software was a simple profession.

Smarter Searching

The numbers can probably be made much better. With a few networking techniques and ways to qualify the route taken, the search can be optimized. Of course I'm just talking about people in this example. If we were looking for a specific type of person (like an accountant or politician), the search space would be much smaller. It's smaller because the odds are that there is a lawyer of accountant known by at least one of your friends.

Its a Big Gulp World

Small worlds are a little easier to see when looking for types of things like the accountant or politician. Small world is a slightly different idea than pure six degrees of separation. A better example might be Starbucks Coffee, McDonalds,7-Eleven, and Wal-Mart. How close are you to one of these businesses? In effect, you are as close to one of these as are a great number of people throughout the United States and increasingly throughout the world. The network of the franchise has made the world much smaller. For example, you may need to drive a few blocks to get a coke at a 7-Eleven rather than always driving to Dallas, Texas where the original store was located. Your world is effectively smaller.

What if we replace the idea of convenience store with a peer? The peer is often just a small computer with its limited resources. A 7-Eleven is small and has a limited selection and inventory. What types of things can we put in a peer that are similar to the convenience store?

We can create small worlds in two ways. This first is to locate information geographically. For example a computer with Starbucks locations would only have addresses within a few miles of the PC (actually a large number in most neighborhoods). Another method is to repeat information. Repeating info is the same idea as the franchise or chair where each location looks identical to the next except it is conveniently located near you wherever you are. Convenience would be in relation to your geographic location via the network, LAN, ISP, etc.

Six Degree and Small Worlds networking has a lot of promise. But what can you really do with this type of software? What are other applications worth pursuing? Since P2P is here to stay, what can we use it for? I have a few ideas, but what are yours?

The Riddle of the Spinx

RTFM==QED

Sometimes you do something that surprises people. Jaws drop and wonder is seen in your friend’s eyes. You too can tap into these secrets of the ancients. See a source of hidden knowledge, known only to select few. Answer the riddle of the Sphinx, just by reading the manual.

A little knowledge, creativity and some imagination and you can change the way people think. I have just recently done just that. I do it a lot because I have a habit of reading the manual and exploring how I can apply what I have read in ways the authors have not expected. It’s a bad habit from school where I was bored with dry assignments, so I twisted them to be interesting to me, rather than the teacher. Yes, I was a rebel…

I Robot

What I have done recently is to mix a couple disassociated things to create something not really intended by the designers. The first is Robot class in the java.awt package. This is certainly one of those read-the-manual things. You may have not heard of the Robot class. Robot was probably added to Java in 1.4 to help with testing. First it can capture an image of the entire desktop or just a part of it. This is quite a cool considering that in the past Java was limited to its own windows. The second, and very surprising feature is that it can send mouse and keyboard events to the operating system. In effect, controlling the entire desktop. Quite a departure from what you thought Java could do eh?

A Remote Possibility

Of course what this meant to me was that I could do more than capture the desktop or control things for a test. This meant I could control the computer from a Java application. Specifically I wanted to do it remotely. More specifically, using JXTA.

JXTA-Remote-Desktop was born! No need to dig up bodies and piece the monster together. Just pick up a couple of pieces and read the manuals. The Jr. Frankenstein kit.

Open Source A Me

What is JXTA-Remote-Desktop(JRD)? First it is open source and hosted here at java.net. It’s a simple implementation of the remote desktop idea, like PC Anywhere, Go To My PC, or VNC. It is written in 100% Java using JXTA as a transport. The key difference from the competitors (it is hard to compete with VNC because it is free), is that JRD can connect any two PC's even if there is DHCP, a firewall, or a NAT**.

JXTA's P2P network uses other generic computers to act as middlemen for HTTP tunneling and relay of messages. This is not a big security hole because the computer behind the firewall must be a willing party to the communication, just like other HTTP tunneling applications. JXTA also has its own addressing scheme so NAT and DHCP are not a problem.

JXTA is certainly not the best choice (message rather than stream based, and it has unpredictable data rates), but it is the only choice for this type of application. Think about your average PC. You can't get to it with a URL because it has no web address. You can't depend on its IP address because it changes. And there’s usually a NAT or firewall preventing direct access. JXTA lets you access almost any connected PC no matter what its current IP address or topology.

How good is JRD? Well, it is not as good as VNC yet. There still needs to be a little work to get the screenshots to be a little more efficient. Most remote applications use the native OS to get just what changes on the screen while JRD is limited to screen shots. JRD can become better through a combination of compression and differencing techniques similar to Internet video. The I/O of mouse and keyboard are delayed quite a bit so the user does not get too far ahead of the screen updates.

JXTA-Remote-Desktop is getting closer to being a viable application. The code works and there is even a multiplatform installer. I will also have an article at P2PJournal.com soon to explain the code. Since it is open source, I am looking for help to improve it. High on my wish list is better video differencing. I challenge you to look at the code and come up with an innovating solution to this devilish problem.

More to come! Up next, running Java and JXTA applications on an Apple Macintosh!

** NAT is an acronym for Network Address Translation. Most cable modems and DSL routers implement NAT. A NAT prevents anyone from directly contacting a PC from outside your home network.

Just a Little JXTA Muse

Blog Away

Am I crazy? I write books, mentor, and architect code (oh and code what I design). I also like to juggle knives, torches, MS XP CD’s, and other implements of mass destruction. I run a couple of Java user groups, and of course, I am a Java guy. And now I blog, therefore I am.

A blog can be a diary, soap box, and a place of information. You might get the first two here, but information is my goal. Be warned my passions are Java and JXTA… and very, very bad puns. With any luck the info will keep you coming back for more...despite the bad puns.

For today's blog, on the off chance that you have not heard about JXTA, let me introduce you.

JXTA I Suppose

It’s amazing to me that every few months there is yet another Java API. Between Sun and the open source community, it’s hard to keep up. But what’s important and what gives you the most bang for the buck? I believe that JXTA is worth your effort. Oh, JXTA is short for Juxtapose.

What the heck is JXTA? Simply it is a way to interconnect home and work PC’s together. Sounds simple, but it really isn’t. The first problem is the barrier to addressing most PC’s. With NAT, DHCP, and firewalls, most PC’s cannot see each other. Web pages, email, and instant messaging are our key protocols, but they suck for applications. Worse is that to host more than a web page costs a lot of money.

Another problem with today's internet, even if you can address millions of computers, how do you find the one you want? Looking for the right data, service, or person? There is no Google for your neighbor’s PC. What if you want to talk with a group of computers? How do you constrain the messages to ‘just’ those PC’s? The more computers there are, the harder it gets.

JXTA solves the addressing problem and has some of the tools for the second. JXTA is a Peer-to-Peer protocol and API developed by Sun, and its also an open source community. JXTA includes routing, message delivery, addressing, and more for P2P computing.

Why JXTA? With JXTA, anyone can create and deploy an Internet application without laying out a load of cash. You no longer need to have a web site and an application server to do interesting applications on the web. JXTA lets you do very interesting and powerful applications with just your PC and those you interact with. It is the missing link that lets anyone write an Internet application. JXTA is the Internet for the masses.

Are servers dead then? Not at all because they still have their place. JXTA can reduce or eliminate your dependence on them. There is a point where having to pay out cash is inevitable, but you can do a whole lot for a lot less and many applications will need no server to be a success.

Sometimes servers do make sense. If you need a central authority for credit card transactions or connecting to the database to check inventories. For these types of things, mixing P2P with the normal web infrastructure of servers and especially web services makes sense and will cost less in infrastructure than just web-based applications.

There is more protocol magic in JXTA like message relays, dynamic routing, and of course a little security. JXTA is also language neutral, so it is more than just Java. I’d explain it all here, but I have a whole book for that. There are a few articles on the net and other JXTA books too. Plenty of resources for learning JXTA. I plan on making this blog yet another place to look for ideas and information about JXTA and P2P.

Time for you to learn a little JXTA. Head to jxta.org, to learn more about JXTA.

If you can really connect any computer in the world, there is a key problem of which one? We'll talk about that soon. Stay tuned!

Punishment

What came first, the chicken or the egg?

The egg.

A chicken must first eggzist!!!

This work is licensed under a Creative Commons License.