Netflix: The King Of Stupid

It looks like Netflix has joined the ranks of companies whose own stupidity has run them into the ground (Nokia and RIM being prominent examples).

Not only they've screwed up their user interface, pissed off a million of their subscribers by spilling their lattes (which is better than expected, though), and lost a good deal of movies I wanted to watch.

Now they're trying to erase the very memory of it.

To whom it may concern @Netflix: I spent my own precious time to hand pick those movies over years, you dumb<censored>. Those titles were important to me, because you're not the only game in town and I wanted to watch them regardless of wheter you had them or no. Now they're all gone.

Of course, as the saying goes, fool me once, shame on you, fool me twice, shame on me. My own fault.

I guess I'd be killing off my Netflix account completely pretty soon.

PS: Now that I've saved their queue page so they can't steal more of my time and looked at it thinking how to automate the title extraction, it is very clear *why* their new user interface is so inefficient. Just take a look at the page source and try not to laugh. Hint: they could save about 40% of it just by removing unnecessary spaces and endlines. Forty bleeping percent.

PPS: This one-liner works just fine:

cat instant.html|grep -A 4 "class=\"title"|grep -v "\-\-"|grep -v span|grep -v "class=\""|sed 's/^[ \t]*//'|grep -v ^$

PPPS: "netflix alternatives" on Search Insights, Search Trends - impressive, isn't it?

Mysteries of Modern Software Engineering

How can a person claiming 10+ years of software engineering experience not know what RTFM is?

What You Get If You Are A Paying Customer

Too good to pass (click to enlarge):

A Special Place at The Ninth Circle of Hell...

...must be reserved for Lotus Notes developers that did not provide a way to change a font size.



It doesn't matter whether you have a cheapskate 14" laptop with 1024x768 screen, or a decent 24" 1920x1200 flat panel - either way, you're condemned to stare at those microscopic letters till your abused eyeballs pop out of sockets and roll down the table.

PS: And don't tell me that there are ways. The idiots specified dialog box and button sizes in pixels, with no regard to font size. This is what happens when I try to make the fonts readable on a big screen:



(photo by chrismar)

Nature Keeps Coming With Better Idiots To Fight Concurrency

A friend of mine sent me a link to an article about Erlang style concurrency. Immediately MapReduce and Sawzall come to mind as smart paradigms intended to reduce (if only as a side effect) the complexity of concurrent programming to complexity of single threaded. And I almost start hoping that there'll be the next best thing since sliced bread which will make all the problems go away. But then, I look back at the code, more and more lines of which gets written every day, and chuckle. No way smart things can fix the situation, given into wrong hands (recent example: A340-600 ADAT accident).

So, what's the good that is supposed to come out of this rant? Very simple advice to make your life easier, if your IQ allows you to follow:

• Fughet the deadlocks and race conditions, they may be the least of your worries in the sanitized world of J2EE containers (sure, take this with a grain of salt, but not too much salt, OK?).
• Scope variables right. Not too wide, not too narrow. Using instance variables to hold request scope data is a recipe for thread safety violation and subsequent data loss and corruption. Reading configuration that doesn't change unless you redeploy the application within a loop is a recipe for a major performance impact.
• Maintain thought over and consistent instantiation and object life cycle patterns.

Now, if you think this is way too simple and can't comprehend why something this trivial should even be explained (and feel like questioning my IQ) - well, feel free to donate something to, say, DZ to alleviate my mental pain and suffering from working with code like this on a day to day basis. Why, you ask? Well, I guess someone does need to do the dirty work...

One difference between enterprises

• Smart enterprises: spend efforts on creating automated tools supporting the process, so the human factor is alleviated, and the process is enforced.
• Stupid enterprises: spend efforts on creating documentation on what processes to follow, so the human factor is confused the hell out of, and more effort is needed to create documentation to explain what the original documentation had in mind, ad nauseum.

Rudiments? Atavisms?

I've noticed an interesting fact during recent (and not so recent) refactoring sessions: junior programmers are using constructs that they couldn't possibly be taught using. Such as, huge blocks of variable declarations (the record is 152 declared variables: int i1, int i2; ... int i99; and so on), usually uninitialized.

The devastating consequence of this is that the compiler won't be able to detect branches that don't initialize the variables, and will happily use given default values and thus let you produce complete crap.

The closest historical origin of this is C, not even C++. It is highly unlikely that very junior Java programmers ever had any C exposure. The only explanation I have is that they keep stealing the code that was written somewhere in late nineties by some inexperienced C programmer trying to learn Java, and they keep doing that for years and years (actually, rather decades now) without a slightest attempt at comprehension of what it actually does, or where did it come from. Thus reaffirming again the painful experience of cargo cult programming.

Like the saying goes, you can write Fortran in any language...

But I wonder, maybe there's a different, better explanation?

Random Thoughts: Does It Have To Be That Stupid?

I just can't stop wondering why NetBeans even as of version 6.1 has to do the disk lookup (traversing possibly thousands of directories on network mounts) on such a simple operation as "Go To File", instead of caching those file names once per session and then updating the cache as necessary, like other IDEs do?