
Ask HN: can software be made "anti-fragile" (aka "better than just robust")? - dualogy
Software ages too fast for my liking! After a few years in this game, every time a "substantial" idea gets me excited, my brain wanders quickly to this thought: "yeah, let's roll down this rabbit hole again. Spend over a year on something that soon won't matter, be outdated or erode into plain non-functioning state in around or under 5 years".<p>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:<p>http://en.wikipedia.org/wiki/Antifragile:_Things_That_Gain_from_Disorder<p>"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."<p>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".<p>Anyway, I'm off to some studying, looking forward to any insights from the fine crowds in this arena..
======
brudgers
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.

------
dragonwriter
> 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.)

~~~
informatimago
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.

~~~
dragonwriter
> 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.

------
verdatel
[https://docs.google.com/file/d/0B_31K_MP92hURjZxTkxUTFZnMVk/...](https://docs.google.com/file/d/0B_31K_MP92hURjZxTkxUTFZnMVk/edit?pli=1)

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.

~~~
dualogy
Much appreciated!

------
CarlHewitt
You might be interested in Inconsistency Robustness 2011 at
<http://www.robust11.org/>

Cheers, Carl

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

~~~
zenbowman
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.

~~~
lutusp
> 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.

