Keep It Simple, Software Guy!
Simplicity is a funny thing. A colleague of mine was showing me an ad for Visual Studio that was set in an office. The coders in the office had put together a ridiculously long diagram to represent the application they were building. My colleague was disturbed at how complex this diagram was. He commented on how we're supposed to be making things simpler with VS, but in this ad, we were condoning/endorsing making the project more complex! Interesting. Is software devleopment easy? No, it's not. But do devleopers make things more complex than is necessary. I think so. And I think it may be rooted in the masochistic tendencies of a group that is far smarter than the average and feels the need to show it.
This morning, I spent twenty minutes reading a blog of someone who spent a week at JavaOne. I know this person in a non-business context and he seems like a pretty good guy, but rest assured, he is not a fan of the company I work for. He managed to stick as many anti-MS comments into his posts as imaginable. I must admit that it makes me a little sad/frustrated to read these things about a company I appreciate so much. But that's another blog post for another day. Anyway, apparently, he's an enterprise developer and it was interesting to see some of his comments. Some were boiler plate (like the person who posted feedback to my last blog entry and suggested IE had holes like a “cheese grater”) comments, but others were assassinations of .NET. I think his take on .NET Generics was that it was something for “VB monkeys” or something like that (no, that wasn't meant to be a flattering comment :>). For those who don't know, Generics are classes & methods that work the same on values of different types. You can argue that it is a level of abstraction to help those that are struggling to accept the typing requirements of managed code by enabling some level of flexibility. Oh no! Not flexible abstractions! I admit that, once upon a time, I thought the level of abstraction built for for VB developers was an anathema. Heck, I even hated Java because of what it wouldn't let me do. “Give me pointers!“, I roared. “Where's the challenge if you don't have to properly use malloc() and delete()“.
But perhaps my days of “drinking the Kool-Aid“ has changed my thinking. Or maybe it's the evolution of what's going on. Or maybe it's the fact that I am no longer counted among the smart guys and, therefore, no longer feel the need to showcase my developer machismo. I saw an interview with Grady Booch where he said the following: “Let me amplify something: looking backward and projecting forward on software engineering, the industry has faced complexity issues by raising the level of abstraction“. It's an industry trend and something that I'd like to think has changed software for the better. Of course, it's a matter of perspective to believe that abstraction=simplicity. Many see abstraction as reduced choices and potentially sub-optimal peformance. After all, how can the performance be as good if the code underneath wasn't custom written for the task at hand. But I still think it's a different issue and part of why all the JavaOne guys like to make fun of .NET. The question is: has it lowered the bar for developers? Perhaps. But (and I suppose this is related to my last post) this snobbery has got to stop. Now my days as a true coder are long gone, replaced by this ability to write cool little prototypes of stuff that have no business in an enterprise setting (“what's an exception?“ :>). But I think I recognize the benefits of limiting a little flexibility for the sake of better code and it's something I applaud at the end of the day. When I see the anti-abstractionist, I have the vision of ordering a martini and having the bartender doing the Tom Cruise “Cocktail” thing--you know, the hippy-hippy shake, flip the bottle of vermouth, do a 360 spin, drop it in the glass, pound the table, and watch the olive magically fall in the glass. Uhhh, I just wanted a martini. You could have saved me the 10 minute show and avoided spilling all the vodka on the floor.
At the end of the day, a little simplicity goes a long way. Try it. Try it in your architectures. Try it in your code. Don't worry--people will still think you're smart. Heck, even the Java guy confessed that Generics were pretty cool.
{Pearl Jam - Live at Benaroya}
Comments
- Anonymous
July 24, 2004
The comment has been removed - Anonymous
July 24, 2004
The comment has been removed - Anonymous
July 24, 2004
Good design equals simplicity though. So the act of showing off with a complicated implementation/design is more of an attitude problem rather than a technical one. Smart == Less Complexity.
One comment, the higher the level of abstraction (.NET, Java, etc.), the lower level of control. In a sense it may come to the point where there you get the feeling that you do not control your own destiny and cannot 'unblock' yourself easily. Without intimate knowledge of the internals of the framework, some subtle bugs or performance gotchas may appear out of nowhere, and may be more difficult to fix.
Now it got me thinking, could the problem be that developers who are too smart need to find an outlet for their excess bandwidth, resulting unnecessarily complex designs? Then the solution would be to put the right level of programmers on the job. For a simple business app, maybe just one or two smart people, then five average joes added for the right mix. - Anonymous
June 18, 2009
PingBack from http://barstoolsite.info/story.php?id=5285