COMPETITION COMPETITION COMPLETION:

INTRODUCTION

In 2013, he took the media research into University College London with a subtitle about a computer that "never falls." It wasn't magic hardware without a malfunction. It was an experimental approach called systematic computing, which was designed to remove the program of dependence on one fragile sequence of instructions and allow the system to reorganise itself after errors.

The idea is still up to date. Modern cloud infrastructure, space systems, and security critical controls no longer count on no part ever failing. On the contrary: they assume that the error will come and design the whole to survive it.

1. WHY THE COMPUTER FALLS

A common computer program performs an exact sequence of instructions and assumes that hardware, memory, files and network are in the expected state. If the assumption is broken, the error can be promoted by the system.

The causes range from programmer error to defective bit in memory to disk failure, power failure, loss of network connection or race of two processes. A worse problem is added for distributed systems: part of the system does not know if another node is dead, slow or only disconnected.

"A computer that never goes wrong" can therefore not be built by making a perfect transistor. We must assume imperfections and propose a way of recovery.

2. SYSTEM COMPUTING UCL

Peter Bentley and Christos Sakellariou of UCL were exploring architecture inspired by biological systems. Instead of one solid program, they had a number of small systems that responded to each other and whose organization was not linked to one exact address in memory.

The experimental computer should have been able to continue after damage to part of its condition. The code and data were distributed and the system could create a new functional configuration from the available parts.

The media acronym "never crashes" was, of course, an exaggeration. Any physical system can be destroyed by a sufficiently large disorder. But research rightly showed a change in philosophy: not to prevent all errors, but to allow the system to survive some errors without a global fall.

3. DIJKSTRA AND SELF-STABILIZATION

The idea of self-repairing the distributed system is older. Edsger W. Dijkstra in 70. years formulated the concept of self-stabilization: the system can get into any wrong state, but if errors stop coming, its protocol will gradually return it to a legitimate state without external reboot.

It's a very strong quality. We don't need to know exactly how the disorder came about. All you have to do is prove that the system rules from any permissible state converge back to order.

4. ECC RECALLING: RECORD TO IT BEFORE THE PROGRAMME ALWAYS REPEALED IT

At the hardware level, Error- Correcting Code memory is commonly used. It adds redundant bits to stored data, which allow detection and often repair of a single-bit error.

Such a mistake may be caused by electrical interference or ionising radiation. In servers that have worked for years with a large amount of RAM, the probability is not negligible.

ECC shows the basic principle of resistance: redundancy is not a waste if it can help us recognize the error from valid data.

5. RAID AND REPLACES OF DATA

The same idea is used by disk fields. RAID can divide the data and add parity so that one or more disks fail to destroy the whole volume.

In data centres, the protection is moved up: a file or object exists on several physical servers, sometimes even in several buildings or geographical regions. When one knot disappears, another will serve the client.

There's nothing "indestructible" here either. If we delete all replicas or replicate the wrong data synchronously everywhere, the redundancy will not help. The resistance always depends on the type of failure against which it is designed.

6. DISTRIBUTED CONSENZUS

Systems such as database clusters must address not only the availability, but also the question of which version of data is correct. The Paxos or Raft family algorithms allow a group of nodes to agree on the order of changes, even if some nodes fail or are temporarily unavailable.

This is one of the pillars of modern cloud services. The user may perceive one service, but in fact there are dozens or thousands of processes behind it that replace their dead members on a continuous basis.

7. BYZANT FISH

Even harder scenario occurs when the node not only keeps quiet, but provides different or incorrect information to different parts of the system. It's modelled like a Byzantine fault.

Byzantine Fault Tolerance algorithms use greater redundancy and voting so that the system can continue with a certain number of faulty or compromised nodes. The principle is used in some critical distributed systems and is related to the consensus mechanisms in the part of the blockchain networks.

8. WATCHDOG: IF THE PROGRAMME IS SET UP

A simpler but very effective technique is watchdog timer. The program must periodically confirm that he is alive. If the confirmation does not arrive, the independent circuit or process will restart.

Watchdogs are common in Embedded Systems, Automotive, Industry, Router and Space Electronics. Sometimes the best self-repair is simply a controlled restart of a small part of the system instead of the fall of the whole device.

9. COSMIC SONDES: FAULT TOLERANCE WITHOUT SERVISM TECHNOLOGY

The spacecraft is an extreme example. Hardware works in radiation, communication can take minutes or hours and technician can't replace the defective module.

Therefore, redundant avionics, radiation-resistant electronics, ECC, safe modes and autonomous diagnostics are used. If the software finds an inconsistent state, the probe can go to safe mode, shoot the panels to the sun and wait for instructions.

"Not to collapse" here is not always to continue at full speed. It means moving to a simpler state in which the device survives.

10. ERLANG: "LET IT CRASH'

The programming language Erlang, originally developed for Ericsson's telecommunications systems, was famous for the philosophy of "let it crash." It doesn't mean ignore mistakes. It means dividing the program into isolated processes, whose failure can be detected by a superior supervisor and create a defective part again.

Instead of a huge monolith where one-thread error poisons the whole process, we have many small components with a clear reboot strategy.

11. CONTENERS AND ORCHESTRATIONS

