Blogs with your Eggnog

I just love reading Ted Dziuba's blog.  The guy has a way with words and to top it off, a wonderfully cynical sense of humor.  The latest post goes over his method for spotting engineering talent.  Specifically, how he determines who is and isn't a valuable engineer (his formula is valuable = smart + productive + battle-tested).  He gleans the most information by figuring out what pisses the candidate off.  Particularly if it's some piece of a technology that they otherwise enjoy.   Good stuff.

Another of my favorites from the blogosphere is Kitchen Soap, an operations focused missive which subscribes to the development/ops (Dev/Ops) philosophy (sadly, it's a philosophy that is a long ways from catching on in most corporate IT departments).

Nutrun (gotta love it for the name alone) is another I've been perusing of late, especially the post related to incremental deployment, since large scale deployment with lots of moving parts has been an increasing interest of mine.

I see Spring 3.0 went final.  I still think Spring rocks, but there is increasing grumbling that the lightweight rebel who helped depose the bloated, self-satisfied Java EE king is itself getting a little bloated and self-satisfied (maybe there's some fear regarding SpringSource's new VMWare master and what it'll do to the technology).  Meanwhile, Java EE 6 has come out after a good while in the gym looking much more fit and useable again. Perhaps ready for another run at the crown?  Maybe.  I wouldn't go quite so far myself just yet.  Like I said, I still think Spring rocks.

Speaking of Spring, I can't wait for it to get here - already sick of snow not even two days into winter ...

Nothing new under the sun (perhaps I should say "under the oracle")

It's been a month since I've posted here and I sense this Technology Blather feels more than a bit neglected (especially if it's found out how active I've been on the other two non-techie blogs I maintain).  Frankly, I just haven't been feeling all that passionate about the world of technology lately - nothing has really floated my boat and gotten me fired up.   I'm always interested in unique solutions to web-scale capacity and concurrency problems, and data integration sort of falls into that bin for me as well.

I've been piddling around with Erland and Scala around the house and checking out what folks are doing in the world of web and object caching for large-scale distributed systems.  But nothing to write home (or, more specifically, to write here) about.

Gregor had an interesting post just a bit ago.  Gregor doesn't post on his blog a whole lot, but when he does, it's always worth reading.

Ted Dziuba is entertaining as always and introduced Milo.com late last month.

Dan North talks about two of my favorite software development approaches (one pattern based and the other process based) and shows how they are in so many ways very much made for one another.

But none of this is new under the sun - all of it is great but nothing earth shattering.  I'm hoping for good things come 2010 ...

More unique insights from other people's minds

Uncle Bob recently posted his thoughts on test driven development couched in a critical light.  Not critical as in negative (this is TDD and Uncle Bob, after all).  Rather, critical in the sense that he attempts to ask those questions usually posed by TDD skeptics and then proceeds to answer them.   I usually enjoy Uncle Bob's writing, but this one struck me as particularly well done (I really like its perspective).

There's an excellent presentation floating around of a keynote Google's Jeff Dean gave on building and maintaining very large, very distributed systems.  It's pretty good.  If you work with large scale systems, you should read it.  In fact, even if you don't, you should read it (it's likely you eventually will).

Other Peoples Words (a lazy man's perspective)

Some really great tech articles this week that I'm digging on ...

• Closing the Gap Between Apps and Operations (this gap is one of my pet peeves)
• Cucumbered (I can never get enough of this framework - love it)
• Deploying to Production Every Week (and the discipline to be able to pull it off)
• Spring 3.0 RC 1 Overview (a good overview from one of Spring's two Dads)
  
• More Meta-Metrics (I love everything about this blog, but especially the attitude)
  

She's a brickhouse ...

I'm digging the idea of Sitebricks and plan to take it for a test drive this weekend.  Maybe it'll reinvigorate my energy for web frameworks that has been exhausted by plethora of offerings out there, most of which seem pretty darn similar despite all their claims for uniqueness.  Even if I love it, though, it's unlikely I'll see it much in the enterprise (where I tend to spend my daytime hours).  Also, it would have to be pretty amazing - and different - for me to get over my anger a them for developing yet another web framework.  My bookshelves are getting heavy (even my virtual bookshelves have a weight limit, measured more in the strain on my eyes and frontal lobe than mass).

Passive-Agressive Developer Personalities - which one are you?

If you don't follow Ted Zuiba's blog, I recommend you check it out.  I love his sardonic sense of humor.  He can be pretty brutal with this commentary.  But, really, that's what's great about it.  Also, he's got some pretty cogent advice.

As per usual, there's some interesting work afoot on the Agile Web Operations blog.  The latest is a great one on development team motivation.  Or rather, the supposition that development teams don't need motivation (they're already motivated when they come onboard, that's why they accepted the job offer).  We simply need to actively stop de-motivating them.  You might say this is just arguing semantics, but I think the difference in perspective is illuminating on many fronts.  At its heart is the notion of developer as thinking individual who takes an active interesting in learning new things and advancing their capabilities.  Developers who don't treat training as a 'let me just sit back and let the teacher wash this know-how over me' but rather 'this is a chance for me to learn - learning is the active verb here more so than teaching'.  I think you want to weed the passive 'teach-me' types out of the organization in favor of the 'let-me-get-in-there-and-learn' sort.

But that's just me.  If you disagree, perhaps we can start a developer exchange program.

The Spinning Continuous

Martin has posted another interesting musing on Feature Branching. It's particularly enlightening on its coverage of the thorny problems related to this practice with large scale concurrent (and sometimes conflicting) development - the Fear of the Big Merge - and how Continuous Integration can help.

Martin points out that the more recent Distributed Version Control Systems (DVCS) such as Git have largely solved the visibility and understanding of syntactical or textual differences when merging but they can't solve the semantic differences. And they aren't any help when refactorings have renamed, reshaped and morphed classes, methods, etc. The pain of the Big Merge make folks reluctant to do the refactoring necessary to keep the code clean and relatively free of technical debt.

Martin's answer: a variant on the old joke 'Doctor, it hurts when I do this.' 'So don't do that!'
If the Big Merge is painful, don't do the Big Merge. Do a continuous small merge and then when there are semantic uncertainties, communicate with the developer(s) working in that area. Use CI to do the small merges and use your voice and brain to do the communication part.

Simple, perhaps obvious advice - but the best kind usually is and it never hurts to hear it regularly.