The BileBlog

Recently I’ve had a need for an IoC container to bless some components with some good old fashioned dependency injection lovin’. So I thought that given how many people out there use pico/spring/hivemind, they can’t be THAT bad. Picocontainer in particular seemed very promising, as it seems to take the embeddability aspect of ‘lightweight’ containers to heart, and does not mandate xml files from bizarroworld (Note to all ‘embedded’ library developers, if your lib mandates a logging framework, or a specific xml file, then you don’t know jack about embedding. I hope you’re listening Mr Hivemind).

It also has next to no dependencies, which makes the thought of depending on it (no pun intended) far less of a house of cards that is the usual case with opensores drivel.

Amazingly, even though I really, really wanted to use it, the damn project went out of its way to drive me away. It’s quite impressive really, I go in wanting to use a product, all but committed to it in my mind, and yet, through the magic of a certain unique touch of poo, was driven away and forced to seriously consider other alternatives.

First, given that I know how OSS works, you’re likely to be told to get the CVS version if you ever run into any issue at all. Being an adventurous sort and intimately familiar with cvs, I thought I’d do that from the outset just to save some effort later on. Here’s where the first touch of genius pops up. The cvs modules are called delightful names like ‘java’, ‘php’, and so on. Despite being consummate java developers with many years of experience and loudmouthed opensource prima-donnas, the authors somehow managed, in a fit of mass insanity, to completely forget how cvs module names work. Sure, I can change the name of the directory once I check it out, but really, why force that extra step? How hard can it possibly be to pick non-spastic cvs module names for an open to the public project?

If only that were the only issue. My hopes were further raised by seeing a build.xml there, tempting me with its easygoing ways and no-nonsense approach to life. So I type those magic three letters, and….hrm. Big blowup since I don’t have junit. Rather odd to be defining a junit task for just compiling, but ok, I can live with that….now lets try again…

Ohdear. Having just installed junit, I bet you’d never ever guess what ant tries to do next. Ready? It….downloads junit. After downloading junit, it downloads ant 1.5, THEN downloads ant 1.5 optional. Then, just to be safe, it downloads junit again. Having downloaded that mindboggling set of ‘dependencies’, it then simply blows up and refuses to build anything.

The maven wankstains like to brag of how maven autogenerates build.xml. Come on, has this EVER worked? Having a build.xml there that nobody has even bothered run is incredibly offensive. It’s the sign of an astoundingly lazy mind. A desperate hoister of featureturds with no thought or consideration or indeed…testing! Perhaps this hasn’t been testing because testing ant is just not possible within junit, and therefore is a terrible idea that will result in insta-smiting from the junit gods.

Nevermind, I’ll have to resort to the latest blessed downloads (basically, the last time some random developer got drunk and thought it’d be hilarious to put out a release). In the meantime, I’ll browse the docs and get a better feel for this beast.

The docs are, to put it mildly, the worst documentation I have ever seen for a project in a very long time. This includes projects that have NO documentation, which at least says more than what the pico docs offer.

For one thing, the documentation is all about the religious beliefs of the authors. They proclaim they support setter injection, but expend so much effort telling you off for thinking that way. Every other line links to some antipattern that this group of lackwits has thought up. At some point they even proclaim that soon there will be a ‘componenthaus’ site that offers pico components to download! (har har, how well is that coming along?)

The ‘relative volunteering’ section also seems to somehow totally miss the point of the project. No doubt as a result of another drug laced late night binge, someone chirped up with ‘components! That’s the future! pico is all about enabling component repositories!’ and the other clever clogs in their opium den of filth somehow latched onto this, and thus was born this sad pitiful page.

Of course, all the parts that actually merit documenting have not been. Setter injection requires that you plop in a ComponentAdapter. That section of the documentation is, unsurprisingly, blank. It’s really astounding what people will put up with from open source docs. The pride and acceptance that the community at large takes in these pitiful droppings is akin to a parent proudly displaying the pathetic crayoning of their spastic three year old child to all and sundry. Just image the outcry if a commercial vendor had the gall to put out documentation with a section left completely blank (and leaves it blank for the next year or two).

Similarly, for all the bragging of container hierarchies, the ‘documentation’ offered merely punts you off to the nanowar project, which just talks about itself and you’re forced to infer how that actually relates to component hierarchies and how they might apply in different situations (hint to doc authors, documentation-by-example should come AFTER documentation-by-documentation). That nanowar page also merrily discussed nanocontainer, which is the first we’ve heard of this term (if you, like any sane curious person, were merely reading picocontainer docs). Although there is a particular stroke of genius here, where, in a totally deadpan tone, the inspired author suggests that nanocontainer is best bootstrapped through groovy code in a web.xml parameter.

Of course, the lunacy doesn’t end there. The FAQ goes on to give us more side splitting examples. Witness the helpful question ‘Is a single Uber|Super|BorgCollectivePicoContainer in development? Something that can do all things for all people in all deployment situations?‘

Honestly, what the hell could the answer to such a question possibly be? You could substitute ANY product for this and still ask the same ridiculous question and still get the same pointless answer-that-has-words-but-says-nothing.

What’s freaky about this project is that the end result does work, and works with some measure of success. Using it though requires turning a very very blind eye to any documentation or non-code emitted by the authors. It’s almost as if the project’s success is through some bizarre cosmic accident. Just another freak output of the thousand monkeys at a thousand keyboards.

