last week was a busy one, being a cummulation of alot of personal work, getting a chance to interact with folks in the *real* world (which is what i personally enjoy most) and taking in new'ness of many flavors. good times.

my week started w/ by testing out the JXTA Hands on Lab. the folks who orchestrate the java one hands on lab deserve huge amounts of credit as the job they do looks alot like herding cats, from my one-of-many perspective yet the collective information is bar none. this content is consistent, comprehensive, HANDS ON (best kind) and is presented for several events. so, sang, shridhar, shannon and tracy ... you folks ROCK and thanks for allowing me to take part in the festivities. this is the third annual jxta hol and is now available online. it is my hopes that this codebase will be treated like that of any other open source element, taking input from interested parties, and simply rolled back into the collective hol family.

with the jxta hol in hands i strolled over to NetBeans Day and caught the tail end of the opening talks and took in the ensuing demos and presentations. the event was as packed as last years but the rooms were divided up a bit differently, making it easier to move about. further, the speakers looked to have a nice amount of time to show their warez where as when i was there demo'ing the netbeans jxta collab provider last year we had roughly 5 minutes to get the dog and pony to dance. given i can talk at a pretty good clip when i'm amped about the topic at hand i didn't have a huge problem with the brevity of the allotted time. this year, i ran into many folks i've worked with at various times so it was good catching up with folks. the realtime development, deployment and instrumentation from within netbeans proper demo stood out in my mind as killer k3w1.

the annual jxta town hall was next in the queue. this year, the bulk of the time was spent having various folks present their jxta products, not projects but products. quite impressive. good times.

given i helped my brother move into his new house in pacifica he let me stay at his place this week versus taking a long train ride each day. that worked out really nicely and i found travelling on bart, first time for me, to be very efficient. i just wish bart came down the peninsula a bit further.

jxta was was well represented at java one this year which provided great context for onging discussions, new and old alike. bondolo's jxta security best practices is a must read. i worked the jxta pod in the pavillion for each of the 3 evenings. the first evening was a tad bit slow and i got a chance to chat with the swing lads who cooked up aerith. very impressive app and it is so refreshing to see folks making it easier for pixel challanged mortals like myself to gen smoking rich client applictions. props to swinglabs! i'm gonna slice some time to dress up some apps with thew new swing goodness.

wednesday and thursday jxta pod activity was largely non stop, chatting with folks new to jxta, others who are community members and whom i seldom get to meet in the real world, some folks who are actively using jxta in intersting ways and others just folks passing by, some of which have intersting projects of their own that we discussed how our collective worlds can be brought together. also had a cool chat with dale and his son who updated me on the type of hacking high schoolers are doing these days. lastly, i chatted a bit with my grid partner in crime, whom i have again worked with virtually for awhile but met in the real world for the first time. great stuff.

petr and i reviewed my last minute netbeans jxta collaboration provider slides for the nb jxta collab provider bof held late thursday evening. not being a huge fan of slideware, i biased the presentation towards the informat, interactive and demo rich side of things. given i attended the java one after dark party and had a couple of bloody marys dancing in my blood stream informality was on high order. the demo used 2 notebooks and a local lan using jxta configured in adhoc mode. we went over the slides in rougly 20 minutes followed up by a comprehensive demo. the netbeans collab folks did an amazing job with the collab provider api and made it really easy to slot in jxta as the networking provider happily shuttling about XMPP, SOAP and XML as generated and consumed by the participating netbeans instances. fun stuff. some general netbeans collab discussion surfaced centering around netbeans and jcreator collab. from my perspective, the jxta collab provider can readily sit in under each of these containers, and others in fact, allowing for agnostic networking across applications of any type. information regarding this work will be posted at collab.netbeans.org moving forward. thx again for co-presenting petr! i'm looking forward to working more with you and our collective communities moving in the future.

backing up a bit, the after dark party was fun. the mix spinning in the background was pretty amazing. the myth busters were cool to see. i stood in line to get an autograph for a bit but given there was no real line, more a mob, i moved on. a colleague ended up freely giving me his autographed picture. honestly, i didn't beg. thx gary! the ac/dshe tribute band was pretty good. i watched fatal1ty do his thing for awhile as well.