Modern Kubernetes and other orchestrations formalize a similar principle in data centres. If the container stops responding to the health check, the orchestra will end it and create a new one. If the entire server dies, the workload will move on.

The user may experience a small failure or none, although the hardware has indeed failed within the infrastructure.

12. CHAOS ENGINEERING: WE MAKE AN INJURY

Netflix and other operators of large-scale distributed services popularized chaos engineering. The idea is radical: if we claim that the system survives the malfunction, we do not wait for a random incident. We have to safely and controlled the instances, increase latency or simulate the region's failure and verify that the design really works.

This changes reliability from faith to experimentally tested property.

13. Why "100% UPTIM" IS NOT PHYSICALLY REALISTIC

Each system has the limit of its fault model. Two redundant sources won't help with the entire building's fire. Three data centres will not help if the software contains a common error that simultaneously damages the data in all three. The advance won't help if we never try to restore it.

Therefore, engineers work with the availability targets - for example 99.9%, 99.99% or more - and with the terms RTO and RPO, i.e. the time needed to restore and maximum acceptable data loss.

14. SELF-HEALING AND AI

Current platforms use machine learning to detect anomalies, predict disk failures or dynamic scaling. The term "self-healing" is so often used for a system that itself detects degradation and performs corrective action.

However, AI does not remove the essential need for deterministic security mechanisms. The model can be wrong. Critical infrastructure therefore needs clear limits, fallback, auditability and the possibility of human intervention.

15. HOW WOULD THE "WRONG" OS REALLY BE?

Instead of one fantastic feature, it would combine many layers:

• ECC memory;
• data control totals;
• Process isolation;
• a transaction file system;
• snapshots and rollback;
• watchdog;
• redundant services;
• automatic health checks;
• Replicated storage;
• deterministic safe mode;
• continuous testing of recovery.

Such a system can act as if it "never fell" because it continuously absorbs individual falls.

CONCLUSION

A computer that never physically breaks down doesn't exist. But a computer system that can survive many failures without losing its service is not a science-fi. It is the basis of a modern design of critical infrastructure.

UCL's research in 2013 was interesting not because it would finally eliminate all errors, but because it highlighted a biologically inspired idea: the robust system may not be perfectly unchanged. It can be robust precisely because it is continuously rearranged, it throws away defective parts and reproduces a functional state.

16. MICROYADRO AND CHYB ISOLATION

One way to prevent a chain reaction is to reduce the amount of code running with the highest permissions. Microcore operating systems move drivers and services out of the small core. If the sound card driver falls, it may not damage the whole kernel.

The formally verified micronucleus of the L4 goes even further: the important properties of the implementation were mathematically linked to the specification. This does not mean indestructible, but drastically reduces the class of software errors that may violate isolation.

17. CRASH CONSISTENCES: HOW TO NOT DESTROY DATA IN THE WEAK OF THE PROUDH

Let's imagine that the file system first marks the block as used and then writes down its contents. If electricity falls between steps, the disk can remain in a inconsistent state.

Journaling, copyon-writing and transaction techniques therefore change the order of entries so that after restart it can be clearly decided between the old and the new state. The system does not expect to be powered; it proposes a data structure so that failure at any moment will not cause uncontrolled corruption.

18. COMMONE-MODE FAILURE: UNFRIEND OF REDUNDANCE

Two servers are not really independent if they are both in one rack powered by one source. Three data centres are not completely independent if the same error update is running in all of them.

The most dangerous errors are the common-mode faculures - one cause will hit all the redundant parts simultaneously. Therefore critical systems try to diversify software, hardware, locations and sometimes implement the same function.

19. BYZANTA RESISTANCE AND SAFETY ARE NOT THE SAFETY

Fault tolerance solves a random or modelled disorder. But the cyber bomber is acting adaptive and trying to find exactly the path the designer wasn't expecting. Redundance can increase safety, but also enhance attack surface.

The truly durable system therefore connects recovery with the principles of least privileges, authentication, cryptography, audit logo and network segmentation.

20. "NON-FALLING 'SYSTEM IS PROCESS, NOT PRODUCT

Reliability is not a property that the manufacturer will once add and then forget about. Addiction changes, firmware ages, certificates are expired, and people make new mistakes. Therefore, advanced organisations have an incident response, post-mortem analysis and regularly test recovery.

So the most resilient system is not the one that says "never fails," but the one that can tell exactly what it will do when a part fails.

RESOURCES AND OTHER READING

[1] University College London - Computer that never crashes (2013), systematic computing.

ucl.ac.uk
https://www.ucl.ac.uk/news/headlines/2013/feb/computer-never-crashes

[2] Dijkstra, E. W. - Self-stabilizing systems in spite of distributed control (historical basis of self-stabilization; summaries and literature).

link.springer.com
https://link.springer.com/book/10.1007/978-3-031-02013-1

[3] The Raft Consensus Algorithm - original project and materials.

raft.github.io
https://raft.github.io/

[4] Kubernetes documentation - Self-healing.

cabernetes.io
https://kubernetes.io/docs/concepts/architecture/self-healing/

[5] NASA - Fault management / space engineering resources.

naj.gov
https://www.nasa.gov/