The BileBlog

The 2nd day of TSSJS was, frankly, abysmal. Other that jiramike’s talk about pragmatic clustering (which despite its promise, mostly involved recommending orasol), there was absolutely nothing that was interesting enough to even go in and bile. The content was fairly dire, why would anyone think that ‘better javascript with prototype’ is something worthy of discussion in this day and age?

Rod gave yet another Spring 2.0 talk. Exactly how many of these do we need anyway? As if a Spring 2.0 generic rodtalk wasn’t good enough, it’s a repeat too from the day before. Is there anyone out there who still gets excited about a Spring 2.0 talk? I for one was much happier staring blankly into space for the duration, it was far more satisfying and educational.

Cameron gave the same tired old clustering grid scaling productpitchbutatasuitabelytangentialangle talk, which I’m sure was very pleasant.

It’s worth at this point pausing to consider the utter crapulence of the panels at this TSSJS. The ESB panel for example was manned by, you’ll never believe it, ALL ESB VENDORS! Gosh, I wonder what they had to say. At a wild wild guess, I suspect they all think everyone should use an ESB. The OSS panel was similarly staffed with people from companies who are busy seeing how rich they can get from OSS, rather than any consumers of OSS or someone without a vested interest.

The Alfrecso guy on the OSS panel was in particular an impressive douchebag. He merrily proclaimed that all software will be either services or OSS. Amazingly, not one other person on the panel called him out on it. Needless to say, this proclamation was pretty upsetting to the majority of people there, who were, on the whole, not living off of OSS or software-as-a-service. Still, not surprising considering the guy ran Documentum, one of the disasters that befell this industry that we still haven’t quite recovered from.

The third day’s contents were marginally better, though I got roped into being on some random panel where we all got to feel important and pontificate pointlessly about more or less random shit.

Overall, the best part as usual was the socializing. It’s a shame that that sometimes entails nipples being tweaked and genitalia reached for(grrr, you know who you are), but one can’t let the small stuff like that get in the way of a generally good time. The best part by far of the whole event was venturing to downtown Vegas and kickin’ it oldschool.

Conference wise, it would have been nice if a miniscule amount of thought were put into the scheduling and selection of content. For example, the last sessions on Friday were all in the same sort of field, so if you wanted to go to one of those, chances are you’d also have been interested in the others. Yet the powers that be ensured you couldn’t do so. The whole thing had far more of a corporate than community feel, which is a terrible shame.

Trotting out the usual suspects to do their repeat talks from last year is tired and tedious, it’d be nice if the brand name speakers did a little more than just show up and recite a talk they’ve done 50 times so far. So please, no more Spring 2.0 talks, though I suspect the opensource track gurus at JavaOne probably have that exact same talk scheduled, bless their dirty little socks.

I’ve finally moved off from JRoller, after almost four years of pain, suffering, tears, blood, sweat, and putting up with one of the worst pieces of software ever to grace javaland.

I’ve always wanted to move, the reasons not to however were:

• Too lazy: Inertia is a wonderful thing, and I have better things to do with my time that faff about trying to install some kind of bloggy thingy
• jroller sorta worked: I could post, people could view stuff. What more could a guy ask for?

Of course, the straw that broke the camel’s back is that referer logging has been turned off for months now, so it’s impossible to find out what’s bringing people to the bileblog (if anything at all), or whether anyone still read it (sniff).

I would like to thank Matt and our Fearless Leader Rick Ross at JavaLobby though, for at least pretending to care every now and then, ultimately though the roller app was just so abysmal at doing anything, so ugly while doing it, and so incompetent in the odd occassion when it did manage to do something, that it was just impossible to get anywhere.

It’s a sad statement on the Java world, that our main offering in the name of blogging platforms is so horrific and useless, with about as much sex appeal as a cocktail of Rod Johnson moobmilk, Bill Berk pantycrust, and garlic scented Fluery gavinguice.

Bitch and whine about the new site in your comments on this post, and I’ll dutifully ignore it all, just so everyone is comfortable and to show you that nothing has changed.

Anyway, the rest of the TSS coverage coming up soon hopefully.

