3 ms·
> ...one interesting takeaway for me from this list is that all of them were preventable... Every disaster is preventable. Everything on the list was happening
by roenxi 3y ago
> ...one interesting takeaway for me from this list is that all of them were preventable...
Every disaster is preventable. Everything on the list was happening in human-engineered environments - as do most things that affect humans. The human race has been the master of its own destiny since the 1900s. The questions are how far before the disaster we need to look to find somewhere to act and what needed to be given up to change the flow of events.
But that doesn't have any implications for software engineering. Studying a software failure post mortem will be a lot more useful than studying 9/11.
- jacquesm 3y ago> Every disaster is preventable. No, there is such a thing as residual risk and there are always disasters that you can't prevent such as natural disasters. But even then you can have risk mitigation and strategies for dealing with the aftermath of an incident to limit the effects. > Everything on the list was happening in human-engineered environments - as do most things that affect humans. That is precisely why they were picked and make for good examples. > The human race has been the master of its own destiny since the 1900s. That isn't true and it likely will never be true. We are tied 1:1 to the fate of our star and may well go down with it. There is a small but non-zero chance that we can change our destiny but I wouldn't bet on it. And even then in the even longer term it still won't matter. We are passengers, the best we can do is be good stewards of the ship we've inherited. > The questions are how far before the disaster we need to look to find somewhere to act and what needed to be given up to change the flow of events. Indeed. So in the case of each of the items listed the RCA gives a point in time where the accident given the situation as it existed was no longer a theoretical possibility but an event in progress. Situation and responses determined how far it got and in each of the cases outlined you can come up with a whole slew of ways in which the risk could have been reduced and possibly how the whole thing may have been averted once the root cause had triggered. But that doesn't mean that the root cause doesn't matter, it matters a lot. But the root cause isn't always a major thing. An O-ring, a horseshoe... > But that doesn't have any implications for software engineering. If that is your takeaway then for you it indeed probably does not. But I see such things in software engineering every other week or so and I think there are many lessons from these events that apply to software engineering. As do the people that design reliable systems, which is why many of us are arguing for liability for software. Because once producers of software are held liable for their product a large number of the bad practices and avoidable incidents (not just security) would become subject to the Darwinian selection process: bad producers would go out of business. > Studying a software failure post mortem will be a lot more useful than studying 9/11. You can learn lots of things from other fields, if you are open to learning in general. Myopically focusing on your own field is useful and can get you places but it will always result in 'deep' approaches, never in 'wide' approaches and for a really important system both of these approaches are valid and complementary. To make your life easier the author has listed in the right hand column which items from the non-software disasters carry over into the software world, which I think is a valuable service. A middlebrow dismissal of that effort is throwing away an opportunity to learn, for free, from incidents that have all made the history books. And if you don't learn from your own and others' mistakes then you are bound to repeat that history. Software isn't special in this sense. Not at all. What is special is the arrogance of some software people who believe that their field is so special that they can ignore the lessons from the world around them. And as a corollary: that they can ignore all the lessons already learned in software systems in the past. We are in an eternal cycle of repeating past mistakes with newer and shinier tools and we urgently need to break out of it.
- roenxi 3y agoIt is 2023. The damage of natural disasters can be mitigated. When the San Andreas fault goes it'll probably get an entry on that list with a "why did we build so much infrastructure on this thing? Why didn't we prepare more for the inevitable?". And this article is throwing out generic all-weather good sounding platitudes which are tangential to the disasters listed. He drew a comparison between the Challenger disaster and bitrot! Anyone who thinks that is a profound connection should avoid the role of software architect. The link is spurious. Challenger was about catastrophic management and safety practices. Bitrot is neither of those things. I mean, if we want to learn from Douglas Adams he suggested that we can deduce the nature of all things by studying cupcakes. That is a few steps down the path from this article, but the direction is similar. It is not useful to connect random things in other fields to random things in software. Although I do appreciate the effort the gentleman went to, it is a nice site and the disasters are interesting. Just not relevantly linked to software in a meaningful way. > We are tied 1:1 to the fate of our star and may well go down with it I'm just going to claim that is false and live in the smug comfort that when circumstances someday prove you right neither of us will be around to argue about it. And if you can draw lessons from that which apply to practical software development then that is quite impressive.
- krisoft 3y ago> It is 2023. The damage of natural disasters can be mitigated. That is a comforting belief, but it is probably not true. We have no plan for a near-Earth supernova explosion. Not even in theory. Then there are asteroid impacts. In theory we could have plowed all of our resources into planetary defences, but in practice in 2023 we can very easily get sucker punched by a bolide and go the way of the dinosaurs.
- jacquesm 3y ago> It is 2023. So? Mistakes are still being made, every day. Nothing has changed since the stone age except for our ability - and hopefully willingness - to learn from previous mistakes. If we want to. > The damage of natural disasters can be mitigated. You wish. > When the San Andreas fault goes it'll probably get an entry on that list with a "why did we build so much infrastructure on this thing? Why didn't we prepare more for the inevitable?". Excellent questions. And in fairness to the people living on the San Andreas fault - and near volcanoes, in hurricane alley and in countries below sea level - we have an uncanny ability to ignore history. > And this article is throwing out generic all-weather good sounding platitudes which are tangential to the disasters listed. I see these errors all the time in the software world, I don't care what hook he uses to again bring them to attention but they are probably responsible for a very large fraction of all software problems. > He drew a comparison between the Challenger disaster and bitrot! So let's see your article on this subject then that will obviously do a much better job. > Anyone who thinks that is a profound connection should avoid the role of software architect. Do you care? It would be better to say that those that fail to be willing to learn from the mistakes of others should avoid the role of software architect because on balance that's where the problems come from. You seem to have a very narrow viewpoint here: that because you don't like the precision or the links that are being made that you can't appreciate the intent and the subject matter. Of course a better article could have been written and of course you are able to dismiss it entirely because of its perceived shortcomings. But that is exactly the attitude that leads to a lot of software problems: the inability to ingest information when it isn't presented in the recipients preferred form. This throws out the baby with the bath water, the authors intent is to educate you and others on the ways in which software systems break and uses something called a narrative hook to serve as a framework. That these won't match 100% is a given. Spurious connection or not, documentation and actual fact creeping out of spec aka the normalization of deviation in disguise is exactly the lesson from the Challenger disaster and if you don't like the wording I'm looking forward to your improved version. > Challenger was about catastrophic management and safety practices. That was a small but critical part in the whole, I highly recommend reading the entire report on the subject, it makes for fascinating reading, there are a great many lessons to be learned from this. https://www.govinfo.gov/content/pkg/GPO-CRPT-99hrpt1016/pdf/GPO-CRPT-99hrpt1016.pdf https://www.govinfo.gov/content/pkg/GPO-CRPT-99hrpt1016/pdf/... https://en.wikipedia.org/wiki/Rogers_Commission_Report https://en.wikipedia.org/wiki/Rogers_Commission_Report And many useful and interesting supporting documents. > I mean, if we want to learn from Douglas Adams he suggested that we can deduce the nature of all things by studying cupcakes. That's a complete nonsensical statement. Have you considered that your initial response to the article precludes you from getting any value from it? > It is not useful to connect random things in other fields to random things in software. But they are not random things. The normalization of deviation in whatever guise it comes is the root cause of many, many real world incidents, both in software as well as outside of it. You could argue with the wording, but not with the intent or the connection. > Although I do appreciate the effort the gentleman went to, it is a nice site and the disasters are interesting. Just not relevantly linked to software in a meaningful way. To you. But they are. > > We are tied 1:1 to the fate of our star and may well go down with it > I'm just going to claim that is false and live in the smug comfort that when circumstances someday prove you right neither of us will be around to argue about it. So, you are effectively saying that you persist in being wrong simply because the timescale works to your advantage? > And if you can draw lessons from that which apply to practical software development then that is quite impressive. Well, for starters I would argue that many software developers indeed create work that serves just long enough to hold until they've left the company and that that attitude is an excellent thing to lose and a valuable lesson to draw from this discussion.