friday i hosted the jxta hands on lab which was packed, like all of the labs. again, huge props to the folks pulling the j1 hol together! the scenario is such that there are 100 work stations on the same subnet and 20 or so notebooks on a wireless net. the jxta hands on lab (7110) is constructed to progressively (read code reuse) walk through the following scenarios:

• configuration (api, declarative profile, abstract configurator)
• network connection
• find stuff (discovery)
• share stuff (publish)
• socket
• multciast socket
• authentication

you can pull down this lab and run it yourself, which you should do right now. go ahead ... i'll wait for ya. doo-bee-doo-bee-doo. the lab is set up with an included netbeans project file so you are ready to compile and run as is. bada bing bada boom. commandline ant is supported as well. the lab configuration is adhoc which was alot of fun for the discovery and multicast exercises. a few folks changed the default text which totally made my day. i barely touched the authentication lab due to timing but will add that an additional "easter egg" exercise is included that is commented out at this time builds on the afore mentioned socket exercise by adding authentication resulting in a secure socket connection. perhaps next year we'll get that one back in the mix. my hopes are to treat the jxta hol examples as open source and encourage others to contribute complimentary code fragments to help build it out. i want to again thank the folks who took time to sit in on the jxta hands on lab and the 15 or so folks that stayed after to deep dive a bit further. this single event made the entire event and the work leading up to it worth all the effort.

i got to sit in on a few bofs. the scripting bof was cool with one take away being that that scripting engines implemented on java evidently provides greater code portability then is otherwise possible. not that suprising after you think about it a bit. the jruby folks look to be rocking and given i've been playing around with ruby a bit of late so that was fun info to learn. i look forward to being able to blend java and scripting logic as warranted for the coming years as this should prove to be extremely enabling for integration type activities, i suspect. the freedom toaster bof was nice. jim took some snaps as well. i got a swag shirt and drooled over the ubuntu themed nexenta solaris 10 system. truly great job. with me being a huge ubuntu fan, bringing together open solaris and ubuntu goodness, noting that i'm generalizing a bit here, is a hugely good thing. i then sat in on the apple bof and was impressed with the ever shrinking time delta between osx jre releases in comparison with other platforms ... i believe it is measured on the order of weeks these days. very cool.

after talking with folks a bit more i'm more convinced then ever that the meerkat (http-over-jxta) code i've been hacking in the jxta comons project is of value, primarily on 2 fronts by easing listener implementations within an IoC 1 method "peerlet" container and to the caller by representing resources of many types and cardinality, be it one-to-one or many-to-many, as a traditional (and expected) uri backed with the respective jxta protocol handlers. i'm looking foward to pushing these ideas futher in the coming weeks given the codes usage of late and the common programming model that is fudamentally http(s)+ ... good times. the meerkat codebase is used in the afore mentioned nb/jxta collaboration provider and significantly eased that effort.

so, for those playing the home game, consider the following and join the party:

% cvs -d :pserver:guest@cvs.jxta.org:/cvs login
  ...
% cvs -d :pserver:guest@cvs.jxta.org:/cvs co commons/modules/ext
% cd commons/modules/ext
% vi readme.txt
% ant run.proto

with java one in the bag, so to speak, i visited friends around the city. while waiting in a posh lobby i ran into phil gordon of celebrity poker fame. when bumping into phil i was pretty much caught off guard and as such ended up being a total fan boy and unfortunately forgot his name and could only blurt out "texas hold'em" and the like. he was nice and we chatted a bit more, me retelling our families evening texas hold'em tradition starting with my 3 year old son's wanting to play "river card." these days, my 5 year old lad can hold his own with a deck of cards.

