Ask HN: can software be made "anti-fragile" (aka "better than just robust")?
5 comments
Yes. GNUemacs is an example. It avoids fragility by being so extensively configurable - entirely configurable some might argue because the source code is available. There are few other programs that have survived thirty years, let alone been among the leaders of their field that long.
Compare this to the fragility of an iPhone App. Apple can change the OS. They can change the TOS for their store. They can produce a new incompatible model, or one with additional features. A competitor can create a better combination of phone and marketplace. People can get tired of the limited thing an app is allowed to do.
Compare this to the fragility of an iPhone App. Apple can change the OS. They can change the TOS for their store. They can produce a new incompatible model, or one with additional features. A competitor can create a better combination of phone and marketplace. People can get tired of the limited thing an app is allowed to do.
> Just wondering if anyone ever developed some more in-depth thoughts of the possibilities of "anti-fragility by design" in the tech world (specifically software). Not as in "software that lasts a lifetime" (COBOL mainframes anyone?) but building stuff that somehow "gets better".
Software itself might be able to, though I suspect that's a hard problem, in the technical sense. Software considered in conjunction with the social system surrounding it which provides maintenance, etc., certainly can be, but that's a social problem rather than a technical one (and, really, the solutions to it are pretty much the same as making the social system better even if the processes it was managing are not automated.)
Software itself might be able to, though I suspect that's a hard problem, in the technical sense. Software considered in conjunction with the social system surrounding it which provides maintenance, etc., certainly can be, but that's a social problem rather than a technical one (and, really, the solutions to it are pretty much the same as making the social system better even if the processes it was managing are not automated.)
Of course, software itself ought to do it. I don't know if that's a hard problem, but that's a meta-programming problem. Not something you can do easily if you don't use lisp.
> Of course, software itself ought to do it.
Antifragility for most real world software means that the quality has to improve over time even though requirements are changing. Unless the software is adapting itself to new requirements (as well as maintaining itself), that means that the net outcome of development and maintenance efforts has to be an improvement in quality. While the design of the software can be a major factor here (making antifragility easier to achieve or harder), it still depends on the system outside of the software that is developing and maintaining it.
> I don't know if that's a hard problem, but that's a meta-programming problem.
I'd suggest its a problem equivalent to solving strong AI.
> Not something you can do easily if you don't use lisp.
Lisps aren't the only class of languages that support easy metaprogramming, and language support for easy metaprogramming doesn't do much to get you closer to the goal here, anyway.
Antifragility for most real world software means that the quality has to improve over time even though requirements are changing. Unless the software is adapting itself to new requirements (as well as maintaining itself), that means that the net outcome of development and maintenance efforts has to be an improvement in quality. While the design of the software can be a major factor here (making antifragility easier to achieve or harder), it still depends on the system outside of the software that is developing and maintaining it.
> I don't know if that's a hard problem, but that's a meta-programming problem.
I'd suggest its a problem equivalent to solving strong AI.
> Not something you can do easily if you don't use lisp.
Lisps aren't the only class of languages that support easy metaprogramming, and language support for easy metaprogramming doesn't do much to get you closer to the goal here, anyway.
https://docs.google.com/file/d/0B_31K_MP92hURjZxTkxUTFZnMVk/...
For a more in depth treatment of anti-fragility. Read anti-fragility a couple of times. One of the one most important ideas of our time (IMO). Btw, your intuitive linking of "age degradation" is also pointed out by Taleb albeit in a different manner. His premise is that ideas that have persisted for a long time are anti-fragile. This is because they have been subjected to shocks, to ridicule, to experimentation and these ideas have become better. Age of existence is one of many indicators of anti-fragility.
For a more in depth treatment of anti-fragility. Read anti-fragility a couple of times. One of the one most important ideas of our time (IMO). Btw, your intuitive linking of "age degradation" is also pointed out by Taleb albeit in a different manner. His premise is that ideas that have persisted for a long time are anti-fragile. This is because they have been subjected to shocks, to ridicule, to experimentation and these ideas have become better. Age of existence is one of many indicators of anti-fragility.
Much appreciated!
You might be interested in Inconsistency Robustness 2011 at
http://www.robust11.org/
Cheers, Carl
Cheers, Carl
You're conflating two separate issues -- that of software fragility and software lifetime. Some software breaks too easily. Some software ages too quickly. Those are separate issues.
> Just wondering if anyone ever developed some more in-depth thoughts of the possibilities of "anti-fragility by design" ...
But that's classic computer science. There's no debate about manual and automatic testing and intelligent error handling -- all software needs to have it.
> but building stuff that somehow "gets better".
To "get better" without human intervention would require a computer system so intelligent that it creates local violations of entropy, sort of like people, and that imitates evolution and natural selection.
We haven't remotely gotten to that point yet -- computers and computer languages would need to be much more powerful than they are. They will eventually be, but more time and energy will be required.
> Just wondering if anyone ever developed some more in-depth thoughts of the possibilities of "anti-fragility by design" ...
But that's classic computer science. There's no debate about manual and automatic testing and intelligent error handling -- all software needs to have it.
> but building stuff that somehow "gets better".
To "get better" without human intervention would require a computer system so intelligent that it creates local violations of entropy, sort of like people, and that imitates evolution and natural selection.
We haven't remotely gotten to that point yet -- computers and computer languages would need to be much more powerful than they are. They will eventually be, but more time and energy will be required.
No, you are assuming that a software system includes just the program.
In a more holistic view, a software system includes the program and its developer community. In that sense, certain software such as Emacs and Linux has clearly proved itself antifragile, whereas most other software is clearly fragile.
The test for antifragility is this: Does the software improve with the presence of time and when faced with change?
If it does, it is antifragile. No need to add more conditions like "no developer changes are needed". Developers are part of the software system.
In a more holistic view, a software system includes the program and its developer community. In that sense, certain software such as Emacs and Linux has clearly proved itself antifragile, whereas most other software is clearly fragile.
The test for antifragility is this: Does the software improve with the presence of time and when faced with change?
If it does, it is antifragile. No need to add more conditions like "no developer changes are needed". Developers are part of the software system.
> In a more holistic view, a software system includes the program and its developer community.
Software systems are embedded in broader systems which include the developers, users, etc. But it is not helpful to communication to call those broader systems the "software system", which has a well understood meaning.
Software systems are embedded in broader systems which include the developers, users, etc. But it is not helpful to communication to call those broader systems the "software system", which has a well understood meaning.
> Developers are part of the software system.
For that meaning, don't use the word "software". The word software has a well-understood meaning that a developer community surrounding a code base doesn't meet.
> The test for antifragility is this: Does the software improve with the presence of time and when faced with change?
Software cannot do that on its own. Remember, we're using the word with its accepted meaning.
For that meaning, don't use the word "software". The word software has a well-understood meaning that a developer community surrounding a code base doesn't meet.
> The test for antifragility is this: Does the software improve with the presence of time and when faced with change?
Software cannot do that on its own. Remember, we're using the word with its accepted meaning.
The tech world moves so fast, all we indie devs or "small teams" can reasonably attack are "toyish gigs". "Side projects." Hackathons, 24-hour/weekend projects... isitsunnyin.com/location etc. Or, participate early (as freelancers or contributors) in a new wave that may at least "sustain" us for perhaps a decade before expiry. 10 years ago .NET or PHP, 5 years ago mobile, today "big data" or Go. Well that's not too shabby... BUT -- I'm still wondering about this and I'm about to dive into this read:
http://en.wikipedia.org/wiki/Antifragile:_Things_That_Gain_from_Disorder
"Some things benefit from shocks; they thrive and grow when exposed to volatility, randomness, disorder, and stressors and love adventure, risk, and uncertainty. Yet, in spite of the ubiquity of the phenomenon, there is no word for the exact opposite of fragile. Let us call it antifragile. Antifragility is beyond resilience or robustness. The resilient resists shocks and stays the same; the antifragile gets better."
Just wondering if anyone ever developed some more in-depth thoughts of the possibilities of "anti-fragility by design" in the tech world (specifically software). Not as in "software that lasts a lifetime" (COBOL mainframes anyone?) but building stuff that somehow "gets better".
Anyway, I'm off to some studying, looking forward to any insights from the fine crowds in this arena..