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 spagetti 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.