upon stopping back by my brother's place to pick up my car and head home i discoverred i got a flat and opted to miss my son's little league game saturday, which was a bummer, and instead hang a bit longer with my brother and his wife in pacifica. upon finally getting back home i learned that while i was away, autumn, our daughter, learned to crawl. amazing how time passes. i took an extended weekend off for memorial holiday at which time we all stated with my brother in pacifica and brought our bikes. there is nothing quite like riding biks along the pacific coastline. dave, my brother, taught trey, my son, chess which he took to immediately. we play a couple of games each day and his watching his learning uptake is amazing. i'm pretty sure he'll end up holding his own in chess, well, agaist me at least, by years end.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Radiohead/Amnesiac/Pryamid Song

the java one hands-on-labs just get's better and better every year. hats off to the crew that pulls it all together.

if you attend the JXTA HOL be sure to say hi. if not, no worries, you can access and run the lab exercises online. so, if you are playing the home game hol then fire up MyJXTA and say hi P2P style!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: javaone buzz

this last two weeks were unique in that i got to meet, for the first time, 3 folks with whom i've *virtually* worked with via myjxta and associated projects. that was *so* fun. it is amazing that given a smidge of im/irc, via myjxta of course, you realy get to know people, quite well in fact.

first up, i got a chance to sit down and chat with mark petrovic a bit where we chatted about juxta in general and furthered some of our jxta configuration discussions of late. i still owe a bit of code to this regard, something i've been meaning to add to ext:config for awhile anyways. mark is a huge motivater for to those involved with myjxta and associated projects. he also has some fun ideas in the areas of collaboration. i'm really glad mark took a bit of time out of his busy schedule to stop by my little corner of the jxta-plex world.

next up, henry story was in town. i met henry via the bloged project but having done a bit of real-time language translation in the past turns out i've used his code long ago as he was the *bblfish* behind alta vista's language translation tools. henry's done a killer job w/ bloged and given we've talked about the possibilities of bringing our varied domain experiences together at some point in time it feels like the time is right to play through some of the ideas. should be a fun ride!

last up, bob way stopped by for a visit. bob's got a ton of ideas and even more domain knowledge in the areas of search, content distribution, copy right entitlements and the like. while bob was in town polo was online so we hooked up a little myjxta video chat.

i'm glad i got to meet and work with these folks in the borderless world that is opensource ... and in the very real world as well.

good times! better times coming! happy holidays all!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Sigue Sigue Sputnik/A Gothic Tribute To The Smashing Pumpkins/Bullet With Butterfly Wings

i've been meeting more gamers on myjxta of late, the most recent of which is joel. i've had a great time chatting w/ him going over what jxta provides to application developers.

jxta *is* the net!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: The Streets/A Grand Don't Come Easy/Turn The Page

per the mink'ster i gave the most excellent bloged another spin this morn. excellent job bblfish!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Page &  Plant/No Quarter/Since I've Been Loving You

the one laptop per student non-profit initiative is pretty amazing, as kevin noted earlier. the $100US laptop design is really compelling. the device looks to be relatively rugged, very approachable and multi-functional. what really intrigues me, though, is the built in assumption that the existence of environmental resources, even electricity, is not a given. wow. think about that for a second. if electricty is not assumed then it is fair to say that "systems administrators," as commonly defined, can not be assumed either. as such, the system, it's constituents and the network in aggregate, simply must operate at a higher order of mutual cooperation then is present for the vasy majority of like devices to date. thusly systems software like that of jxta thrive in such environment, by doing more with less, by discoverying, leveraging and rotating network accessible services when needed in true collaborative peer-to-peer fashion, and done securely.

i've had the good fortune to interact with some of the folks in the trenches for this project. largely by happen stance ... the best of interactions. i have a keen interest in this space largely because my sone (pictured above) is now in kindergarten (man how time flies) at the village school, a really great parent participation public school. that and i like the domain of small group (ie long tail) collaboration and the firm belief that systems software, ie the network, can be so much better then what it is today. as such, projects like myjxta are a natural fit.

back to the olpc initiative. while this is compelling and looks to be entirely viable with the right alignments of corporate and government sponshorship, etc. i wonder if any us schools are candidates for this program. more to the point, i want my son (and daughter) to have access to such a device and the backing "network of things." now, if one answer for us schools is to spend a bit more on commodity systems i think we missing the boat, entirely. schools that i've seen have ample access to h/w but limited time and ability to "manage" said systems. that, in a word, is the problem. why is it the managability of commodity systems is what it is today? it doesn't need to be this way, at all. it is time to think different.