It’s really astounding how easy it is to pull the wool over the java kids’ eyes and amuse them for hours on end by merely dangling a shiny object in front of them.

The latest example of this is the one of the ‘ajax’ poster boys, json-rpc-java.

I am truly baffled that people take this crap seriously. At best, it’s a cute toy with a couple of neat tricks that one could copy. At worst, it’s a evil evil implementation that’ll bite you in the ass if you ever expect more than 3 users or would ever like to cluster, use declarative security, fine grained access, method level anything in fact.

The idea itself is not that bad. The implementation however is almost like some kind of sick sick joke. For those who have so far been wise enough to avoid this shiny bauble, it’s basically a clever hack built around xmlhttprequest and some javascript to java serialization that allows you to invoke arbitrarily methods on serverside java objects.

So how is this done? For reasons best known to to the authors themselves (and no doubt applauded by the shit-eating-grin sporting ajax crowd), they basically bung everything into a session. Now, you might be forgiven into thinking that ‘everything’ here is just lightweight stateless information. You’d be so so depressingly wrong. Every means that each user gets their own JSONRPCBridge. This class is so incredibly session-unfriendly that it doesn’t even implement Serializable. Even if it did, mind you, you’d be even further up shit creek sans paddle. Said class contains every exposed object, every exposed method, and every exposed class. Persisting this to anything other than memory is likely to take a few days at best, while your hapless user is left sitting there with any number of thumbs inserted into any number of orifices. Adding to the general hilarity within this class, we also have a static classCache map. It’s the gift that keeps on giving!

Of course, should you to refuse to use said session object, you’re forced to use the ‘global’ bridge. Of course, when asshats like these say global, you just know they mean ’static’. Of course, of all classes they could have possibly stuck the static, which did they pick? Yep, you guessed it, the very object they’re shoving in the session!

The documentation of course is in the fine tradition of open sores. It starts off well enough, but halfway through the manual, the author simply lost interest in the whole thing and just gave up, leaving 4 sections totally blank. Just imagine the hue and cry if a commercial vendor dared have empty swathes in their documentation. Why on earth is such incompetence tolerated and nudgenudgewinkwink-ed away in the opensores world?

It’s quite a shame really, the project is a cute little gizmo, and to the authors’ credit, it has no dependencies and does not use maven, so they’re not completely braindamaged. They do try and go out of their way to make up for that foresight though by forcing their hapless victims to edit build.xml and specify twatty tomcat values. It is truly astounding how few people seem to know how to use ant, or how others expect to use it. The developers’ real downfall however seems to be that they were never beaten with the scalability mallet as children. So if you kids know what’s best for you, let the beatings commence!

First of all, apologies for not covering the last day of TSSS. An early flight to Guatemala coupled with watching the sun rise the previous night very quickly squished any hopes of attendance.

Overall, the conference was a laugh. Vegas is a great location for it, and really, most of the fun is probably due to that. As no doubt most attendees felt, there really was absolutely nothing truly useful in any sessions that you couldn’t find without some rampant googlage, but that’s to be expected. The real point of these things is socialising and getting to yell at people in person.

The highlights for me were meeting a bunch of new people. In no particular order: All the oracle guys (despite them being Canadian and having a jdbc driver that’s about as enticing as bill burke’s breast milk), Craig McLanalanahamabanahan (who loves the silent majority of java developers out there, even if he hates the ones who actually know java), Craig Russell (bright JDO spec lead with his heart in the right place), Andres March (oscache maintainer who is hilarious when drunk), and finally getting to have a conversation with Rod Johnson about his pasty manboobs and various Springy things. I can say I was truly surprised once, when an EJB3 migration talk turned very surreal with a completely irrelevant discussion of porcupine mating habits and the role of urine therein (with relevant slide).

The lowlights and weirdnesses were many and varied. So I’m sure I’m missing some out. First up of course is everyone’s favourite whipping boy, Bill Berk. He has the somewhat dubious honour of being the only speaker who had people shaking their heads sadly as they walked out of his AOP talk. It’s actually odd how many people dislike this guy. He then worked further to cement his professional image in the EJB3 BOF, where he was the ONLY expert who managed to consistently plug his own product and never gave any credit to anyone else (or anything other than jboss/hibernate). It’s a total mystery why the guy works so hard at always appearing to be a socially retarded child around adults who feel awkward that such an inept spastic needs to be invited.

One of the funniest moments however was when some random guy decided to listen in on Rod and I talking. The man’s approach to listening was certainly novel, as it involved moving his face as close as possible to the speaker’s. So there was this guy, his face whipping back and forth from Rod’s mouth to mine, his eyes wild, staring into us unflinchingly without a care in the world. Poor Rod panicked and kept trying to move away, eventually completing a full circle around the table just to try and dodge this lunatic. You could feel the tension rising, it was as if the guy was abount to open his mouth and literally put Rod’s head in it, and Rod knew he only had a few minutes to cope with this impending disaster. On further reflection, the man might have well been deaf and attempting to read lips. Still, it’s surprisingly disorienting to have a person literally breathe on you while you’re trying to make a point.

I also got to give a ‘tech talk’, where I was cornered into saying things like ‘poopoo’, ‘genitalia’, and ‘asshat’. Maybe I shouldn’t make so much fun of berkyboy, as I suspect I’m now just are hirable as he is.

