The two opposing forces of software: why career programmers will always have a job.

A lot of people have been complaining about the loss of jobs in the programming field, and it's only going to get worse they say. I don't think it's true. There will always be work for the career programmer. We just have to make sure we move up the abstraction ladder. Even in a world where basic coding is done overseas and many components are opensourced, there's still plenty of work to be done, and paid for.

The way I see it, from thirty thousand feet, software all about managing complexity: Finding ways to doing ever larger real world tasks on a computing device of some sort. I see two opposing forces here.

First: software always gets cheaper because the cost is front loaded. Theoretically you can write once and run forever. There is no per-unit cost so prices can approach zero (though once they get close to zero other forces start to take affect. sort of like quantum physics. :) This also means first adopters and monopolists have great advantage because they can always undercut the competition on price.

Second: the inherent complexity of software. As difficult as it is to write, software is even more difficult to maintain and integrate with other systems. Once you begin to customize the software it gets even more expensive. Add in a few new features and soon you've got a tangle of spaghetti that a swat team of extreme programmers can't unravel. And once we get it working and debugged (if you are so lucky) you got something new to do.

The good news is these two forces oppose each other and keep software moving forward. Without decreasing cost from reusability and development tools software would quickly get too expensive to build, much like the idea from the 50s of one day only having 5 computers in the world to do everything. (and all with the same bugs, no doubt). Without the inherent complexity of software all products would eventually be written, debugged, and free. And there would be no career programmers.

Together, the two forces mean programmers develop new technologies and move up the abstraction ladder, from bits to procedures to objects to markup and beyond. The history of software has always been about moving up the ladder, which not coincidentally means up the value food chain as far as the customer is concerned.

So where does this leave us, the career programmers?

Well, software will always be asked to do new things, so we will always have new things to code. This is good. But software will always become commoditized. Something I wrote today may be next to worthless tomorrow. This means I need to update my skills. But just learning a new technology isn't enough anymore. You have to move up food chain and closer to the user. If you want a job after the wonk-work is sent over seas and the components are all opensourced then you need to find new value to add to software. This may mean less actual coding and more product design. You are still coding, just at the level of requirements and mockups instead of Java or C. A good product is challenging to design, no matter what level you work at.

So where is the growth? What should we be concentrating on? This is where I see things going:

  • Rapid development technologies. The ability to prototype not only makes software development faster but better because design flaws can be seen earlier. Even better if the prototype can be transformed into a headstart on the real product through something like code generation.
  • Mastery of commoditized components. No one wants you to write a mail API, but if you know JavaMail really well, you can be hired to write software on top of it.
  • Mature implementations. In any software category some people will pay more for a better implementation even after the basic features have already been built. Take something and make it more secure. Faster. Easier to use. Even just plain prettier. There are many ways to add value besides features.
  • Requirements gathering. Ultimately the customer wants their requirements, which they may not even fully know, turned into software. This can't be done by someone overseas or from a prebuilt component. The ability to gather requirements and design custom systems, even from unknowing users, is very valuable. As software grows more complex the line between programmer and product designer will blur. I, for one, look forward to moving up the chain and closer to the user.

In the end we are all product designers: telling a stupid computer how to do something. so that someone else doesn't have to. We just have to stay ahead of the curve. The only thing that is changing is the way we do it. In the end the two forces of software will keep technology moving forward and we, the career programmers, need to always stay at the front of the push.

Talk to me about it on Twitter

Posted September 15th, 2003

Tagged: philosophy