the good news is, of the few folks i've met of late they "get it" and as such they are changing the world. now, please, let's change our local school systems in the process as well. my skin is in the game.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Depeche Mode/Remixes 81-04/I Feel Loved

one of my first ah-ha moments w/ jxta was when, for me at least, i envisioned it being, at it's lowest level, a socket. a kick a$$ socket, but a socket none the less. a socket that slurps up late binding and constantly changing addresses of varying protocols w/ ease. of course, there is more to jxta but for me, it was the socket perspective that intrigued me the most.

now, sockets are fine an all, w/ jxta socket being the tastiest of all, but it is what you do w/ said socket that matters. having worked on tomcat in the day (ahhhhh, good times), built a number of ecom systems (i *hate* the letter e as a result), and an interesting application at a startup (shudder) it's pretty obvious that http is, for the most part, fine. various protocols are stacked on http which are subject of debate, but http is, well, simple, and simple is good. can i get an amen!

w/ that as backing context and having an itch that has needed scratching for 2+ years now, and having a very real need to simply the $%^@ out of a current gig i opted to lay down some code that takes my tomcat experience and binds it squarely over the jxta socket keeping in mind all the while tha ease of use is paramont ... as i'm going to use this stuff myself. i've been talking about this for awhile now but talk is, well, cheap.

so, what did i end up with? here's the skinny. there is a server and a client component, probably more approriately noted as requester and responder moving forward in a jxta context as "this ain't your father's server."

here's what the server looks like:

  // xxx: a most excellent 1.5'ism
  URL.setURLStreamHandlerFactory(new JxtaURLStreamHandlerFactory());
  // xxx: server
  HttpServer s = new HttpServer(this.npg);

  s.addPeerlet("foo", "net.jxta.myjxta.dialog.http.RestPeerlet");
  s.start();

the basic idea is that one can start up a server (listener) socket and accept inbound connections. a series of "peerlets" can be registered, not entirely unlike a servlet, that will be selected as the connection handler delegate based on some regex mojo as specified by the key, a "webapp context" in servlet parlance. that's about it.