The last talk I went to today is Enterprise App Mashup: Architecting the Future by Eugene Ciurana.

Of course, the talk is as fluffy and pointless as I had expected. I walked in late because the likelihood of anything vaguely interesting being said was fairly negligible.

The one thing Eugene does excel at is name dropping. Whatever he did at walmart clearly involved next to no ‘real’ world, and a lot of musing and faffing about with whatever toys happened to catch his fancy. In many ways, it’s a dream job. Wouldn’t it be great to have a job where you get to fuck around with whatever you want, without ever having to achieve or deliver anything? Without naming names, there seems to be 2-3 jobs like this in this industry, held by vocal public personalities. Yet more proof that it’s a cruel unjust world.

The core problem with this talk is how nebulous it is. We get the usual ESB flagwaving, that same tired old diagram of a centralized bus and how we’re moving into a happy new world of no point to point, anyone and everyone plops their turdy nuggets onto the bus, who will magically and mysteriously only deliver it to other applications that want to gobble up said turdicles. The clever thing is that there still seems to be some people who haven’t tried this approach ,and still don’t know that if applications aren’t written to talk this common language, you end up writing a zillion adapters, thus having the same ball of spaghetti, except that you’re now also now beholden to a bunch of dubious shady people who now happen to own your centralised bus.

The ludicrous example we have is making two applications communicate, one of which talks JMS, and the other talks SOAP. Now, has anyone ever come across such a situation? Where they just happen to have message structure that’s similar enough so all you’d have to do is drop in an ESB and now the world is magically wired up?

It’s just so astoundingly stupid. One of the most impressive cases of the emperor having no clothes since SOA. Speaking of which, I went to the SOA panel which was equally depressing, services are pretty much….anything. It’s a testament to the power of salesmanship that anyone is able to actually sell this crap.

It’s very clear that Eugene spent a couple of days playing with Mule (ESB), and thought that he’d give them a shout out as some kind of benevolent godfather type at Walmart.

Even more ludicrous, he recommended that people use…JavaSpaces. Good lord, is it 1999 again? He even mentioned it as a sane alternative to JMS. Good thing everyone is going to ignore everything he’s saying, so no harm done I guess.

The talk title certainly didn’t disappoint, the talk is so full of shit, so pointless, so inapplicable to anyone that it’s impressive that a human being can actually stand up for an hour and make noises in vague sentence structure about it.

Gotta give the man credit though, he has nothing to say but delivers it with style and authority, it’s easy for people to end up thinking they’ve attended a good talk, because the speaker was friendly and engaging and spoke well. The fundamental flaw is that HE SAID ABSOLUTELY NOTHING. The talk basically revolved around how great the speaker is, how he’s bought expensive hardware because he’s so cool, how he knows so many people and vendors, and how some of them lined up for a glimpse of his holy genitalia.

Sometimes I’m a bit of a glutton for punishment. You’d think that after attending so many conferences, seeing so many JPA drivel talks, I’d stop. Alas, I can’t seem to help myself. and am dismayed to find myself sitting in Advanced Topics in JPA by Mark Richards.

It’s evident that the use of the word ‘advanced’ was somewhat liberal in this case. All we’ve done so far (20 minutes in the talk) is discuss the joys of join tables, entity relationships and how to define them. I shudder to think of what Mark would consider to be an ‘intro’ talk. Perhaps a 20 minute discussion on the benefits of casting? The benefits of coding with eyes open and thumbs out of anuses, to maximise JPA productivity?

Even more worrying, he actually makes JPA config look so much skankier than it actually is. Switching from hibernate to toplink for example in his case seems to require changing 20 lines of Spring xml. Spring? Yes indeedy, he managed to sneak SpringSpringSpring in there! Either Mark or Spring is pretty fucked up if changing implementations is so much work (it’s the former, incidentally).

To his credit, Mark is actually a good speaker, he’s just cursed with abysmal material. OHMYGOD, he didn’t just…..OHMY…