I attended the EJB3 migration talk in the afternoon, which was all a bit too straightforward and no-nonsense so I’m afraid there really isn’t anything worth mentioning beyond one little aspect of the talk. I won’t go into details, but anyone who was there will no doubt concede that this talk contained the absolute best and more irrelevant factoid ever illustrated in any talk this year. Who knew that urination played such a big role in insemination in Canada!

I attended the EJB3 BOF next which was disturbing as it showed that I am pretty much the only guy at TSS who has to maintain EJB2 applications and actually treats said applications with some amount of responsibility. Floyd certainly wasn’t correct when he described the attendees are leaders, a lot of the polls however do tell us exactly what segment these attendees represent. The majority basically seems to be random grunts who have no actual understanding of any sort of higher level view of the technology landscape. They are engaged in a perpetual quest to find the next shiny object to grin inanely at. Even the so called ‘thought leaders’ are more often than not piddly little consulting gig monkeys who think that just because they happen to be able to pimp their open sores crap that the big boys would be doing the same thing.

Eventually I managed to stumble my way into the opensymphony sponsored open bar at the Bellagio. Much alcohol was consumed (surprise surprise) and I spent a good portion of the time pointing out to anyone who’d listen any combination of JSF is dumb, JDO is dead, Sun is weird, Apache is by morons for morons, and other such witticisms. Still, since we’re paying for so many people to get drunk I feel that did earn me the right to clamber up onto my soapbox and pound the pulpit in the general direction of anyone who’d listen.

Eventually a group of us peeled off and headed out in quest of more solid consumables. Much eating and drinking later resulted in the conversation eventually degenerating to the merits of anal sex, as well as various caveats that one must keep in mind for such shenanigans. The weaker members of the group slowly peeled off and crawled into their respective beds, and the hardcore real men (read, those too cowardly to admit they’re tired as fuck and need to sleep) stumbled bravely onwards into another bar. More things were consumed, a surprising number of new technologies were invented (courtesy of Dion and Cedric) and much hilarity ensued.

And so it’s now 5:30am and I should really really follow through on my passing out instinct. I’m not sure I’ll be up for any talks tomorrow as I have a somewhat early flight out.

This talk was fairly disturbing. The whole thing seems to be one big giant apache fapfest as conducted by none other than captain one hit wonder, Jason Hunter.

Jason is, it turns out, a deranged opensores lunatic. He’s not just drunk the koolaid, he sounds like he’s been receiving koolaid enemas as well as injecting it intravenously for quite a while.

For example, he thinks that it’s ‘cowardly’ for companies to consider their source to be part of their IP, and if they ‘really wanted to compete’, they’d hand over the source and then compete!

He then talks through the trials, tribulations and motivation behind writing JDOM, and as expected, it basically boils down to ‘it makes me look cool’, so take that Cedric, more ego-driven opensource! The anecdotes are all about going to interviews and saying ‘I wrote the book! I wrote the api you’re using!’

To his credit, he does proclaim that the GPL is the ultimate evil, with its sick ‘fuck you all! This is MY code and you can’t do diddly squat about it!’

To be fair, the talk is a good overview of some of the issues surrounding opensores and the various licenses and models involved, even if it is from the one of the enema eager crowd.

Unsurprisingly, it all goes horribly wrong in the end. Jason totally loses it and puts up a slide of ‘guidelines for open source projects’. This list has absolutely nothing to do with open source, and it’s pretty offensive how he’s managed to hijack a bunch of common sense guidelines (use a source repository! Have mailing lists! Use email instead of meetings!) and somehow make them open source specific issues rather than standard stuff any project should employ.

The delusions continue in full force shortly thereafter, where Jason proclaims that there are more talks about Jakarta projects than JCP ones. I don’t know what conference you’re at Jason, but the only Jakarta project that has its own talk is Tapestry, which all of 3 people use. Contrast that with a talk about the JCP, twenty nine EJB3 talks, a JSR168 BOF, JSR208, JSF, and a smattering of random open source crap that is most definitely not in Apache (always by deliberate choice, given how broken the Apache committee and voting schemes are).

Some more drug induced gibberish comes out later, where we’re told that the JCP should accept every proposal submitted to it, without any consideration to existing solutions that might already fulfill that need. Basically Jason thinks that the real world is insane enough to build an industry around the zoolike loonybin model that is apache.

Really, I must say I was quite surprised. You’d think that at a talk like this, it’d be a lot more even handed and representative of ‘the other viewpoint’, rather than how childishly naive and simplistic it actually turned out to be.

Next up is Cedric’s talk about TestNG. TestNG for those who don’t know (and why the hell don’t you know what it is, given that Cedric whores it at every chance?), it’s basically an improved and less fucked up version of JUnit.

Now, TNG won’t really address any of the flawed premises of JUnit, it will however address the absolutely retarded and childish way that JUnit is implemented.

The talk kicks off by pointing out the positives of JUnit, but quickly launches into describing how anyone who relies on such a brokenass piece of goatshit is basically trying to run a marathon by first chewing off one leg and blowing up the other while ramming an uncomfortably large baby jesus buttplug (yes, such an implement does exist, google it) into any number of orifices.

For the unenlightened, there’s a whole plethora of issues with JUnit. Thoughtworks cocksuckers will insist that it’s all that way deliberately and will basically slowly insert hot pokers into their dirtboxes simply because junit says so. They’ll also do it with their trademarked shiteating grin and lofty furious arm waving tactics.