now, this is just a prototype as this point in time but, again, taking my past experience into account (mom taught me well, learn from life's lessons and be nice to people) here's what a peerlet looks like today (read hell'a simple):

import net.jxta.myjxta.dialog.http.Message;
import net.jxta.myjxta.dialog.http.Peerlet;

public class RestPeerlet
implements Peerlet {

  // xxx: pong
  public Message process(Message req) {
    Message m = new Message("pong");

    m.setHeader(Constants.CONTENT_LENGTH, String.valueOf(0));

    return m;
  }
}

now, the client side is where the fun starts to happen. well, it's all fun to be honest, but this is where my juices really start to flow. here's the basisc:

  URI u = null;

  // xxx: put this stuff in a factory of some sort bruth'a
  // xxx: in the real world teh pipe adv will be inferred from some other means
  try {
      String p = s.getPipeAdvertisement().getPipeID().toString();
      int c = p.lastIndexOf(COLON);

      u = new URI(JxtaURLStreamHandlerFactory.PROTOCOL +
          URI_DELIMITER + p.substring(p.lastIndexOf(COLON) + 1) + "/ping");
   } catch (URISyntaxException use) {
       use.printStackTrace();
   }

   System.out.println("u: " + u);

   // xxx: dispatch a request
   if (u != null) {
     Rester r = new Rester(u);
     Message req = new Message("ping");
     System.out.println("request: " + req);
     Message rsp = r.dispatch(req);
     System.out.println("response: " + rsp);
   } 

basically, given a uri with a specified protocol, in this case "p2pp," we can now use java-only classes to connect to the server and open input and output streams. in my case, i have a little rest engine baked into the mix which simply shuttle mime messages across the wire. which is precicely what i need right now, no, wait, i needed that like 2 years back. since my folding space-time continuum device is presently in for repairs i only have the present ... the result can be summarise as "meerkat," tomcat's fleet footed sibling. i'll expand on this more in following thread. till then, here's a joyous run:

execute:
    [java] connect
    [java] u: p2pp://uuid-5961626164616261[...]FAB41254E3268B04/ping
    [java] request: resource: /ping
    [java] content: null
    [java] response: resource: /pong
    [java] header[Content-Length]: 0
    [java] content: null 

not perfect but if one conciders how simple it was to get to this point it, well, thrills the heck out of me. the "jxta url protocl handler" can back pretty much anything, as my deep thinking compadre bblfish and i have discussed, well, since our paths first crossed via bloged code sling'age. on top of meerkat we can project any number of flavorful content, of which foaf:rdf looks the most attractive. myjxta has already start to shuttle about rdf data so we have an app with which to readily test pilot these ideas further.

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

Secure End-to-End Computing

in my ears: Death In Vegas/Death In Vegas/Days Go By

tbray has earned his jxta wings.

thing is, i suspect we can cut down the current jxta configuration class to 1/3 the size ... something like the following is what i'm aiming for:

import net.jxta.ext.config.AbstractConfigurator;
import net.jxta.ext.config.Configurator;
import net.jxta.exception.ConfiguratorException;

public class MyConfigurator
extends AbstractConfigurator {
 public PlatformConfig createPlatformConfig(Configurator configurator)
 throws ConfiguratorException {
   configurator.setName("foo");
   configurator.setSecurity("bar", "bop");

   return configurator.getPlatformConfig();
 }
}

but i want to add the following:

• a main method
• instantiate the jxta platform

tim's got a piece of real-world code, as mentioned in his blog, that i'd like to start with, opting to take a small piece per blog and itteratively refactoring the code down the the bare essentials and no more. i suspect the outcome will be significanly application agnostic and perhaps the little thread we spin along the way will be enlightening. i promise, no holds barred with regards to diamonds in the rough, best practices and pitfalls.

tim ... your serve. can you post the code at which point to which i will reference it making subtle tweaks along the way.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: The Crystal Method/Community Service II/SpeedFreak

JXTA Technology Brings the Internet Back to It's Origin is really nice article that covers jxta context along with current and future state networks.

jxta is the net!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: The Crystal Method/Community Service II/The Crystal Methods Vs The Doors

given the build up to javaone '05 and netbeans day, then participating in the afore mentioned events in addition to jxta town hall followed by a most excellent and very non-virtual (read real) vacation i've offline for a spell ... and it felt really good :)

For NetBeans Day we presented "NetBeans/Collab:JXTA," which basically extends the NetBeans Collab module with true peering capabilities. More on this in the coming weeks.

Immediately following NetBeans day I re-presented the NetBeans/Collab:JXTA demo and provided MyJXTA updates, which now supports voice, video, a spiffed out UI, etc.

For JavaOne '05, which so totally rocked IMNSHO, we provided the second installment of the JXTA Hands On Lab (note: I'm not sure where the '05 HOL content is posted at this time). The JavaOne Pavillion was hopping and I met many new folks interested in JXTA along with a growing number of regulars.

Lastly, NetBEAMS, of which MyJXTA is a component, won a Duke Award under the "Community Category." This project was very rewarding in that the result, in this case, was a perfect blend of complimentary technologies to solve very real world (read wet and dirty) sensor telemetry management and collection. there is so much more we can do in this space. as such, i'm very much looking forward to "2.0" and again working with a great group of folks.

in aggregate. that's the opportunity. building solutions taking readily available and extremely enabling components to build out real world solutions ... in aggregate! good times.

over the vacation we worked on our long overdue bathroom remodelling project. given my father-in-law helped replumb recently we now have the tile layed (first timer for me) along with the swag radiant heating mats, walls and ceiling painted, floor and window trimmed and ceiling vent installed. next up we'll bring the claw foot tub into the room once i seal the tile and grout, calk the trim and fill and paint the trim nail holes. this project was supposed to be done before the arrival of our first child, how is 5yr old today. i'm betting i can beat the arrival of our second child, given a 5yr head start.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: New Order/Substance/The Beach

wow. netbeams won a dukie award at this years java one. here's a nice netbeams one-pager for those that are new to the project.

the netbeam's application domain is both immense and important, potentially life critical in the big scheme of things. the ability to realiably collect, manipulate, compute, display and act upon realtime, real world, telemetry from around the world spanning aquatic and land based sensors. further, by applying jxta it will become possible to securely command-and-control such sensors from afar.

this is just the start and nothing but good things will result as continued innovative and out-of-the box thinking is applied to this and like applications. and jxta is at the heart of it all. securerly and pervassively connecting disparent data sett flowing across varying networks creating bi-directional and truly "peered" relationships.

potential next steps include leverage of the java me jxta platform, broader federation of aggregated sources of a jxta network, richer client-side interativity along with a healthy mix of authentication, quality controls and, lastly, broader deployments into like domains. all leveraging a cadre of existing and maturing communities, including at this time but not limitted to jxta se, myjxta, jxta me, jddac and others.

applications rock but the people behind it are what drives progress. without open minds and unabashed willingness to collaborate the best of ideas are merely fading conversations. the folks behind netbeams are top-shelf and thus netbeams is born and off to an incredible start.

i've truly had a great time working with a set of new faces along with some great sun colleagues, namely james liu, jim wright and tai-wei lin. these lads rocked. we came together in short order and managed already busy commitments and schedules to do our part and truly raise the bar. i very much look forward to working with these folks again pushing jxta into deeper and broader domains.

join the fun. get connected.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Underworld/Dirty Epic/Dirty Epic

just reached a major milestone in a little project i've been hammering away at. feeling good. this one was mondo challanging. lots of moving parts. phewwwww.

tomorrow should prove to be an interesting day.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Led Zeppelin/How The West Was Won/Dazed And Confused

like any old school servlet hacker of yore i have a set of trusty HTTP GET/POST utils under my belt at the steady ever ready for times of need.

well, after shuttling a series of request/response tuples to and from across ye jxta vastness it has become crystal clear that if i simply marry two very simple (as in good) approaches the net gain is effectively a "RESTful jxta."

there are some kinks but if this approach can solve 80% of the problem domain then we are on to a good thing indeed.

i'm very eager to add more to the mix, namely MIME delegates and XSLT transforms but for now i'm going to build up from the bottom and not necessarily require the upper tiers but anticipate their usage all the same.

for now ... i REST.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Gomez/In Our Gun/Ruff Stuff

configuring jxta via the ext:config library is trivial. using ext:config one can specify desired deployment models declaratively via profiles.

most applications these days include configuration of some sort. further, it is quite common to specify configuration data via xml. nothing new here.

the ext:config profile is yet another xml structure and as such applications that wish to leverage the conviences profile offers must mechanisms to create and/or manipulate this structure, likely foreign to the hosting application. further, it is quite likely that within the hosting applications native configuration structures, some if not all of the needed ext:config profile can be extracted. xml code slingers don't flinch at this commonplace practice. well, most don't.

alex milowski has augmented the ext:config work flow by pre-processing his applications native configuration structures with an xslt transform thereby creating the derived and specialized profile as a very late binding.

very cool! this further eases jxta configuration in general for a significantly large class of jxta applications. so cool, in fact, that we have an open issue to simply add an optional xslt style sheet to the relevant Profile methods to perform this transform within ext:config, further lessening the jxta configuration overlap into a hosting applications code space.

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Bloc Party/Silent Alarm/Pioneers

paulby of lg3d fame provided some myjxta goodness today in the form of constructing a myjxta icon in the looking glass tray.

here's the myjxta icon:

hmmmmmmmmmm. need to spiff that icon, me thinks.

anyways, the myjxta code slingers are drooling 'bout this one. one things for sure, this is gonna be a fun journey!

MyJXTA :: use it - learn it - do it

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

Secure End-to-End Computing

in my ears: Bloc Party/Silent Alarm/So Here We Are