This is a brave move indeed! Totally unexpected. We were happily traipsing about in many to one land when BOOOM! He brought in…MANY TO MANY! There’s an inaudible gasp from the audience at his sheer gumption and audacity. What will this crazy guy do next? Drop his pants and moon us? Masturbate into the first row of attendees? I might explode from excitement and anticipation.

As if that excitement wasn’t sufficient, this crazy man just tossed in fetch types. I’m going to need a nap shortly to recover from this.

Oh wait, all is not lost, he actually mentioned something interesting (honest). Throughout the demo, he seems to pointlessly switch from Hibernate to TopLink for no reason, but this finally paid off with showing (what he alleges) a non-compliance by Hibernate, which apparently doesn’t support fetching multiple collections, which the spec says must be supported. We switch to TopLink and all is well.

Next we’re covering compound keys, which I guess is finally venturing to the realm of potentially non basic trivial features, too little too late I’m afraid. The one thing I am enjoying about this talk through is the hibernate bashing. He’s showing fairly standard JPA usage, no custom stuff, yet hibernate seems to shart itself pretty regularly as a result. The latest example is that @IdClass is basically broken (and yes, that’s been my experience too). I do like the advice that once hibernate takes a big dump, it’d worth switching providers just to see if it’s because hibernate developers are cocksucking chozgobblers, or if it’s you who is being a muppet.

Finally, we cover stored procedures, also pretty interesting and I’d say something that does qualify for advanced usage.

All in all, I’m not nearly as angry about this talk as I was in the first 20 minutes. It started off with boilerplate JPA but did eventually manage to eke out some useful info. A speaker who seems interested in his subject and is coherent is such a refreshing change as well, even though he does smirk a lot.

Depressingly, despite making a somewhat valiant attempt to get enough sleep, the night before TSS ended with the usual mix of drinking, stumbling about helplessly, and stay up until 3:30am. Last year the question to inflict on poor unsuspecting victims was ‘have you masturbated on a plane’, which surprisingly 50% of people seem to have done. This year I’m hoping to get a good list going with ‘what deviant sexual act would you pay $10 to see if it were socially acceptable’.

The keynote in the morning kicked off with the usual fumbling intro, with the TSS guys clearly looking like they’d much much rather be somewhere else, possibly somewhere very far away.

As usual, the audience polling thing was a total and utter shambles. It’s 9am, there’s no way I can count down a bulleted list of 7 items to figure out what number I should press. Which genius though that a bulleted list is a good way of displaying numbered options? Even more depressingly, as I finally figure that out and start furiously jabbing the appropriate button, the handheld piddly pile of poop steadfastly refuses to acknowledge my pitiful attempts.

The one mercy is that there were very few of them compared to every year. Interesting it turned out to be yet another venue where they managed to sneak in vendor content, asking a bunch of java devs whether they’re interested in DTrace or ZFS is a perplexing choice, certainly.

The actual keynote by Eric Gamma was, basically, enough to bore even the more excited of attendees halfway to death. Maybe it’s because I’m not an Eclipse user, but really, 10 minutes of discussing the benefits of OSS and what it means to have a community, how it’s all so wonderfully transparent, and how it’s better for your genitalia than a penis pump is a bit…twee, at this point. How many times do we need to hear? Yes, we get it, OSS is as satisfying as openair hot lesbian twin live action with many toys; lets move on already.

Part of the problem is that Eric, while I’m sure is a frighteningly smart guy, is a fairly abysmal speaker. I’m having to work very hard to actually listen, but I’ve found that it’s way too easy to let him become a mildly annoying background noise. Coupled with the miniscule font on the slides, this ensures I haven’t a hope in hell of figuring out what’s going on, why it’s going on, and when’s it going to stop.

The talk is supposed to be about Jazz, and we’re halfway through the talk and I still have as much information about what Jazz is as I do about the contents of Bill Burke’s panties (eeeurgh, even I winced at that lurid image).

The one interesting thing I guess is the release management arm waving, and all the boring crap that goes with it, its impact on development velocity, marketing, metrics, blahblah. Still no clue what Jazz is, but maybe we’ll find out soon!