These issues range from the fact that each test object is instantiated over and over again for every test method to the amusing need to use statics to maintain any sort of state across invocations. JUnit is also essentially abandonware at this point. It doesn’t really support 1.4 (no assert keyword), it relies on a static programming model (you need to use a fancy IDE, recompile, or other custom crap in order to run a subset of tests), and so on and so forth.

It’s really quite impressive, that such an abysmal product has managed to succeed so well. I’d say that that’s mostly due to the fact that it’s free (so no cost to using it) and that its underlying concepts and principles (on a high level) are very compelling and appealing to all sorts of software development approaches.

TestNG addrsses a number of these issues with varying degrees of success. For one thing, it extensively uses annotations (or jdk 1.4 javadoc comments) for metadata. I have somewhat mixed feelings about this as the jdk1.4 javadoc comment style is SO fragile (ever fucked up an xdoclet comment? It’s endless hours of joy tracking down why). However, it’s a reasonable compromise as Cedric’s initial plan of supporting 1.5 only is clearly about as useful as a project that can only be built with maven.

The runtime configuration is also captured in an xml file, rather than java source. So you’re able to specify test groups and other relationships between tests. This allows all sorts of useful crap like being able to have a specified test run order, dependent tests (test X requires Y and Z to be run first). So for example, if you have some kind of ‘verify db connection’ as the first method, you can specify that all other tests depend on it, so once the first one fails, the others are not run since we’ve had an early failure. TestNG is also designed up front to cope with plugins and extensions, so modifying its behaviour or adding to it hopefully involves less stabbing of eyes and penis mangling that working with JUnit does.

Some of the other nice features in TestNG is that you no longer have to start all your methods with ‘test’ nor extend a base class, since annotations capture the information that that hack has been put in place for.

The annotations available are a pretty rich set of controls to customise and specify test behaviour. You can for example specify a timeout on a per test basis (if this takes more than 10 seconds, soil yourself, etc).

The grouping support is actually quite powerful, since you can arbitrarily slice and dice your test into whatever groupings make sense for you. So for example, you can specify that a test is part of the ‘functional’ group, the ‘config’ group, and the ‘database’ group. You are then able to execute all tests within a particular group. There are many examples of the power of the grouping feature. Another example; you can create a ‘broken’ group that tests that are still being developed for example can belong to in order to be excluded by default (yet still show up as being skipped, so you don’t forget about them a la JUnit commented out tests). This approach craps all over the ‘never check in stuff unless all tests pass’ approach, since it correctly decouples testability from commitability, a bizarre coupling that has become quite popular recently.

All in all, a good introduction of the features of TestNG, and I’d be stunned if anyone with two braincells to rub together would, given the choice, ever pick JUnit over TestNG in future. The only question mark of TestNG’s future really is tool adoption. JUnit’s success can also be largely attributed to all the third party crap that has sprung up around it (coverage tools, IDE integration and whatnot). Of course, given how primitive and childish is it, it’s pretty easy to do all that. TestNG integration into toolsets will require more thought and consideration and well…work. Nobody likes more work, so it remains to be seen if TestNG manages to achieve that critical mass whereby users start nagging their vendors to support it and kick off the snowball effect.

