Τhis is officially the first post of our rebranded newsletter. I’d like to start with definitions. To be able to discuss about antifragility and what it means for software engineering, it is important that we:
Define antifragility outside the scope of software engineering.
Revisit software engineering’s history and investigate why the concept of antifragility is relevant to software.
Let’s begin.
Antifragility is a term coined by Nassim Nicholas Taleb circa 2012, when he published his book Antifragile: Things That Gain from Disorder. It is defined as a property of systems that gain from volatility, uncertainty, and stressors. It’s not merely about survival or adaptation; it’s about transformation. When a system is antifragile, shocks act as fuel for improvement. Mistakes become data, volatility becomes feedback, and randomness becomes a source of creativity.
At its heart, antifragility is a philosophy of engagement with the unpredictable. It asks us to design systems that learn, self-correct, and regenerate. It is a mindset that reframes uncertainty from a threat into an ingredient for progress.
What does antifragility have to do with Software Engineering?
During the 70s and the 80s a need became apparent. In certain cases, it was critical that we create software that would be as error free as possible. Margaret Hamilton, while working for the Apollo space programme, pioneered building in code to prevent failures due to user error or hardware failure. Software Engineering was born and popularized by a NATO conference in 1968. Software crisis, a term coined by Fritz Bauer in the same conference, described a critical shortage of programmers (sounds familiar?).
Throughout the 70s the software world tried to improve software quality. Structured programming, functional programming and object-oriented programming where some of the coding paradigms that emerged to assist this effort. Testing began to be recognized as separate from debugging when Glenford Myers wrote The Art of Software Testing in 1979. The software development life cycle (SDLC) was formalised in the 1980s and the waterfall model became commonplace after the US Department of Defence adopted it in 1985 [1].
This was the era of Software Robustness.
In computer science, robustness is the ability of a computer system to cope with errors during execution and cope with erroneous input.
~ Wikipedia [2]
Software Quality as a concept was heavily investigated by the academia. In [3] we found that there were a lot of Quality Models created between 1977 and 2013. They are sorted in Basic Models (1977-2001) evaluating software as a whole and Tailored Quality Models (2001-2013) which extend evaluation to components. Moreover, these models try to evaluate more than the source code. Robustness wasn’t enough any more.
Although resilience is connected with software since 2009, the connection mainly happens on an infrastructural level. When we talked about resilience in computer science at this period, we did it from the network perspective; how (the network) could cope with stressors like power outages, hacking attempts and so forth. During my PhD dissertation (2017-2023) I tried to introduce the concept of Software Resilience by using the research of the Arup + Rockefeller institutes; the City Resilience Framework. Although City Resilience Framework was meant to evaluate Urban Resilience, in [3] we argue that there are conceptual similarities between a city and an Open Source Software (OSS). OSS projects are dynamic and continuously evolving systems with their own structural properties, they attract people that form communities around them which, on a second level, may utilize a governance model. Some OSS projects have commercial activity. As it is happening with cities, OSS projects can face stresses and crises (i.e. developers abandoning the project to work on a fork or users massively migrate to a competitive project).
Now that we have established that software can be resilient, lets try to define resilience:
Resilience lies in the ability of a system to suffer stresses and crises and, nevertheless, survive them.
City Resilience Framework [4]
I approached the resilience of an Open Source Software, from four distinct dimensions.
It’s structure (source code)
It’s monetization capabilities (which reflect on the projects legal and business decisions).
It’s ability to be integrated to other projects or integrate other projects itself
(and, last but not least) it’s social aspect (aka its community of developers, users, stakeholders, etc).
Fast forward to the sunset of 2025, I feel antifragility is a prerequisite for survival. We are seeing the world and almost every aspect of our lives facing major challenges; major stressors. From the economic crisis that started on 2008 (and never really ended), the pandemic that followed in 2020 and now the wars that emerge in different parts of the earth, we see that we are navigating through troubled times. I strongly believe that it is imperative to move past resilience - the ability to navigate through a crisis without “losing ourselves” - to antifragility, the ability to learn from a crisis and come out wiser and ready to avoid it next time.
For software it is, more or less, the same. Nowadays the rapid evolution of interconnectivity through the World Wide Web and the rapid evolution of AI create opportunities for creativity and prosperity. At the same time, they bring challenges. Resources management, privacy and security issues and the hot topic of when we are going to be enslaved by the machines 🙃.
Regardless of how likely or unlikely, how intense or impactful these scenarios may be, we will need to bring software engineering to the next level.
Welcome to Software Antifragility!
References:
Harrison AJ. Robust Programs. In: How to Teach Computer Science. Available from: https://httcs.online/robust/.
Robustness (computer science). Wikipedia. Updated [cited 2025 Oct 8]. Available from: https://en.wikipedia.org/wiki/Robustness_(computer_science).
Kritikos A, Stamelos I. Open Source Software Resilience Framework. In: Stamelos I, Gonzalez-Barahona J, Varlamis I, Anagnostopoulos D, eds. Open Source Systems: Enterprise Software and Solutions. OSS 2018. IFIP Advances in Information and Communication Technology. Vol 525. Cham: Springer; 2018. doi:10.1007/978-3-319-92375-8_4
Da Silva J, Morera B. City resilience framework. Arup & Rockefeller Foundation. Online: http://publications. arup. com/Publications/C/C-
ity_Resilience_Framework.aspx [12/15/2015] 2014.
Kritikos, Apostolos & Stamelos, Ioannis. (2023). A resilience‐based framework for assessing the evolution of open source software projects. Journal of Software: Evolution and Process. 36. 10.1002/smr.2597.
