January 6, 2008
I've often thought that software developers were akin to Magpies, birds notorious for stealing shiny items to decorate their complex nests. Like Magpies, software developers are unusually smart and curious creatures, almost by definition. But we are too easily distracted by shiny new toys and playthings.
I no longer find Scott Hanselman's Ultimate Developer Tool list inspiring. Instead, it's fatiguing. The pace of change in the world of software is relentless. We're so inundated with the Shiny and the New that the very concepts themselves start to disintegrate, the words repeated over and over and over until they devolve into a meaningless stream of vowels and consonants. "Shiny" and "new" become mundane, even commonplace. It's no longer unique for something to be new, no longer interesting when something is shiny. Eventually, you grow weary of the endless procession of shiny new things.
I'm not alone. Jeremy Zawodny also notes the diminishing luster of shiny new things:
Over a year ago I unsubscribed from Steve's blog because he had a habit of writing in breathless fashion about the latest shiny new thing – often several times a day. I see too many people I know getting caught up in the breathless hype and forgetting to think about whether the latest shiny new thing really matters in the grand scheme of things.
Dave Slusher concurs:
[Robert Scoble] says that he gets too much email and that is ineffective for getting PR releases to him. He suggests that what you should do now is leave him a message on his Facebook wall. Dear god and/or Bob. In the time I've followed Scoble, I must have seen something like this a dozen times from him. Don't email, Twitter me. Don't Twitter, Pwnce. Jaiku me. Leave a wall message, send an SMS, just call me, email me, don't email me, don't call me. Enough already! I'm not even trying to get in contact with him, and I find this constant migration from platform to platform to be a load of shit that just wearies me. I felt the same way when I dropped TechCrunch, well over a year ago. I got so tired of hearing about another slightly different way of doing what we were already doing and why that tiny difference was worth dropping everything and moving over. I officially renounce the search for the newer and shinier.
It isn't just the neverending stream of tech news. It's also the tidal push and pull of a thousand software religious wars that continually wears us down, like errant rocks in a rapidly flowing stream. I bet the process David Megginson outlines sounds awfully familiar:
1. Elite (guru) developers notice too many riff-raff using their current programming language, and start looking for something that will distinguish them better from their mediocre colleagues.
2. Elite developers take their shopping list of current annoyances and look for a new, little-known language that apparently has fewer of them.
3. Elite developers start to drive the development of the new language, contributing code, writing libraries, etc., then evangelize the new language. Sub-elite (senior) developers follow the elite developers to the new language, creating a market for books, training, etc., and also accelerating the development and testing of the language.
4. Sub-elite developers, who have huge influence (elite developers tend to work in isolation on research projects rather than on production development teams), begin pushing for the new language in the workplace.
5. The huge mass of regular developers realize that they have to start buying books and taking courses to learn a new language.
6. Elite developers notice too many riff-raff using their current programming language, and start looking for something that will distinguish them better from their mediocre colleagues.
I hope you're sitting down, because I've got some bad news for you. That Ruby on Rails thing you were so interested in? That's so last year. We've moved on.
If you consider that, statistically, the vast majority of programmers have yet to experience a dynamic language of any kind – much less Ruby – the absurdity here is sublime. Some dynamic language features are trickling down to the bastions of Java and .NET, but slowly, and with varying levels of success. These so-called thought leaders have left a virtual ghost town before anyone else had a chance to arrive.
I became a programmer because I love computers, and to love computers, you must love change. And I do. But I think the magpie developer sometimes loves change to the detriment of his own craft. Andy Hunt and Dave Thomas, the Pragmatic Programmers who were a big part of the last sea change in Ruby, said it quite well in a 2004 IEEE column (pdf).
Users don't care whether you use J2EE, Cobol, or a pair of magic rocks. They want their credit card authorization to process correctly and their inventory reports to print. You help them discover what they really need and jointly imagine a system.
Instead of getting carried away with the difficult race up the cutting edge of the latest technology, Pete concentrated on building a system [in COBOL] that works for him and his clients. It's simple, perhaps almost primitive by our lofty standards. But it's easy to use, easy to understand, and fast to deploy. Pete's framework uses a mixture of technologies: some modeling, some code generation, some reusable components, and so on. He applies the fundamental pragmatic principle and uses what works, not what's merely new or fashionable.
We fail (as an industry) when we try to come up with the all-singing, all-dancing applications framework to end all applications frameworks. Maybe that's because there is no grand, unified theory waiting to emerge. One of the hallmarks of postmodernism – which some think is a distinguishing feature of our times – is that there's no "grand narrative," no overarching story to guide us. Instead, there are lots of little stories.
Don't feel inadequate if you aren't lining your nest with the shiniest, newest things possible. Who cares what technology you use, as long as it works, and both you and your users are happy with it?
That's the beauty of new things: there's always a new one coming along. Don't let the pursuit of new, shiny things accidentally become your goal. Avoid becoming a magpie developer. Be selective in your pursuit of the shiny and new, and you may find yourself a better developer for it.
Posted by Jeff Atwood
"Doesn't that mean that if you stick with Java or C# you will not have to worry about any of this? "
A little bit. At least for the next five years this will be the case. I've noticed that C++ almost never adds anything significant anymore. the Java folks seem to have been burned by implementing generics and seem a lot more hesitant to do continuations. C# is newer than Java and they seem to throw stuff in at a pretty consistent basis.
What I take from this is that languages accumulate some momentum and it becomes harder and harder to change direction the longer they have been rolling. Libraries, legacy code and backwards compatibility are big burdens for successful languages.
I bet over half of the code in the world is still written in COBOL!
Well, at least a third...
Talk about old and dull, but it still keeps processing those millions of insurance claims every night.
I've grown weary of the new Paradigms. I am happy as long as I can code, compile, run and test without much hassles. I don't even want to learn the intricacies of new features, I just want to know what's the new syntax for my old tricks. What's the name and syntax of the new queue, deque, list, arraylist, collection, stack whatever you want to call it... How do I concatenate my strings and index them...
I am curious as to what exceptions would qualify a transition to a new shiny technology as not MagPie? If the new shiny technology would say reduce code complexity and developer effort by 10% would it not be worth it? Or is only bringing on the new technology just for the sheer fact that it would be "cool" constitute as being MagPie?
What are your thoughts? How do the exceptions fall into place?
The only "shiny" new trinket I use these days is Notepad++. Just give me Visual Studio and Notepad++ and I'm pretty happy.
The worst part about chasing all the shiny objects is that eventually it wears you down to the point that you start to dislike that which you loved before...
I bailed on programming for a few years just because I got so sick of the continual chase, year after year after year. I've had a long enough vacation now that I feel the love again and am getting back in. :) Started off with some nice easy x86 asm and C (where most of my time was spent before), then tried some Ruby on Rails (ugh, what WERE they thinking? Easy to do "quick and dirty" web stuff, but maintainability is a nightmare), and finally settled on Java (which appears to have become a nice stable business platform, entirely different from the Java that was coming out just as I was bailing on programming...).
Excellent post. It's important to always that real-life experience is part of the "best tool for the job" evaluation and will in many cases out-weigh subtle "fewer lines of code" benefits.
Well written and a good point. I've often thought about the same thing - to use all the latest toys, I have to spend more time researching/learning those then writing actual code.
Lately I've started to use plain "vanilla" Visual Studio - no fancy refactor tools, no snippet inserter, no nothing. And I get along just fine.
I honestly think this was all obvious to real developers from the start but it was again a well-researched post. As you have said you are blogging for your own sake, there's really no point in saying stuff like "Well. Duh!".
I am a little curious though; what makes you think software developers are smart and curious, almost by definition? What's the definition you are using, really?
It's turles all the way down. For every developer getting sucked into the new and shiny, there's eight managers helping weight down the bandwagon hoping for the silver bullet to solve all their problems.
Shiny new things look really appealing when you don't have a life. Instead of Magpies I was thinking of Monkeys that get fascinated by some shining object in a stream.
God help us with what the VS team is dreaming up. 2008 doesn't seem to have one thing that isn't shiny, new, and totally useless unless you have an IQ of 170.
Hear hear! Vanilla Visual Studio!
Seeing Scot's big page of shiny stuff, I just have to browse through them! Maybe I should try out something better then notepad paint...
The thing with some of those programs is that once you're used to them, there's no going back! Good example would be tabbed browsing.
As to Sander:
Have to copy XML text in Visual Studio. Glad to use the addin "Smartpaster" which splits the lines and adds double quotes. Did save quite a bit of time.
The flip side to this is: "what *are* the important changes that should be seriously considered as reasons to change". And since it is easier to use hindsight than prescience rephrase to "what were the important changes of the last 50 years in software development?".
I would suggest, in roughly chronological (and probably importance):
1) Representation of the software as an abstraction from the hardware it runs on (Basically compilers rather than assemblers, the world of fortran and C plus all those that died out).
2) Functional languages, principally for their enabling of the elite gurus to some of the more potent tools and testbeds on which many of the later improvements would be based.
3) Provision of large API's not simply as a means of interacting with the OS but to do more common tasks/data structures independent of the actual environment.
4) Managed Code. I.E. letting the system handle memory allocation and deallocation for you, the resulting sanity and safety checks that result.
5) Sophisticated Integrated Development Environments where the code/build/[test|debug] cycle can be made faster and simpler.
Whilst I like OOP in many ways I have not included it because I don't believe it justifies it's presence amongst the above (though you could argue a well designed OOP language can make the the provision of the IDE easier/faster compared to many of the alternates)
I have not included the provision of code/data in electronic form (i.e. moving off punched cards) since the change was obviously massive but was more a change in the hardware.
IT should be noted that almost all of these changes required the increasing power (and readily available fast memory) of the computers of the time so you could argue that anything which enables moving to the latest shiny new computer hardware is good. As such you could argue the highly portable nature of modern languages are the most importance change...
I do not know where UI frameworks should feature here. They seem kind of orthogonal to the concept (since they improve in a similar fashion throughout but do not take over most needs in the same way (the creation of compilers eliminated the need for the vast majority of people to need to code in assembly, the provision of WIMP did not remove the need for decent command line tools in the same way). Certainly knowing how to do a quick WIMP system became an important part of many developers skill set.
In the same fashion Source Control must go in there somewhere as the most useful tool, but no really a programming paradigm shift like the others.
I think the really elite programmers use low level languages and assembler/byte code... and perhaps wonder why so much time is wasted on all this new flashy jazz. :P
Ruby on rails is a great example of something I deemed a complete waste of time when it came about... I couldn't see anything great about it other than another learning curve.
Stick to the tried and tested... to quote the old addage "if it ain't broke, don't fix it".
I've never needed a tool beyond the latest Visual Studio... although I will use libraries etc... its a bit different... stuff like OpenGL, flex, bison etc... none of which are shiny or new. :)
What's all this "buying books and taking courses to learn a new language" business I hear mention of? Over 20+ years of programming and learning new languages (from assembly onwards...), I've never done either of those weird things :)
I think its amazing with all the shiny and new stuff that I still find myself using vim/emacs and sed/awk when I really get backed into a corner.
Jeff , you must admit that all "shiny new toys" come with additional features and by your definition : "software developers are curious".Thus we (software developers) can't stop asking "what does this new feature do ?" actually meaning "how much of my work does this new feature do for me" .The hacks they provide make our day since we are lazy and wouldn't want to do them manually.The next batch of new toys come out and and the cycle continues.
Erik I wasn't trying to say one approach was better than the other in any particular field. I'm sure one could find plenty of examples of one approach being selectively better than the other at different times depending on the metric you used. And frankly I don't think the hydraulic flight stick really goes against any particular point I was making -- mine was a point about cultures of production, not specific things produced.
Jeff , you must admit that all "shiny new toys" come with additional
features and by your definition : "software developers are curious".
Jeff's a .net coder, so he's probably installing vs2008 and wondering what it's broken; then the first SP will be out; if it's worth learning LINQ; what Silverlight will bring to the table etc etc!
All hail the sub-"huge mass of regular developers" who are just slow enough to see the tarnish appearing on the shiny new things.
We raise a glass to the tarnished not-so-new things and toast their brevity while silently praying: "there but for the grace of god, go I"
i see only one problem in "being selective in your pursuit of the shiny and new" -- it almost immediately means that you have to now what is the shiny and new -- you have to work with it to determine if it fits to you -- you are not selective anymore -- you have to invest a lot of time to find out if the shiny and new ( probably its only shiny and new for you but not anymore for the crowd ) fits to your needs
a perfect example is ajax. a lot of companies do web development for example using asp.net. now microsoft releases an ajax library on top of this -- what are you going to do? -- miss the train and stick to pure asp.net or jump on the shiny and new ajax stuff of .net 3.5 ...
it is quite hard to find your way between sticking to the known or using the new technologies ... even if everything is situated in the same family of technologies like in my example the .net platform
what we do here is to read about lots of different stuff but wait at least half a year until we incorporate something in our products ... not even this approach is perfect ...
Excellent post .. couldnt agree more :) The shiney things call to me on a daily basis its hard to resist.
I try out new tools regularly, not because they are shiny and new, though they often are, but because they may be *better*. If they are better then I will stick with them, if not, I go back. This is why I still use Vim, because no other text editor I have used so far provides me the balance of power, speed and usability that I find Vim (and a few years experience with it) lends me.
I think to give up on new products is as foolish as blindly following their allure. Yes, there are fashions in software applications and in software development as an industry -- sometimes these fashions are led by great innovation and sometimes by marketing, popularity and hype. The easy option is to denounce it all, leave the fashion industry completely, maybe even find a niche. It is a little more effort to try to filter out the hype, judge the products for what they are and what they add and to pick the ones that work best for you, but ultimately, in doing so, you will be a stronger developer, concentrating more of your time on the difficult task of solving the business problem.
As to programming language, it is all very well saying that programmers should not worry about following the industry and be happy with what works, but at the end of each appointment comes the need to find another and there is nothing better than experience in the currently most popular technologies when trying to find a job in any particular job market, whether you like those languages or not.
Dozens of interview candidates the last year:
"So, what software/technologies/platforms do you use here?"
My response to every single one of them:
"We use whatever works."
I think perhaps you meant 'effete' everywhere you used 'elite'. An elite programmer is one who is superlatively productive, writing code that communicates clearly the problems it is solving and how it is solving them. The effete programmer is dedicated to living a decadent life of excessive tool-lust and no sense of responsibility beyond constant satisfaction of his own voracious ego.
Some of us picked up our shiny stuff back in the 1980's, and settled in to wait for the rest of computerdom to catch up. I think that with about five years of effort focused on performance, Ruby and Python will catch up to Common Lisp and CLOS.
(And if we're really lucky, the CL community will settle on decent cross-platform standards for sockets and Unicode...)
I've just bitched about this a href="http://enfranchisedmind.com/blog/2007/12/29/functional-programming-language-de-saison/"over at my blog/a, too, although in a more particular case: functional languages themselves seem to have a popularity turnover about every three months. You site Scala as the next big thing, but it's really on its way out: mark my words.
Go hit programming.reddit.com and type in "Erlang" -- the flood of posts were from last summer, and it was basically inaugerated with the Seaside presentation in front of all the Railsists. Then people seemed to get bored with Erlang in about 3 months, and then Haskell had a longer run (about 4 months). Then it died out and Ocaml had a couple of months, and now Scala is on its rise.
Now, as an Ocaml developer, it's taken me three years just to wrap my head around all the a href="http://enfranchisedmind.com/blog/2007/01/01/ocaml-lazy-lists-an-introduction/"new ideas/a and a href="http://enfranchisedmind.com/blog/2007/08/06/a-monad-tutorial-for-ocaml/"other weirdness/a in that language, and I'm still getting used to it. I must just be stupid if everyone else is able to grok those languages in a matter of a couple of months...
vi and Makefiles ftw!
Visual Studio in Windows though :/
Oh dear god I had forgotten about ever going back to check out Scott Hanselman's list.
There goes my morning!
Although I have found sometimes there are some real gems to be found as you build your nest. Just need discipline to go nest building AFTER you've had time to actually get real work done.
On the other hand you don't want to write ASP Classic apps with notepad for the next 50 years ...
As a programmer with a blog named "Shiny Things", I'm full aware of my magpie nature. When I find a new language or technology I try to learn something new from it and take it back to the technologies I use regularly.
You eventually learn that most of the time shiny and new is repackaged and re-hashed...
Not that things like Ruby represent a whatever forward, the real question is, is it really worth it? Will it really bring about a new leap in productivity?
And then there are the fence sitters, you know the ones I'm talking about, "Yeh, I'd buy a computer this week but I'm waiting for the next greatest and latest in oh, about six months or so, don't want to be obsolete right out of the box..." There are programmers with the same mentality.
The point is, we make a living doing what we are doing and we are for the most part, priveleged to do so. I pick my toolset to make my living. Period.
However, we all have to keep up so that we don't get left in the technological dust.
I guess the point is we have a need for shiny and new, just so long as the shiny and new can make us some money. At least I think that is still the reason I and about 200 million others like me in the USA go to work.
The key point to avoiding the Magpies syndrome is to stay focused on the product itself. The Magpies are ones who are erronesouly focused on the tools and/or the language they are using.
Here is a rule of thumb: Never change the language you are using. Change the tools perhaps a little more often....
As others have pointed out, your users don't care about your tools. Focus your energy on adding features to your product and making it better...mastering your tool set and occasionally improving the tools over time using tested and well verified techniques demonstrated by others. The last thing you want to be coding in is a language or tools that had a life cycle of bad fashion fad....that nobody knows anything about in 3 to 5 years.
Jeff you had claimed Joel for had "Jumped the Shark" at FogCreek for writing their own compiler to avoid a rewrite as their product evolved. Read your own post here again and you might understand better why they did that.
You've made the comment in the last couple of weeks that end users don't care what language an application is written in, I disagree. I work for a small consulting firm that was a Visual FoxPro house; now that VFP has been relegated to the back burner at Microsoft, no new customers are appearing; and well they shouldn't. Most customers are savy enough to realize that any custom software needs to be written in the language that currently fits into the "riff-raff" category so that there is a base of developers to support it that aren't elite or so few and far between that they are hard to find.
Vertigo looks like a magpie company!
Where does one download those "magic rocks" of which you write?
Great post, Jeff. I've only been doing professional software development for 3 years and I'm already dreaming of escaping to management for precisely this reason. New tools and methods are great, but I find it frustrating that so many of our peers would rather engage in endless religious wars over the "best" technology than build useful software.
That's an English Magpie. I didn't think they looked like that in America. Is that right?
That's why I love Python, you get the best of both worlds : an ever evolving and shinier language built on top of robust and clean foundations.
I wonder what people find shiny and new in ruby, scala, java, C#, etc... they still have braces and begin/end tags ! It may look like a detail, but that's one of the differences that make Python code so much smaller, and thus more readable. Readability being one of the most important aspects of a good program, Python made an improvement here where others failed miserably or even ignored the problem.
The debate between dynamic and compiled languages should not even exist, the optimization lies in the algorithms, not in the tiny little bits of performance you get from compilation or clever lines rearranging. When you really need to optimize to the limit, just write those ten lines of C/assembler your program spends most of its time in, and if you find yourself writing too much C then it may be time to rethink your algorithm ...
Scott Hanselman list effectively seems boring, I stopped reading after Notepad2++alpha4. Really need an advanced text editor ? learn Vim or Emacs. Yes you will have to throw all the good things you learned from Notepad (?!), but in the end you will thank the 20+ years of user interface refinements that drive these programs.
I think that's what this post shows finally. Good tools that present real improvements like Python stay in the shade because of the programmers laziness, while things that are not really new but faster to learn get all the "attention".
I think there are too many riff-raff using C#. I'm going to switch to COBOL.NET. Seriously though, I did invest some time in learning Eiffel.NET when I wanted use something obscure to keep a project from being outsourced.
Visual Studio 2008 has caused me a problem. I now have msiexec.exe bogging down my PC whenever I run Visual Studio 2005 or 2008. I think it is trying to repair something.
I think part of the issue is in how easily is it to integrate the shiny new thing into your work flow and project. Refactoring tools are easy to adopt - they dont do anything but make the source easier to manage (hopefully) and in the end the code still has to compile before it can being testing.
LINQ is a much harder proposition. I just cant see people with years of investment in stored procedures switching to LINQ because they can. And lest we forget the VB6 revolt caused by VB.NET being backward compatible.
One probably just needs to be pragmatic (as we always have) in selecting tools for use in our daily jobs. The trick is in not giving into the hype. Always remember that the demos always work, the devil is in the details of doing something not in the demo. When I evaluate a new tool if I can do some small projecct that I feel should be easy with the tool, into the crapper it goes.
Nicely said. If you follow programming.reddit.com, you get the impression that everyone is using functional languages and C disappeared back in the 1980s.
Your post makes me think of Ecclesiastes (1:8-9):
"All things are wearisome, more than one can say. The eye never has enough of seeing, nor the ear its fill of hearing. What has been will be again, what has been done will be done again; there is nothing new under the sun."
Whenever I start a project at home I spend some time looking at language features, modules or libraries that could help me. This usually leads me to spend lots of time reading terrible documentation for their APIs. I generally end up concuding that the libraries are terrible and it would be less effort to write it all myself.
I've noticed this too with Microsoft APIs. They have done this with GDIPlus (it is now in maintenance mode), with WinForms (in favour of the new, shiny WPF) and countless other APIs.
Just when you've caught up with the new technology from Microsoft, they have moved on to something new.
I was surprised someone of your experience, having gone through so many technologies (I too got my start with LOGO) wasn't sufficiently sceptical about Ruby.
I've seen the claims so many times, when Ruby came out, I just sighed. A good idea, yes, but it's been tried before. A matter of time before people started adding to the technology to get it to do what it didn't do before, and it would joing the never ending sea of frameworks out there.
I found it interesting, the highest percentage belonged to the most mature of the technologies.... hmmm... food for thought
I've never fallen victim to the obsession with new, shiny languages. As a matter of fact, I still do the vast bulk of my web programming in ASP VBScript and PHP. They both work well, they deploy quickly, and they're easy to find help with because they are well established. I have only recently reached the limit of ASP, but PHP appears to be limitless. Unfortunately, my employer frowns upon the use of open-source languages.
Now, the fact that I'm not a Magpie doesn't say anything great about me, it's probably just because I'm such an isolated developer. The only other developer I work with pushes .NET, and I already hate .NET, so no pressure there, although it appears that .NET is my only option to move forward (oh Python, how I wish we could be together!). My point is, it's only natural to compete with your peers, and in Software you do it by pushing the language edge.
"Don't feel inadequate if you aren't lining your nest with the shiniest, newest things possible. Who cares what technology you use, as long as it works, and both you and your users are happy with it? "
Problem is too often it doesn't work. With so many software projects failing and so many users upset with the results of projects these days and so many critical bugs emerging after deployment, is it any wonder that people are constantly looking for something new? The issue isn't that we have too many solutions without problems, its that we have too many problems without (good) solutions.
Brilliant, I needed to hear that. Now I can rest from always thinking I need to be actively learning everything new thing that comes along. Good to hear it from someone else.
"And how has *any* new programming language or development process addressed this?"
They've certainly addressed those problems, whether or not they succeeded may well be a different story. I wouldn't consider them all complete failures; as you say there have been improvements (even if they have been small). The fact that we still have problems just means we still have room for improvement (which means there will be more "shiny things" trying to be that improvement in the future).
On a completely different note, what is the point of that "Enter the word" test for comments? It seems to always be the same word, so if it is supposed to be a CAPTCHA test its not a very good one...
If with every new, inspired attempt to a perfect language we come a little step closer to mature software development in general, I say GO shiny new toys.
Please let all elite, senior, and regular software developers contribute to shiny new toys, at the expense even of their effectivity as software developers. By the time the next next thing is there and we jump to yet another shiny new toy, we might have learnt something from the previous shiny new toy and gotten more effective as a whole.
I agree with this post. I have a working set of systems built in Rails that didn't take a lot of pain to develop. I don't care about the shiny stuff. I just want to get things done quickly. I like shiny stuff and play with it in my own time. The reason there is so much awful Java out there is because it used to be shiny and was written by people who didn't understand object orientation or even good programming techniques. Most Java code I've come across isn't o-o, just the same old procedural stuff hidden behind some badly named objects (most of which are static).
That said, we use Rails because it's quick to develop stuff and we were starting from scratch. I also find writing interfaces really easy because Ruby underlies it all and I can get something written in half a day that would have taken most of a month using the technologies I used to use.
I worked for a Java shop running J2EE for a few months (even have the Sun Java Certs) and it drove me insane. Never have so many XML config files contributes so little for so long. (Struts? Are you insane?)
I suspect that Microsoft tools win because they automate a lot of the garbage you have to deal with as a result of the alleged agnosticism of the Java platform and (pick one) the OSS tools you've chosen. Rails wins because it's opinionated, as in the config is part of the conventions used by the framework - this is a good idea if you agree with the opinions, or don't have an opinion in the first place. MS is opinionated by default, think about it.
The sad thing is that the guy who wrote Mongrel, who should have ended up with a good job or being a high-paid consultant from his efforts has thrown his toys out of the pram. I suspect that it's because he comes across as someone who is difficult to work with (Elite developers are a self-selecting pain in the ...). So he's moved on to something else but still using Ruby. Fine. I don't care.
Also, remember all those "stable" and "old" technologies were all "shiny new toys" at one point. Java, C++, hell even C were once new technologies, and all faced skepticism that they would help (ok, I'll admit, I am too young to remember C++ and C coming out, and Java had just come out a few years ago when I started playing around with programming). Obviously they had some redeeming qualities as they stuck around for as long as they did.
I think your argument is short sighted. I see this argument a lot, primarily from the older developers that have been through the cycle a number of times. Frankly, getting old means you've already learned a lot, and learning becomes tiring after x number of iterations.
Now think back to when you were a scrapping new programmer, learning all the latest stuff. It was exhilerating, and new. And you found all kinds of cool things you didn't really know before.
Learning is a young mans game, sad to say. Sure, there's plenty of old geezers (like me) that still enjoy learning new stuff, but each year it becomes more and more of a chore. At some point i'll toss in my hat and relegate myself to "legacy" technologies.
The thing us geezers forget, though, is that the shiny new thing always brings with it *something* new and useful. And this technology will likely eventually filter down into the mass market. Without people doing the exploration, it's hard to tell what ideas are really worthwile. Sure, the pioneers will move on to the next new technology next year, but they will bring with them the ideas they learned with the last new technology, and those ideas will begin to filter down the chain.
Just because you no longer want to be on the cutting edge doesn't mean the cutting edge is no longer useful. It may not be for you, but it is for the programming profession in general... it just may take some time to filter down.
I mean, where would we be if scientists just stopped trying new things? Thank god there's always a new crop of fresh faces who aren't tarnished and jaded by years of experimentation.
I have been programming for about 20 years and the tools I use are just that. The real meat of programming for me was and continues to be writing leaner and maintainable code that causes as few errors as possible.
Tools help a lot. To that extent they are very important. For example, the first few programs I wrote were in Norton Editor and today I can't imagine writing one without a syntax highlighting one.
The other notable changes occurring during my programming career have been the rise in level of abstraction - from structured programming to OOP, patterns, services, etc. If one was to shy away from learning this stuff, one wouldn't have a job for long.
Still there are times when one needs to do bit manipulation, write a tight loop, parse an expression, use the right sorting algorithm, create just the right design and so on. The limelight no longer shines upon these skills but that doesn't mean they don't matter. The mainstream takes these things for granted, places more demands upon it and causes the elite to bring out better stuff.
What font is this written in? It looks sucky on firefox in XP.
Hey Now Jeff,
I don't want to be a Magpie dev!
Coding Horror Fan,
Well said Jeff. Urge to stand out in thr crowd is what comes through in most blogs on technology. May be that writing Software is really a mundane task. May be that we dont need so many great intellects in this field.
Now, if only Microsoft resisted the urge to release a new version of the language/framework every year........
I have to agree with Nobody Real. A good developer should always put aside a reasonable amount of time to explore new (new to you anyway) tools, languages, techniques, etc.
I've certainly tried my share of dead-end stuff, but there are quite a few tools in my toolbox that help me immensely that I wouldn't have if I didn't try new stuff on a regular basis.
If you are interested in some of the tools that I use regularly, I've posted an article on my website that lists them. Many of these tools came from Scott Hanselman's list (though my list isn't anywhere near as extensive).
- Favorite Tools -
I've actually managed to make my J2EE applications a lot meaner and cleaner since learning Ruby on Rails. Even though we don't use it where I work it was worth learning just to pick up a lot of neat tricks for writing clean web applications.
The issue isn't that we have too many solutions without problems, its that we have too many problems without (good) solutions.
A man I've learned much from, Gerald Weinberg, wrote his first couple of books on the technology of programming. Then he switched, and wrote or coauthored 50 more on the process of programming, and he is most famous for saying "no matter what they tell you, it's always a people problem."
I liked this post and understand your angle. I was just thinking about this recently...
But... don't you agree this kind of relates to our obsession with hardware too? Didn't you recently post about a DLink router? I embarrassingly am a college student (painfully poor) with 2 computers I upgrade/replace every year.
Isn't this an important part of the toolbox? Old stuff works, but what about the effect on productivity. Customers don't care about how many developers, hours, and lines of code either (unless it means its going to cost them). If you ask me, considerations into aspects like these determine my tools.
On a completely different note, what is the point of that "Enter the word" test for comments? It seems to always be the same word, so if it is supposed to be a CAPTCHA test its not a very good one...
Nick on January 7, 2008 08:28 AM
This is going to sound like hype, but it's just my $.02 and honest opinion.
Before I found ruby, I kind of hated programming, much of the time. It was just a pain. There were parts that were fun, enjoyable, etc.
But there seemed to be a pattern, which, perhaps might repeat itself w/ RoR for me one day, which was:
* be excited about learning all the cool whizbang technology of some new language (new for me)
* actually learn how to do the basic stuff in that technology
* get bored frequently, because every task seemed to be all about doing the same boilerplate things again, just slightly different each time
Perhaps I wasn't lucky enough to work on cool, unique projects all the time.
But now, even when doing my Xth social networking site in RoR, it's still interesting to work on and get down into the internals of the language, pushing the limits of the framework.
... my point is though, I'd probably still be hating life right now at a Java, .Net or PHP company if I hadn't of taken the time to tinker with Rails one weekend.
Shit, maybe I'll say the same thing about Scala, Lua, Scheme/Lisp, etc one day... but I'm *far* from being elite or even sr. junior elite. :)
It's refreshing to hear that there are people who realize that the sheer amount of information overload has negative effects on us mere mortals. I used to read Scott's blog, but the guy puts up so much information that it just becomes noise and becomes anti-informative.
I think that the wave of new languages owes something to the ubiquitousness of the internet. In the past, new languages tended to fester and percolate in research labs and academia for years. The good stuff would eventually gain commercial traction and the lesser stuff would become geek trivia questions.
Now, everything new gets thrown at the wall to see what "sticks" as soon as someone can upload it. You don't know what has legs or what's better left on the drawing board.
In November, I gave the commencement address for Neumont University, a school in Salt Lake City dedicated to teaching computer science where my coauthor lectures. This is that speech.
Part of my living comes from tutoring students at that college on subjects the teachers don't know or just happen to get horribly wrong.
It's easy to confuse "the search for newer shinier" with the "search for a better way".
At some point, the sub-elite and the regular programmers just get snowed by their awe of the "elite". They jump on the next bandwagon and waste tons of time making shiny new apps rather than solving problems more efficiently. But it's a human problem as much as anything else. We want "new tech", not "better solutions". The latter reeks of "productivity gains" and so much corporate speak; the former smells of new car leather.
Here's a good one. We're on VS 2008, 3rd iteration (or is that 3.5th iteration?) 2005 finally stopped f*ing around with our HTML syntax and 2008 has bunch of shiny features. Now don't get me wrong, DLINQ and Extensions will definitely provide me with some increased productivity, but they're very "back-end-centric". But you know what else small devs waste a ton of time on? UIs!
So now we get WPF, but MS still hasn't cooked up a good ASP "input control" for all of the standard types. What do I mean? I mean that every input on a standard front page to a DB is actually like 3-4 controls (sometimes more). You have your label control, then your textbox/calendar/drop-down list, then your validation control (with or w/o AJAX?). Sometimes you even have multiple text-boxes or validation controls. But at the end of the day, you're always doing the same things: standar text input, phone input, credit card # input, postal/zip code input, "must-be-a-number" input that inevitably fails when someone types "-1" into the box, date range inputs, etc.
I have wasted so much time in the last year alone in both building these UIs and testing/rejecting the stuff that's submitted. Goodness knows that if MS just included a good library for this type of pre-cut "input control", then VS would simply pay for itself.
Instead, we get lots of "shiny" and a dose of "better". I think it's a human flaw as much as anything else. *sigh*
There's an interesting article from awhile back in the science studies literature about comparative jet design in the USA and the USSR during the Cold War. The USA favored "shiny" technology -- top of the line, state of the art, caring more about raw performance of the machine than they did the cultures that made the machine or how much it cost. By contrast, the USSR had a different model of what constituted the "best" technology: they wanted versatile technology that could be used in many different theaters, at a good price, with interchangeable parts that could be serviced by anyone who knew how to repair a tractor. They had entirely different modes of production but ended up with a fleet of powerful jets that didn't have all of the frills of the US ones but cost a great deal less, could be more easily repaired and serviced, and could be easily produced in larger numbers. I always thought that was an interesting contrast in terms of technological cultures -- there is no one way to judge which is the "best" technical solution, it really depends on what your priorities are.
(The citation, if anyone cares, is Leon Trilling, "Styles of Military Technical Development: Soviet and U.S. Jet Fighters - 1945-1960," in E. Mendelsohn, et al, eds., _Science, Technology and the MIlitary_, Springer 1989.)
I think it all ties back to the "Real Artists Ship" or Getting things done mentality. Accomplishing a goal, no matter what the technology, is more important than all the shiny new things (or dull things) you used to build it.
Shmork: What you fail to mention (and which, coincidentally, has been mentioned on this blog before) is that the whiz-bang hydraulic flight controls on Sabres actually wound up making a huge difference in their combat performance against the MiG-15.
By definition, aren't windows developers always trapped working on the shiniest thing around? Waste time re-writing working programs because MS re-invented a new shinier OS?
Whenever I interact with fellow IT folks for the first time typical question asked is "In What Platform you work?"
I don't have any answers to that. I worked in variety of stuff COBOL, RPG, CL, C, Java, JSP, ASP, VB, C#, Oracle, SQL, DB2, ... too many to list.
My current project uses too many frameworks (Struts, Spring, Hibernate ...) to do simple CRUD database stuff. Developer are carried away with these facinating framework and miss fundamendal points such as database concurrency.
What you "use" doesn't matter, what you "deliver" matters. People fail to learn basics, very sad.
Best code language in the world that will last forever...
LOL Code (http://lolcode.com/)
Not shiny at all...very dirty in fact
@Thomas David Baker:
"On the other hand you don't want to write ASP Classic apps with notepad for the next 50 years..."
Not even if it works well, keeps your clients happy, and earns you a good living?
To Aaron G,
Your summary is too simplistic.
I programmed for a few years before using a garbage collected language. Then, when I used .Net I was surprised by how many common mistakes just weren't possible anymore. Later I read about the blub paradox. Now a days, I live in fear that there is something much better out there that I don't know about.
The good news is that I work with a team of people which prevents me from jumping to every shiny thing I see.
I think the next big thing I have to discover is dynamic/implicit typing. I've experimented with it, but I don't think it will hit me until I work with it full time.
"In a 5 year period we get one superb programming language - only we can't control when the 5 year period will begin."
Welcome to the post-Singularity. You can't possibly keep up, but you must try or the developer in the next cube over who puts in more hours will code you out of a job.
"Some dynamic language features are trickling down to the bastions of Java and .NET, but slowly, and with varying levels of success."
Doesn't that mean that if you stick with Java or C# you will not have to worry about any of this?
I guess what it boils down to is this:
Do you want to get work done, or do you want to advance the technology baseline?
We could all still be writing in assembly if a few people hadn't gone out on a limb and invented higher level languages. Then, we had to have people go out on a limb and actually start to USE those languages.
C++ would not exist if it weren't for the "shiny new thing". Nor would Java. Nor would C# or the CLR. We probably wouldn't have an internet, or a world wide web.
I guarantee you, those crusty old COBOL programmers you used to make fun of when you were fresh out of college felt much the same way as this article and it's supporters do. Congratulations. You've achieved nerdvana.
Nerdvana is that place where programmers go when they stop learning. They feel their skills are valuable and will continue with the status quo until one day they wake up and realize there aren't many jobs left, and those remaining are all maintenance.
At that point, you can choose to leave Nerdvana, and go to Management, or you can join the rest of your colleagues back on the learning treadmill and update your skillset. Either way, you're not going to keep doing what you were.
I am a young programmer (24yo) and have learned pretty much everything to programming before the web languages started to appear. From basic to assembler, I think that covers more than enough territory for programming.
I can't believe a language which started as "Pretty Home Page" finally ended up as a professional language. At first glance I thought the name implied corny website written by 12 yo kids full of animated smileys and blinking lights.
The only real contender to established tools I have seen is Java. But I never used it seriously because it generates huge bloatwares memory sucker. I have seen many pseudo benchmark Java vs C and I can't believe for a second their speed is comparable.
I am glad I did stick with desktop development so I don't have to keep up with all those "fancy", buggy and hard to install/configure new languages. Microsoft provides pretty much all of the tools needed for the major OS which is Windows.
I simply love oranges, especially while typing comments.
What we could do is make a nice big public wiki-like
table - Excel Live or something - and have these columns:
Skillset (VB, VB.Net, VC++, C/C++, C#, C Omega, Linq, WPF, ....)
Feature (Templates, dynamic typing, lambdas/function pointers, UDFs, one-line serialization ;-), , ...)
and so on....
Someone has to figure out the moderation of content.
Just hope you get a correct statistical sample.
Hope. Anything else is incorrect or unreal ;-)
have you considered and alternate explanation: you are just getting old :)
I started using emacs this past year (June 2007, for the recordbooks) because I wanted something non-shiny. Well, also because I wanted a flexible editor with good scripting and regular expression support, and had always wanted to learn LISP since my wee days in the 1980s.
Too bad its Lisp is e instead of common, but that's okay.
As far as non-shiny goes, I'm stuck using VB6/VBA for most things at work. But, hey -- no reason to not write good code.
Reading this while I'm supposed to be coding in LabVIEW, with a tiny bit of C added in. Non-shiny for the win!
(but I do Django on the train commute...)
Great post, Jeff!!
Does make sense.
Users don't care whether you use J2EE, Cobol, or a pair of magic rocks.
Users don't, but as I'm freelancer, customers almost always do. They wanted ror - I started writing on ror, if they will want xxx++, i will start learn it. This is what makes all that "top languages" lists.
I never used the magpie, I always used a raccoon. My old boss was a raccoon, easily distracted by every new shiny piece of tinfoil he saw in the garbage heap.
I spent alot of years trying to get him to realize what he was doing but it was always 'his ball, his bat, his field, his way or the highway'.
Shiny items are sometimes good but it's so easy for those in power (and not necessarily knowledge) to lose their way.
I really really look forward to ruby becoming a "thing of the past". Then I can go back to ruby coding in peace and quiet, like I did before the arrival of the rails hordes.
I agree that the pursuit of the new and shiny for its own sake is counter-productive...now somebody needs to get that info to Microsoft who profits the most from constantly introducing "new and shiny".
And to "encourage" adoption, older tech is "deprecated" routinely to make sure that the pursuit of new and shiny is first and foremost on the minds of every developer worthy of the name!
Even though I've not always agreed with you (Steven McConnell), sometimes you really hit the tack on the head with a satisfying force that could humble Thor himself. Many thanks for your well-written blog; it is one of the best on the 'net for this industry.
Jeff. I was an intern at Microsoft not too long ago. They're churning a lot of new tools and forced employees to use the beta version. It's very painful. One example was the new version of ADO.NET. The other being PowerShell (or Monad, whatever).
ADO.NET vNext was something. I can't even differentiate between ADO.NET vNext (or EDM?), LINQ, DLINQ, what else there? who knew?
They can advertise me how powerful PowerShell is but Python can do a lot of things in Linux/Unix/Windows.
Fast forward to the present:
- I decided to dump .NET
- I decided to pick up JEE 5 (JSF, EJB3, GlassFish)
- Say NO to Hibernate, Spring, Struts, whatever the fad
- I decided to learn Zope/Plone
- I decided to learn PHP (I know syntaxes, but haven't written anything)
I have some basic knowledge of Python and I decided to pursue it further.
A little bit of fact-checking:
- Zope: not pretty, but works well and rock solid since '97
- Plone: quirky, no Drupal-blingie, but Govt, NGO, Univs love it
- Python: Silicon Valley's best kept secret
Microsoft with its .NET always come up with something new every 2-3 years.
- It was MFC - WinForms - WPF
- It was Biztalk - WCF + WF
- It was Web Service, .NET Remoting, whatever-else - WCF
- It was ASP - ASP.NET 1.0/1.1 - ASP.NET 2.0 - ASP.NET 3.5
- Windows 2003 - 2008 - 7
- Active Directory: every new release is a big release
- SharePoint: same as AD
In between, as you know it, they'll have CTPs and a big marketing around it to gather early adopters. I'm just too tired.
People can say "just because it's there, it doesn't mean you have to use it". Well dude, if your manager told you so (for street-creds during MS expo), YOU'RE THE ONE TO IMPLEMENT IT.
People can say "just use whatever you need". How am I suppose to know what I need when those tutorials and books are covering every single corner of the latest technology using BETA PREVIEW (this is a common practice for MS Press books). It's like finding a needle in a haystack.
At the end of the day, those books are just eliminating more trees and end up being obsolete in a matter of months. What a waste.