3 ms·
I doubt that's true, unless you mean it tautologically. There are plenty of good programmers working on software that matters that should absolutely not be tra
by wpietri 9y ago
I doubt that's true, unless you mean it tautologically.
There are plenty of good programmers working on software that matters that should absolutely not be trading off hazy possible benefits in 2052 for significant costs now.
It's occasionally necessary. When I wrote the code for Long Bets [1], I took a number of prudent steps to make sure things would have a good shot at surviving for decades. But I only took the cheap ones; the important thing was to ship on time.
And I think that's the right choice for most people. Technological change has slowed down some, but 35 years is still an incredible amount of volatility. Betting a lot of money on your theories of what will be beneficial then is very risky.
- justin66 9y ago> There are plenty of good programmers working on software that matters that should absolutely not be trading off hazy possible benefits in 2052 for significant costs now. I guess it's not obvious, but I think there's really a continuum here. You don't necessarily need to write software that will run perfectly in 2052, but it'd be good if you wrote software that can be comprehended, adapted and altered later on. Maintainability is never a "hazy benefit." (If the problem isn't a total throwaway.)
- wpietri 9y agoSure. Maintainability pays off relatively soon, and often makes systems simpler and cheaper to operate. But the topic in this sub-thread is the Y2K bug, where the proposed solution would have been expensive and provided no benefit for 35 years. And at the time, those benefits would have been very hazy.
- chrisweekly 9y ago> "Technological change has slowed down some" wat
- wpietri 9y agoIt's definitely true. Technical change in the 60s was enormous. During that period there was a lot of fundamental architectural change and experimentation; that's when they settled on 8-bit bytes as the standard, as well as many other things. Moore' Law became a thing. In the 70s is when we started seeing operating systems that look familiar to us, and even into the 80s it was plausible to introduce a new OS from scratch (see, e.g., NeXT, or Be). But Moore's Law is now dead: https://www.technologyreview.com/s/601441/moores-law-is-dead-now-what/ https://www.technologyreview.com/s/601441/moores-law-is-dead... Per-thread performance has been basically flat after decades of exponential gain: http://preshing.com/20120208/a-look-back-at-single-threaded-cpu-performance/ http://preshing.com/20120208/a-look-back-at-single-threaded-... The iPhone is a decade old; every phone now looks like it, and it's highly plausible that they'll look basically the same a decade from now, possibly much longer. Laptops are 30 years old; they've gotten cheaper, faster, and better, but are recognizably the same. HTML is coming up on 30, and it will be in use until long after I'm dead. TCP is nearly 40; Ethernet is over 40; even Wifi is 20. So it's just easier now to guess what programmers will be doing in 35 years compared to 1965.
- tonyedgecombe 9y agoI don't know, I think the attitudes that make you a good programmer mean you won't be satisfied leaving broken code in your product, no matter how far out the consequences are.