The lunch keynote was provided courtesy of Oracle, and was (somewhat controversially titled ‘Does J2EE (still) matter’.

The speaker however seems to have some very odd concepts of what is and what isn’t J2EE. His example of ‘non-J2EE’ stuff included things like Spring and other such frameworks, all of which would be rather pointless without J2EE.

This actually touches on a pretty surprising misconception that a lot of the monkeys here have. Spring (to cite an example) is NOT a replacement for J2EE. Without J2EE, Spring would not exist. All is it is a extra layer of civilisation that sits on top of the J2EE stack and makes life easier for a certain class of problems.

A good point raised by the speaker also is the difference between how audiences receive open sores crap vs vendor solution crap. An open source talk is applauded for some reason and viewed as somehow being altruistic or noble, whereas the exact same talk delivered about a non-OS product is viewed as an underhanded vendor pitch. There is something particularly revolting about seeing all these talk about custom proprietary solutions (spring, tapestry, random OS crap) being viewed as legitimate in such conferences, whereas closed source stuff being treated as red haired step child that must never be spoken about in civilised society.

Next we move onto saying how great EJB3 is. Gosh, do these people never get tired of this? We get it already, EJB3 is nicer than EJB2. We believe it, lets move on for fuck’s sake. Please please, no more words of wisdom about how wonderfully testable EJB3 is. I’m going to stab the next person who says ‘lightweight container’ in the face with a blunt spoon.

Of course, no EJB3 talk is complete without code samples. Instead of the savvy pertinent snippets that Linda’s talks have (come back Linda, all is forgiven!) we here have huge huge chunks of code that nobody can actually read. This is actually pretty common throughout many talks. What is it about writing code in a small font that’s so sexually gratifying to these speakers?

Having pimped oracle’s EJB3 stuff and convinced us all that JDeveloper is a horrible IDE, we now move onto the joys of JSF.

Oracle has, for some inexplicable reason, developed a disturbing JSF fetish. The speaker is, surprise surprise, one of those dolts who thinks that JSF is there to be written by competent ‘by-hand’ type developers. There really is an idiot born every minute.

The hilarity really kicks off when Ted shows off orablogs. His concept of ‘customisable UI’ is firmly 1998 material. The site looks like someone had a terrible underwear accident, and accidentally smeared the outcome on a webpage. This portion of the presentation captures perfectly a very common blind spot that java web monkeys have. Why, for the love of god, do these people think that a developer should be allowed anywhere near a UI? Most developers couldn’t design a UI if their worthless little lives depended on it. They’re all straight lines and table borders and ‘ooh look at mee look at meee I’m xhtml compatible!’

Even more ironically, his example of ‘how easy it is to write JSF’ by hand does everything it can to prove it isn’t. It requires a custom IDE, the code block for a table is roughly the size of a respectable swing custom component (including painting code). The IDE is all about custom panels for editing properties, and there’s so much JSF awareness that the whole thing makes for a great ‘fuck you java developers!’ demo. They should sell it to IBM in fact, it’s THAT bad.

To add icing to the cake, half the stuff he tries doesn’t even work. I have a lot of sympathy for demos going wrong, but this really is somewhat of a comedy of errors on so many levels. On the plus side, the whole talk looks and feels a lot more relevant given how abysmal Macromedia’s talk was yesterday. So here’s a tip for future speakers, make sure that the previous session the users go to really, really sucks. That way you can fling poo at the poor little bastards and they’ll still feel mildly grateful.

Moral of the story? Don’t buy Oracle, they’re just a wannabe IBM. If you must buy Oracle, you can do penance by sticking any JDeveloper CD’s you can find in as many microwaves as you can find.

Next up is pluggable web apps by jiramike. This is pimping atlassian’s latest foray into open source, this time in the form of a plugin manager thingy for webapps.

This plugin system basically allows you to load in arbitrary jars as plugins. The jar is driven by a descriptor (in the jar), that specifies some versioning info and the main entry point to the module. Interesting for me personally is that internally for epix development, we have come up with pretty much exactly the same mechanism, so I’d say there’s definitely a use for this sort of functionality.

Jiramike then talks through some practical examples. One interesting usage I noted that I hadn’t thought of is the idea of deploying servlets in a module, which would be simple enough to implement via a proxy servlet runner that simply delegates to the plugin’s servlet for a specified url-pattern.

While the premise and functionality all seems very neat and all, there are some rather disturbing issues that show up if you dig a bit deeper. The real issue is that ultimately, the whole thing is a hack. The servlet spec sadly does not really cater for this sort of runtime extensibility. For example, using a custom classloader is highly suspect in webapps, and quite discouraged. Similarly, these modules can’t contain resources like jsp pages, because the spec does not allow for an easy programmatic way of serving up a jsp as a resource. Thus, you’re forced to use moronfodder like velocity for any visual plugins.

Another interesting usecase (well, interesting from a cool hack perspective) is the ability to basically fuck with IoC containers and swap out components with ones more to your liking. While there’s something very disturbing about this, it’s actually a nice implementation of one of the premises of IoC, that nobody cares about the implementations of components, and that as long the contractual obligations are met, you can pretty much slot in any old junk.

I definitely like the premise of having dynamic components within webapps. Any vendor providing a pluggable open system will find a lot of use for this sort of functionality. It’s just a shame that the spec manages to do just enough to make any working form of this nothing more than a clever hack that is crippled in some very critical ways.

Of course, no jiramike talk is complete without pointless selfpimpage. This comes in the form of the last slide, where not only are we told to buy jira and confluence, we’re also told that they’re looking to hire people and that it’s a cool software company to work for.

Still, on the bright side, no other vendor has self promoted in this way so far, so I’ll just chalk this one up to a freak accident. It’s certainly not like Atlassian to pimp themselves in any venue they can now…is it?

In conclusion, mike jirajirajira, jiramike jirajira, confluence jirajira. jira? jira jira, jiraarse! jirajirajiraajijiaaaaaaarfgrfrfira

Last night’s official dinner was surprisingly enjoyable. It was delightful to finally track down some Oracle people and try to get them to justify why their jdbc driver seems to be written by someone who wouldn’t know java if it stuck a cluebat wrapped in the jdbc spec up his bottom. it’s amazing how bad a database company can screw up their own damn drivers.

After shaking my fist angrily (yet politely) at some oracle people, I finally got to meet Craig Mcflanabanawanaflafla. The man doesn’t reek of evil the way that one might expect; perhaps that’s just an indication of the purity and pervasiveness of his evil, it’s hard to tell. Craig’s a smart guy, the only problem is that he wants to marry VB users, and thinks the competent java people should all just burn in hell (at least where JSF is concerned). So yes, JSF is NOT for real java developers, it’s for those paint by numbers by kids (which, to be fair, are by far the huge majority). Really, all you morons insisting JSF is great and usable today for people who like to code by hand (you, Rick Hightower) are fantastically brain damaged and should be put out of your misery for the greater good.

Of course, the dinner was followed by the usual stumbling aimlessly around Vegas, ingesting and consuming all sorts of things that sane people wouldn’t, but such is life.

This morning’s keynote was by Rod Johnson. It’s pretty much a boilerplate J2EE is great, but it’s only great if you put a facade in front of it, namely spring (even though he doesn’t quite come out and say it). It’s also harder now to think that Rod is stuck up his own bottom since he came up to me last night and discussed the chips he does indeed have embedded in his acolytes, and even pulled in one or two and made a show of examining their chips (no, you filthy minded bastards, ‘chips’ is not a euphemism for anything).

However, he does lose it a bit when it comes to saying how opensource is the best thing since the reacharound penistug.

For example, he says that using opensource because it’s getting something for nothing is a bad reason. In the real world, that’s one of the biggest reasons that open source products are popular and used. Why else are projects that are plainly crap so popular? How do you explain clogging, maven, castor, cocoon, jetspeed, and most of apache? All of which exist yet serve no discernible purpose.

He also maintains that OS has a certain ‘pride in quality’ of work. This is also total bunk. The pride does exist in equal measure in the closed source world, if not more so. OS happens (I had this argument last night with Cedric) because of ego. Shy or introverted people will not expose themselves in public via their source. Egomaniacs with chips on their shoulders and a desperate attempt at peer recognition will always release their source if they can get away with it.

He also touches on the whole commiebullshitty ‘freedom of information’. Really Rod, surely you’re too old and wise (and have worked in too many banks) to be snorting from that particular line eh?

Next, he talks about specifications and their role, and when something should be a specification and when it should be left to roam free in the wilderness. I think Rod here has a big fat blind spot to the importance and marketability of specifications. For better or worse, organisations LIKE specs. Given a choice, they’d pick something backed by a spec over something that isn’t (which is why, long term, hibernate will die). Clueful developers might well wave the ‘use-the-best-technology’ flag, but anyone who thinks that works in the real world probably has a fascinating array of drugs swimming around in their deluded little minds. As much as I find this argument somewhat childish and purile, I’m forced to resort to it in this case. People like Rod who aren’t suckling off the spec teat (what is it with that man and nipples?) are just jealous of those who are, and feel (rightfully) threatened by the sucklers.

He also insists that the free market kills bad ideas whereas specs don’t. I think is proven wrong in so many projects. Look at maven. Bad ideas persist because developers are irresponsible and think that an idea is worthwhile purely because their ego tells them it is. You could polish a turd and release it as open source. Provided you get it into apache and suck up to your users, you can guarantee success and many imitators polishing their own poo and claiming that their polishing methodology is innovative and an advancement of the state of the art.

Rod’s hatred of EJB’s is somewhat funny. It’s very unclear why he has this personal vendetta against them. I can only assume that he’s had a bad childhood experience that EJB somehow brings out and makes him relive the trauma.

Next, we move onto AOP. I am totally baffled by why people are still harping on about AOP. Even a poll this morning showed that most people didn’t give a flying fuck about it. Yet these turdy thought leaders are still banging on that war drum. What’s sad is that while AOP itself might not be an exceptionally retarded idea, its proponents have done such an abysmal job of pushing it and marketing it (and doing so way before it can be considered ‘ready’) that I think that many people have been turned off and will now avoid it simply because of the bad stench floating around it.

It’s also nice to see how universally despised and hated JBoss is amongst the clueful. Even Rod, during a keynote, manages to get in some digs at them. Nobody can deny that JBoss is successful, however, one can only hope that the fact that so many people wouldn’t stop to piss on them if they were on fire will count for something, in the long run.

Rod also manages to rise slightly above the ‘we’re great, you’re great, I love the depth and size of the cavity up your ass’ mentality at TSS by suggesting that people go out and do other things that’d make them more successful. Examples include….communication skills! Reading The Economist! Stuff that’d no self respecting geek would ever do, sadly.

Feeling a tad more refreshed after a quick powernap, I am now ready again to be bored to death having more old news regurgitated at me. Thus, I head to the EJB3 talk.

Of course, this is the same EJB3 talk we’ve always had. The same song and dance; if you’ve been to one EJB3 talk, you’ve been to them all. The additions in this talk are basically an overview of the new stuff in the second draft, including interceptors and whatnot.

So I’ll sit here for the first half then head on over to the scalability talk and see if Patrick and Cameron manage to avoid trying to sell either the most expensive HashMap in existence or a dead end EOL’ed persistence technology.

Turns out I missed yet another stellar performance by Bill Berk. I did however get many interesting reactions from that talk, ranging from his awful presentation style to the lukewarm audience, concluding with bill’s amazing dodge’em game when it came to non-jboss worshippy questions.

So I head over to the scalability talk. So far, this actually seems pretty decent and spells out a lot of common sense and obvious tactics, highlighting facts like transactions being bad, and read-only data being very cluster friendly.

Despite spending a lot of time with Cameron, I hadn’t actually heard him speak before (he’s very big on subtle talks that boil down to ‘buy my hashmap’ which I find rather boring/repetitive). I must admit that he’s a pretty good speaker, and his jokes are somewhat amusing (even if the dullard audience didn’t think so, bastards).

Another nice aspect of this talk is that for a change, it isn’t about how to write a CRUDy my-first-intranet-webapp. Surprisingly for TSS, this is actually a discussion of scalability in enterprise applications. They also get plus points for harpooning junit and pointing out that it’s rubbish. An interesting point Cameron raises is the false sense of security that unit tests can give, and the general fallacy of single user style testing, and how doing that sort of has absolutely nothing to do with scalability testing. Again, pretty obvious stuff, but it’s nice to have it expressed explicitly like this.

Of course, the biggest plus of the whole thing is all the sexual references. It’s really hard to go wrong when you have a slide called ‘Dont Wait for the Load to Blow’.

The lunch keynote, as expected, is the bit of the conference where TSS allows a vendor to shovel their own sweet brand of doggiepoo down the poor developers’ throat alongside other things that are only slightly more digestible.

This year, again, we get more woowoo’ing about Macromedia Flex. The speaker is a ‘technology evangelist’ which of course is a code word for sales drone.

The man has an unhealthy fixation with rich clients. In fact, his obsession with the word ‘rich’ is bordering on the obscene. Hard as he’s trying, he’s simply unable to formulate a sentence without that word. He’s rich, we’re rich, the applications are rich, resources are rich, images are rich, data is rich, rich media! rich experiences! rich rich rich! Anything that isn’t rich is ubiquitous, most things are both rich AND ubiquitous. A veritable fapfest of richness.

No macromedia flex talk is complete without the requisite demo or two. The only thing that all these flex talks have done so far is convince everyone that it’s a great demo tool. Of course, if you’re the kind of problem who doesn’t mind splashing out $10k/cpu for an essentially proprietary toy demo creator tool you have more serious problems.

What is impressive (and somewhat galling though) is that the guy seems to be reusing the EXACT SAME material he used last year. It’s as if time stood still for poor Macromedia, and nobody bothered cc’ing them on…well….anything.

In fact, this talk is so deathly boring that I am going to go to sleep. Such is my boredom that I am in fact going to skip the next session. The coma I am gradually falling into is going to be sweet, deep, and blissfully flex-free.

Surprise surprise, xmlhttprequest is the star of the show here. All sorts of flailing about invoking changing paradiggums! The talk is mostly about ajax, and convoluted explanations about the lifecycle of such apps (xmlhttprequest, javascript, yawnyawn).

The first ‘hello world’ example involves, interesting, neither a hello nor a world. it’s one of those horrifically ugly web pages that lets you input a city name and it goes to get the zip code (you’re shit out of luck if you’re outside the US). We’re shown a walkthrough of the code which looks pretty from a distance (the font is actually too small to see for the cool kids who like to sit in the back). While it’s nice seeing a concrete code example and all that, I’m not sure it’s really worth talking through every line of javascript.

To while the time, Sam Pullara and I are playing a fun game of ’spot where this slide was stolen from’. I’ve spotten a graph lifted directly from the ajax intro page, and Sam has spotted a table lifted directly from Apple docs.

Next up is a dissection of google maps. This is mildly interesting, but of course the google circlejerk commences almost immediately with lofty claims of google maps…THE PLATFORM!

Continuing on the google penis tugging theme, next we’re told how spoogy google suggest is. Yawn. More examples follow, some of which are actually mildly interesting (eg, using this mechanism for comment posting on TSS, or managing admin queues etc).

Dion being one of the speakers on this, it was only a matter of time before AOP got a mention. This time in the form of AOP JAVASCRIPT!

Finally, a sensible conclusion that all this stuff is new, and that people are still feeling their way around it all and trying to figure out how not to view it as the hammer to end all hammers. There’s also a decent spot about the fact that debugging this stuff and writing it sucks ass right now, given the poor quality of the toolsets available (or not, as the case may be).

All in all, the talk is somewhat interesting, if only in terms of the options and examples it offers. For people interested in this sort of crap and with lots of spare time, there’s plenty to get off on and run along and play with. Dion also did say ‘anal’ which is always nice.

My one complaint about all the talks so far is that they’re too damn long. Expecting a normal person to sit still and listen for an hour fifteen minutes is asking an awful lot. Most people in the audience at this point are either doodling, nodding off, drooling foolishly, or surfing porn. The talks also seem very insensitive to us poor bastards who are struggling to function with a mere 4 hours of sleep.

Next I thought it might be a laugh to attend Craig Mclanaflanapoopoo’s talk. Of course, he kicks off by telling us a bit about himself. Gosh, this guy has a lot to answer for. Tomcat, struts, JSF, so much of what is evil in the world these days is due to this one bearded guy.

The talk at this point is quite high level. There’s a brief digression into bizarro world where Craigy tells us all about the JCP. Coming to think of it, this is a bizarrely titled talk, combining the development of webapp API’s and standards for java. So the first half seems firmly about the process aspect of it.

I guess all in all the JCP stuff is pretty standard and I guess interesting to anyone who doesn’t know it. Next up he’s discussing the relationship and impact of open source on the JCP, following by Sun’s impact and role within the JCP. He does give an abysmal example of the current JDO fiasco, forgetting that it’s just about the worst example to bring up if the point is ‘Sun doesn’t control everything!’ since Sun wanted JDO, it failed, so they basically decided to revote until it passes. As an aside, I wish someone would just set fire to the JDO people and rid us of them for good (yes, Robin Roos, you’d be the first kindling).

We’re now onto the web portion of the talk. Again, spitting on Floyd’s assertion that attendees are a bunch of clever clogs, Craigy tells us what ServletContext is, what Servlets are, and even an explanation of…JSP pages, starting with the first implementation, and taking in the changes and modifications that have happened up to and including the current spec, 2.0.

Sadly, I don’t even have another session to run to for comfort. The other two sessions going right now are some crap about unit testing (are people STILL going on about that?!), and Jason and Patrick’s usual one trick pony, WebWork2.

Uuurgh, Craig now tells us how great Struts is. How it’s a ‘de facto’ standard, and twists one of the earlier polls by Floyd whereby 50% of people said they used Struts by saying that ‘50% of people PREFER Struts’.

I doubt anyone sane would actually prefer struts to anything. There are two kinds of struts people, those too stupid and simply don’t know better, and those who are forced to use it because they work somewhere with a stupid decisionmaker who doesn’t know better.

Craig, surprisingly, does seem to live in some kind of lalaland where struts is great and everyone loves it. His perception of what makes it great is also interesting, and attributes it to various technical and market forces (half of which are, frankly, quite contentious).

He also then points out that the success of Struts led to jealousy. It’s an interesting interpretation of what actually happened (and is happening). While all of its competitors are jealous of the market share, I doubt they’re jealous of it in any real sense beyond that. I don’t think he quite realises the frustration and anger that people feel at the fact that struts is popular, given how craptastic it is. I mean, websphere is the most popular appserver out there, but I dare anyone to find a developer who actually likes using it or thinks that it’s a good product.

To be fair, Craig does understand the stupidity and mindset of open source developers, and uses this to his advantage. He freely acknowledges that the best technical solution is not the one that ‘wins’, and that that’s a small factor that is more often than not, quite irrelevant. Nor is running a project for the benefit of its developers (vs the users) any kind of recipe for success.

Overall, the talk is an interesting overview of standards and how they come about, as well as some (dubious) musings on the success of struts and justifications for that success.

I’m going to head to ‘Next-Gen offline capable web apps with html and javascript’. If the whole talk ends up sucking google penis and discussing how xmlhttprequest will bring about world peace, I might need to shoot someone.

The keynote, much like any keynote, involves an awful lot of self congratulations. Floyd tells us how great TSS is, what an industry leader TSS is, and how absolutely delightful, bright, impressive, and thought leading the audience is.

Once the initial round of we’re you’re, you’re great, we all love each other is over with. It’s time to pay homage to techtarget’s buyout of TSS, with some gizmos that let the hapless audience vote in real time to various questions.

The little gizmo allows one to vote onj questions posed by floyd on various relevant topics, ranging from preference of Star Wars vs Star Trek (WHICH Star Trek dammit! What the hell should I vote if I love TNG but despise all the others??)

What is interesting about the results is that they reveal that Floyd’s premise of the audience being thought leaders and innovators and all round smart kids is, plainly, rubbish. The morons all seem to use Struts, Eclipse, and over half of them think java should be open sourced.

Sorry Floydy, your audience is, as one might suspect, a bunch of fuckwits.

Next up we have Mark Hapner. As anyone who has seen Mark speak, he’s awfully bright but also a fairly abysmal speaker. His delivery is so deadpan that as far as the listener is concerned, it might as well be in a monotone that never varies in pitch or volume.

Suffice to say, we’re at the first slide and I’m alredy pondering if this might be the right moment to take a sorely needed nap to help defray the physical cost of the requisite stay-up-until-4am-with-java-lossers-insisting-junit-sucks-ass session last night.

Mark dutifully waves his SOA flag, with the first slide subtly avoiding the dreaded acronym yet still managing to casually slip in ’services’ in a number of places.

It’s pretty interesting that Mark has avoided coming out and admitting that he’s pimping SOA. I suspect that he’s cottoned on to how deeply unglamorous and unsexy those three letters are.

So in order to avoid passing out or gnawing on various appendages out of sheer boredom, I am going to digress and discuss those Spring freaks instead.

What the hell is it with these people? The cult of Spring is disturbing yet fascinating. Taken individually, the members are sane, coherent, and pragmatic. So why do they insist on behaving as a hive? Really, why must they cling to one another so? They go for drinks together, they marched into the keynote together, and I suspect they all share a room. One can just imagine the goings on in this room of horrors. Poor Rod Johnson perched on a platform oiled and naked, with the acolytes twirling around him as humble supplicants, hoping to gain succour through his puny (yet holy) manboobs. Genuflecting wildly, no doubt coupled with some disgusting sexual practices and flinging of genitalia with gay abandon.

Come on folks, sure, you’re better put together and a lot more rational than the JBoss people. You’ve mastered the art of not frothing at the mouth in public, and most of you seem well potty trained. Really though, it’s just not healthy for a bunch of grown men to need this level of physical proximity to one another. Questions of sexual orientation will arise. The cuteness factor of pretending to be little ducklings hovering around a mother duck wears off very quickly.

Back to the keynote. It’s question time and as predicted, nobody seems to grok the armwavingy aspects of SOA/JBI/services. The first questioner wants to know how all this is different from webservices backed by EJBs (no satisfactory answer beyond ‘it’s bigger! It’s more! It’s shinier!’)

I think one of the flaws of Mark’s talk is that he’s forgetting (or is unaware of) his audience. They aren’t, as Floyd would like to think, clever leader types. They’re just everyday grunts who have enough spare time and meaningless enough jobs that they can fart off on TSS every other day, interspersed with the odd person who has been sufficiently beaten with the cluebat.

The whole SOA myth makes for a great sales pitch by IBM types to high level ‘architect’ types whose job involves little more than doodling with crayons and going on IBM sponsored golfing trips. It does not, sadly, translate well to gruntspeak. us grunts are simple folk, we like code examples, we like concrete classes, and by god, we like xml. Anything else and most of us will be flailing about helplessly trying, and failing, to relate to the subject matter.