Antifragility & Applications

There is an approach I’m taking from programming to my use of my choice of operating systems and applications I use. The aim is to both remove dependence on complex solutions for otherwise simple problems.

A classic example, in programming, is if you’re using a framework then quite often that framework can become the main focus of any / all development. The benefits are that you can often build an application quickly and to an apparently low cost, and often there can be good community support.

However, the long-term costs are manifold:

• Investing time in a framework whose purpose is not to support your specific needs
• Frameworks can be also dependant on underlying technologies
• Critical business logic may be buried deep in nested folders within the application
• Some technology employed by the framework is likely to be not well known to developers, if they ever need to update it
• Switching to a different technology may become impossible
• Common frameworks are frequently targeted

Almost all websites are created by third-party agencies using popular frameworks (e.g. so-called “full-stack” frameworks like Laravel or Drupal, in the case of PHP applications), and they are also mostly neglected after installation. The websites might receive new content, but it often unlikely that the underlying software will be regularly and dependably updated. Then you get agencies that specialise in fixing broken or outdated systems, but that will normally involve a substantial rewrite and/or significant costs.

One alternative is akin to micro-services. Have a solution that depends on as few as possible moving parts, and modular in the sense that parts of it can be dropped and rebuilt at the drop of a hat.

For PHP, there now exists the PHP Framework Interop Group, which is a set of interfaces and standards that libraries are encouraged to adopt, and so they can be used interchangeably in your application with little or no effect within the business domain.

For Linux, there is the fundamental concept that every resource on the system is a file. This allows any program to interact with another without any direct knowledge or understanding of another program.