…mostly I’m struck by the irony that the tools, networks, and protocols built over the last 40 years by programmers are the exact mechanism that allows these jobs to move overseas. It’s fast Internet connections and carefully designed software that makes it possible for a programmer in Bangalore to work for a company in Palo Alto. The programmers are being eaten by the creature they made themselves.
It’s a neat, ourosbouros-esque, hoist-by-their-own-petard conclusion. But it’s not true.
What makes offshoring possible (and I’m assuming here that it’s this, the cross-border-to-cheap-labour way of losing your job, to which Paul’s really referring) isn’t programming, except in the general sense that programming is important as an element in most modern technology. It’s communications; the international direct dial phone system. It’s convenient, cheap air travel. It’s the international system of law that allows contracts to operate between organisations in different countries. It’s the mobility of capital. And, in amongst these, it’s the success of the ideas that are the Internet protocols.
If TCP/IP had not taken off as it did, and the huge unwieldy bulk of the ISO layered model had continued to balkanize the Connected Globe, perhaps it wouldn’t be this way. Instead, we’d have a world of Compuserves and Prodigies, where MSN and AOL fought battles over exclusivity of content. There would be no ISPs, merely relationships with one or other subsidiary of this or that multinational entertainment conglomerate. But the idea of a net based on standards that everyone followed persisted, not (I submit) through any innate virtue in the engineers or device designers who built it, but from a sort of momentum – the open standards were the grit around which the oyster formed the pearl. The bigger the pearl, the more obvious the benefits of joining.
But this is going off topic, and not in a good way. The charmingly closured conclusion that programmers are the architects of their own demise is my target. Let’s consider it from two angles.
First, the personal. I know many programmers, as one might expect. I’m not aware that any of those who are facing aspects of their livelihood going overseas have actively been part of that by writing code. Perhaps their jobs have changed to include managerial duties that make it easier for someone else to do the coding, but that’s not the same. In most cases, it’s the guys I know working on the big commercial systems who have suffered, and their code has nothing whatsoever to do with networks; it’s all accounts, balances and reports. I suppose one could, with sufficient diligence, find someone working in one of the big phone equipment providers, or maybe Cisco, who’s lost out to a programmer in Pakistan or a hacker in Hyderabad, but that doesn’t make a general case.
Second, the general. Programmers are not a community, they’re a set, with more or less fuzzy boundaries depending on how one defines a “programmer”. There is no accepted set of agreed targets and goals to which a community might aspire; in fact, ten minutes spent trawling through the areas of USENET wherein programmers debate shows that disagreement happens as often between programmers as between politicians, and sometimes with more venom. The image of a mass of swarming humanity building a great Cathedral to a Master Plan is wrong.
As a group, programmers write Code to make Systems do Stuff. Engineers are another set (with a degree of overlap) who build Things that Do Stuff, possibly the same Stuff. We can proceed to do the same for any of the groups whose contributions to the Way The World Is have made offshoring (a) possible and (b) commercially attractive. In general, one could argue for hours over the exact details of whose contributions are more relevant than whose, but to little overall effect. Like the Industrial Revolution ushered in the Age of the Factories and led to the general demise of the village and the cottage industry, the Network Revolution has led to a world in which many things are possible, but was itself dependent on other Revolutions. Only a few of those are technical.
 I was writing Ethernet device software Back Then, and have memories of tediously reverse-engineering ICL printer protocols to try and deduce how the damn things worked. Proprietary sucked then as now.