We finally find out that Jazz is some kind of collaboration thiingyboggy. Unfortunately, many people have already chewed off their own heads in sheer boredom, so it might be a little too late. Still, maybe something can be salvaged!

From what I can gather, it sounds like a more pretentious and happy agile noises version of TeamCity with better role and team management (at least to the marketing blurb we’re being subjected to). Team collaboration junk, better isolation, scalable, blahblahblah. I’m still angry that yet another hour of my life has gone down the drain.

Ultimately I guess the only people who don’t want to kill themselves just to end this talk are probably Eclipse developers (not users), who likely could manage to keep themselves sufficiently entertained by masturbating in the stage’s generation direction for this infinitely long hour.

The fact that XML is, basically, a steaming pile of goatshit is not news. Many many people know this now, yet you have an awful number of people eager to grab a hold of some xml and perform deviant sexual activities in it, around it, and in between its elements.

The problem is that there are some good ideas out there that happen to use xml. Even though xml has nothing to do with the quality of the idea, xml somehow gets credit.

This has become quite apparent lately when participating in some Guice vs Spring debates. The fact of the matter is, Spring’s XML sucks unbelievable amounts of ass. Don’t buy the bullshit hype of Spring 2.0 improving its XML so it’s now all great. All it’s done is made it plausible that one might not jab oneself in the eye with a big black ribbed for his pleasure dildo when confronted with it. I cannot believe that a sane person would think that the Spring 1.x syntax is fit to deposit a big dogturd on, let alone use in any application you’d care to be associated with.

I like Spring. I like the integration features it offers. The XML however is revolting. The IoC bits are about as pleasant as using a bucketful of Rod Johnson’s moobjuice as anal lubricant. You either have to autowire (which is convenient but too magical as your project grows, not to mention fragile), or explicitly wire stuff in xml, miles away from the source code. Lets not even get started on how abysmal performance is once you’re using a real project with more than 3 beans, or heaven forbid, wiring up actions at runtime. You could play many a game of soggy biscuit while Spring figures out who needs what, when, and why.

Of course, the situation is conveniently disguised by the fact that tools such as IDEA natively grok Spring’s hellish configuration.

No doubt someone will counter with the fact that thousands of people use Spring and all is well. Yes, thousands of people also used EJB2, oddly enough the very same places that switched to Spring. What are the chances of all these venues suddenly becoming full of wise intelligent developers who from now on will only make sensible sane well considered decisions?

As a result, Spring is hopelessly fucked due to its success. It can’t really drop support for crappy old JDK’s (contrary to what everyone tells you, banks ARE using JDK 5 now), so will always be lumbered with its current idiotic configuration and wiring approach.

That problem makes it somewhat understandable that the Spring guys, in order to defend their fuckeduptheassness, deride annotations and proclaim that declarative xml goop is Rod’s Holy Word. Go forth and write xml, Rod proclaims, and the unwashed masses go forth and positively ooze angular brackets. Stupid fucks. Still, all is not lost, in cases where it’s possible to shoehorn annotations into Spring’s archaic innards, they’ll enthusiastically proclaim it Useful and Recommended, such as the @Transactional annotation.

The other common argument is ‘you don’t spend too much time in Spring’s xml compared to time spent in your code’. Sure, I also didn’t spend much time writing ejb2 descriptors either (xdoclet did it), yet everyone bitches about those. Why can’t we apply the same standards to Spring?

Fundamentally, Spring has a tough time accepting that the world has moved on, and that its approaches are starting to look a wee bit outdated. Even EE 5 in many cases looks more modern and usable than some of its approaches. Thanks to its widespread use, they can, much like the JBoss people, maintain an insular world view where they’re surrounded by sycophants who do nothing but bend over with a shiteating grin plastered over their sallow filthy faces.

So do yourselves a favour Spring guys, and stop being so obsessed with where you are now and with how much you can do with AOP (which nobody cares about, it’s not 2004 anymore so move on), and instead look around with an open mind and embrace annotations like you’d embrace a Rod Johnson penis replica. Your configuration bean bullshit still doesn’t cut it, dependencies are best expressed where they belong, in the damn source code itself.