How to Design for Failures

It is impossible to build a failure-proof software system. A system can run through its lifecycle without failing, but no one can guarantee it will never fail. Writing perfect code does not solve the problem, because even flawless software depends on a physical computer, power, working storage and other components. If the machine loses power, the software will fail regardless of its quality. For this reason, engineers must design for failure, deciding in advance how a system should behave when some of its parts are not working correctly.

This article looks at strategies that help developers deal with failures in their systems. It begins with the reasoning behind an "assume everything breaks" mindset, which prepares teams to expect faults rather than treat them as rare exceptions. It then contrasts avoiding faults with tolerating them, two approaches that serve different purposes in system design.

From there, the discussion turns to practical techniques. Developers need to work out the scope of a failure so they know which parts of a system are affected and which remain healthy. They also need ways to reduce the impact of a failure, so that a problem in one component does not spread across the whole platform.

Finally, the article covers how to handle failures while the system is still running correctly, and how to measure recovery from failures. Tracking how quickly and completely a system recovers gives teams concrete feedback on whether their failure-handling strategies actually work.

من المستحيل بناء نظام برمجي محصّن تماماً ضد الأعطال. قد يمرّ النظام بدورة حياته كاملة دون أن يتعطل، لكن لا أحد يستطيع أن يضمن ألا يتعطل أبداً. كتابة شيفرة مثالية لا تحل المشكلة، لأن حتى البرمجيات الخالية من الأخطاء تعتمد على حاسوب مادي، وعلى الطاقة، وعلى وحدات تخزين تعمل، وعلى مكونات أخرى. فإذا فقدت الآلة الطاقة، فسيتعطل البرنامج مهما كانت جودته. ولهذا السبب يجب على المهندسين التصميم للأعطال، أي تحديد سلوك النظام مسبقاً عندما يتوقف بعض أجزائه عن العمل بشكل صحيح.

يتناول هذا المقال الاستراتيجيات التي تساعد المطورين على التعامل مع الأعطال في أنظمتهم. يبدأ بالمنطق الكامن وراء عقلية "افترض أن كل شيء قد يتعطل"، وهي عقلية تُعد الفرق لتوقع الأخطاء بدلاً من اعتبارها استثناءات نادرة. ثم يقارن بين تجنب الأعطال وتحمّلها، وهما نهجان يخدمان أغراضاً مختلفة في تصميم الأنظمة.

ومن هنا ينتقل النقاش إلى التقنيات العملية. يحتاج المطورون إلى تحديد نطاق العطل ليعرفوا أي أجزاء النظام تتأثر وأيها يبقى سليماً. كما يحتاجون إلى طرق تقلل من تأثير العطل، حتى لا تمتد مشكلة في مكون واحد إلى المنصة بأكملها.

وأخيراً، يتناول المقال كيفية التعامل مع الأعطال أثناء استمرار عمل النظام بشكل صحيح، وكيفية قياس التعافي من الأعطال. فتتبع سرعة النظام واكتمال تعافيه يمنح الفرق تغذية راجعة ملموسة حول ما إذا كانت استراتيجيات معالجة الأعطال تعمل فعلياً.

একটি সম্পূর্ণ ব্যর্থতা-প্রতিরোধী সফটওয়্যার সিস্টেম তৈরি করা অসম্ভব। একটি সিস্টেম তার পুরো জীবনচক্রে ব্যর্থ না হয়েই চলতে পারে, কিন্তু এটি কখনো ব্যর্থ হবে না, এমন নিশ্চয়তা কেউ দিতে পারে না। নিখুঁত কোড লিখলেও সমস্যার সমাধান হয় না, কারণ একদম ত্রুটিহীন সফটওয়্যারও একটি ভৌত কম্পিউটার, বিদ্যুৎ, কার্যকর স্টোরেজ এবং অন্যান্য উপাদানের ওপর নির্ভর করে। যদি মেশিনের বিদ্যুৎ চলে যায়, তবে সফটওয়্যারের মান যাই হোক না কেন তা ব্যর্থ হবে। এই কারণে প্রকৌশলীদের ব্যর্থতার জন্য ডিজাইন করতে হয়, অর্থাৎ সিস্টেমের কিছু অংশ সঠিকভাবে কাজ না করলে সিস্টেমটি কেমন আচরণ করবে, তা আগে থেকেই ঠিক করে রাখতে হয়।

এই নিবন্ধে এমন কৌশলগুলো আলোচনা করা হয়েছে যেগুলো ডেভেলপারদের নিজেদের সিস্টেমে ব্যর্থতা মোকাবিলায় সাহায্য করে। এটি "ধরে নিন সবকিছুই ভেঙে যেতে পারে" এই মানসিকতার যুক্তি দিয়ে শুরু হয়, যা দলগুলোকে ত্রুটিকে বিরল ব্যতিক্রম না ভেবে তা আশা করতে প্রস্তুত করে। এরপর ত্রুটি এড়ানো এবং ত্রুটি সহ্য করার মধ্যে তুলনা করা হয়েছে, যে দুটি পদ্ধতি সিস্টেম ডিজাইনে আলাদা উদ্দেশ্য পূরণ করে।

এরপর আলোচনা ব্যবহারিক কৌশলের দিকে মোড় নেয়। ডেভেলপারদের ব্যর্থতার পরিধি নির্ধারণ করতে হবে, যাতে তারা জানে সিস্টেমের কোন অংশ প্রভাবিত এবং কোনটি সুস্থ রয়েছে। ব্যর্থতার প্রভাব কমানোর উপায়ও তাদের দরকার, যাতে একটি উপাদানের সমস্যা পুরো প্ল্যাটফর্মে ছড়িয়ে না পড়ে।

সবশেষে, নিবন্ধে দেখানো হয়েছে সিস্টেম সঠিকভাবে চলার সময় কীভাবে ব্যর্থতা সামলাতে হয় এবং ব্যর্থতা থেকে পুনরুদ্ধার কীভাবে পরিমাপ করতে হয়। সিস্টেম কত দ্রুত ও কতটা সম্পূর্ণভাবে ফিরে আসে তা ট্র্যাক করলে দলগুলো বাস্তব প্রতিক্রিয়া পায় যে তাদের ব্যর্থতা-ব্যবস্থাপনার কৌশল সত্যিই কাজ করছে কি না।

Ein vollständig ausfallsicheres Softwaresystem zu bauen ist unmöglich. Ein System kann seinen gesamten Lebenszyklus ohne Ausfall durchlaufen, doch niemand kann garantieren, dass es nie ausfällt. Perfekter Code löst das Problem nicht, denn auch fehlerfreie Software hängt von einem physischen Computer, von Strom, funktionierendem Speicher und anderen Komponenten ab. Verliert die Maschine die Stromversorgung, fällt die Software aus, unabhängig von ihrer Qualität. Aus diesem Grund müssen Ingenieure für Ausfälle entwerfen und im Voraus festlegen, wie sich ein System verhalten soll, wenn einige seiner Teile nicht korrekt arbeiten.

Dieser Artikel betrachtet Strategien, mit denen Entwickler Ausfälle in ihren Systemen bewältigen können. Er beginnt mit der Begründung für die Haltung „Alles kann ausfallen“, die Teams darauf vorbereitet, Fehler zu erwarten, statt sie als seltene Ausnahmen zu behandeln. Anschließend werden Fehlervermeidung und Fehlertoleranz gegenübergestellt, zwei Ansätze, die beim Systementwurf unterschiedlichen Zwecken dienen.

Danach wendet sich die Diskussion praktischen Techniken zu. Entwickler müssen den Umfang eines Ausfalls bestimmen, um zu wissen, welche Teile eines Systems betroffen sind und welche intakt bleiben. Sie brauchen außerdem Wege, die Auswirkungen eines Ausfalls zu verringern, damit ein Problem in einer Komponente nicht auf die gesamte Plattform übergreift.

Schließlich behandelt der Artikel, wie Ausfälle behandelt werden, während das System weiterhin korrekt läuft, und wie sich die Wiederherstellung nach Ausfällen messen lässt. Die Nachverfolgung, wie schnell und vollständig sich ein System erholt, liefert Teams konkretes Feedback darüber, ob ihre Strategien zur Fehlerbehandlung tatsächlich funktionieren.

Es imposible construir un sistema de software a prueba de fallos. Un sistema puede completar su ciclo de vida sin fallar, pero nadie puede garantizar que nunca lo hará. Escribir código perfecto no resuelve el problema, porque incluso el software impecable depende de un ordenador físico, de la energía, del almacenamiento en buen estado y de otros componentes. Si la máquina pierde energía, el software fallará independientemente de su calidad. Por esta razón, los ingenieros deben diseñar para el fallo, decidiendo de antemano cómo debe comportarse un sistema cuando algunas de sus partes no funcionan correctamente.

Este artículo analiza estrategias que ayudan a los desarrolladores a gestionar los fallos en sus sistemas. Comienza con el razonamiento detrás de la mentalidad de "asumir que todo se rompe", que prepara a los equipos para esperar averías en lugar de tratarlas como excepciones raras. Después contrasta evitar los fallos con tolerarlos, dos enfoques que sirven para propósitos distintos en el diseño de sistemas.

A partir de ahí, la discusión se centra en técnicas prácticas. Los desarrolladores deben determinar el alcance de un fallo para saber qué partes del sistema se ven afectadas y cuáles siguen sanas. También necesitan formas de reducir el impacto de un fallo, para que un problema en un componente no se extienda a toda la plataforma.

Por último, el artículo aborda cómo gestionar los fallos mientras el sistema sigue funcionando correctamente, y cómo medir la recuperación tras un fallo. Seguir la rapidez y la integridad con que un sistema se recupera ofrece a los equipos una retroalimentación concreta sobre si sus estrategias de gestión de fallos funcionan realmente.

Il est impossible de construire un système logiciel infaillible. Un système peut traverser tout son cycle de vie sans tomber en panne, mais personne ne peut garantir qu'il ne tombera jamais en panne. Écrire un code parfait ne résout pas le problème, car même un logiciel irréprochable dépend d'un ordinateur physique, de l'alimentation électrique, d'un stockage fonctionnel et d'autres composants. Si la machine perd son alimentation, le logiciel tombera en panne quelle que soit sa qualité. Pour cette raison, les ingénieurs doivent concevoir en prévision des pannes, en décidant à l'avance comment un système doit se comporter lorsque certaines de ses parties ne fonctionnent pas correctement.

Cet article examine les stratégies qui aident les développeurs à gérer les pannes de leurs systèmes. Il commence par le raisonnement qui sous-tend la mentalité « supposer que tout peut tomber en panne », qui prépare les équipes à anticiper les défaillances plutôt que de les traiter comme des exceptions rares. Il oppose ensuite l'évitement des pannes à leur tolérance, deux approches qui répondent à des objectifs différents dans la conception des systèmes.

La discussion aborde ensuite des techniques concrètes. Les développeurs doivent déterminer la portée d'une panne afin de savoir quelles parties du système sont touchées et lesquelles restent opérationnelles. Ils ont aussi besoin de moyens pour réduire l'impact d'une panne, afin qu'un problème dans un composant ne se propage pas à l'ensemble de la plateforme.

Enfin, l'article explique comment gérer les pannes pendant que le système continue de fonctionner correctement, et comment mesurer la reprise après panne. Suivre la rapidité et l'exhaustivité du rétablissement d'un système fournit aux équipes un retour concret sur l'efficacité réelle de leurs stratégies de gestion des pannes.

एक पूरी तरह विफलता-रोधी सॉफ़्टवेयर सिस्टम बनाना असंभव है। कोई सिस्टम अपने पूरे जीवनचक्र में बिना विफल हुए चल सकता है, लेकिन कोई भी यह गारंटी नहीं दे सकता कि वह कभी विफल नहीं होगा। पूर्ण कोड लिखने से भी समस्या हल नहीं होती, क्योंकि सबसे निर्दोष सॉफ़्टवेयर भी एक भौतिक कंप्यूटर, बिजली, कार्यरत स्टोरेज और अन्य घटकों पर निर्भर करता है। यदि मशीन की बिजली चली जाती है, तो सॉफ़्टवेयर की गुणवत्ता चाहे जैसी हो, वह विफल हो जाएगा। इसी कारण इंजीनियरों को विफलता के लिए डिज़ाइन करना चाहिए, यानी पहले से तय करना चाहिए कि जब सिस्टम के कुछ हिस्से सही तरह काम न करें तो सिस्टम को कैसा व्यवहार करना चाहिए।

यह लेख उन रणनीतियों को देखता है जो डेवलपर्स को अपने सिस्टम में विफलताओं से निपटने में मदद करती हैं। यह "मान लें कि सब कुछ टूट सकता है" वाली सोच के तर्क से शुरू होता है, जो टीमों को दोषों को दुर्लभ अपवाद मानने के बजाय उनकी अपेक्षा करने के लिए तैयार करती है। फिर यह दोषों से बचने और उन्हें सहन करने की तुलना करता है, जो सिस्टम डिज़ाइन में अलग-अलग उद्देश्यों की पूर्ति करते हैं।

इसके बाद चर्चा व्यावहारिक तकनीकों की ओर मुड़ती है। डेवलपर्स को विफलता का दायरा तय करना होगा ताकि वे जान सकें कि सिस्टम के कौन से हिस्से प्रभावित हैं और कौन से स्वस्थ हैं। उन्हें विफलता के प्रभाव को कम करने के तरीके भी चाहिए, ताकि एक घटक की समस्या पूरे प्लेटफ़ॉर्म में न फैले।

अंत में, लेख बताता है कि सिस्टम सही तरह चलते रहने के दौरान विफलताओं को कैसे संभाला जाए, और विफलताओं से पुनर्प्राप्ति को कैसे मापा जाए। यह ट्रैक करना कि सिस्टम कितनी तेजी और पूरी तरह से उबरता है, टीमों को इस बात पर ठोस प्रतिक्रिया देता है कि उनकी विफलता-प्रबंधन रणनीतियाँ वास्तव में काम करती हैं या नहीं।

Membangun sistem perangkat lunak yang anti-kegagalan adalah hal yang mustahil. Sebuah sistem bisa menjalani siklus hidupnya tanpa gagal, tetapi tidak ada yang bisa menjamin bahwa sistem itu tidak akan pernah gagal. Menulis kode yang sempurna tidak menyelesaikan masalah, karena perangkat lunak yang tanpa cacat sekalipun bergantung pada komputer fisik, daya listrik, penyimpanan yang berfungsi, dan komponen lainnya. Jika mesin kehilangan daya, perangkat lunak akan gagal terlepas dari kualitasnya. Karena itu, para insinyur harus merancang untuk kegagalan, dengan menentukan sejak awal bagaimana sistem harus berperilaku ketika sebagian bagiannya tidak bekerja dengan benar.

Artikel ini membahas strategi yang membantu pengembang menangani kegagalan dalam sistem mereka. Artikel ini dimulai dengan alasan di balik pola pikir "anggap semuanya bisa rusak", yang mempersiapkan tim untuk mengantisipasi gangguan, alih-alih memperlakukannya sebagai pengecualian yang jarang terjadi. Setelah itu, artikel membandingkan menghindari kesalahan dengan menoleransinya, dua pendekatan yang melayani tujuan berbeda dalam desain sistem.

Dari sana, pembahasan beralih ke teknik praktis. Pengembang perlu menentukan cakupan suatu kegagalan agar tahu bagian sistem mana yang terdampak dan mana yang tetap sehat. Mereka juga membutuhkan cara untuk mengurangi dampak kegagalan, sehingga masalah pada satu komponen tidak menyebar ke seluruh platform.

Akhirnya, artikel ini membahas cara menangani kegagalan saat sistem masih berjalan dengan benar, serta cara mengukur pemulihan dari kegagalan. Melacak seberapa cepat dan selengkap sistem pulih memberi tim umpan balik konkret tentang apakah strategi penanganan kegagalan mereka benar-benar efektif.

障害が一切起きないソフトウェアシステムを構築することは不可能です。システムはライフサイクル全体を通して障害を起こさずに動作することもありますが、決して障害が起きないと保証できる人はいません。完璧なコードを書いても問題は解決しません。欠陥のないソフトウェアであっても、物理的なコンピュータ、電源、正常に動作するストレージ、その他のコンポーネントに依存しているからです。マシンの電源が落ちれば、ソフトウェアの品質にかかわらず障害が発生します。そのため、エンジニアは障害を前提とした設計を行い、システムの一部が正しく動作しなくなったときにシステムがどう振る舞うべきかを事前に決めておく必要があります。

本記事では、開発者がシステムの障害に対処するのに役立つ戦略を取り上げます。まず、「すべてが壊れうると想定する」という考え方の根拠を説明します。この考え方により、チームは障害を稀な例外として扱うのではなく、発生を見込んで備えることができます。次に、障害を回避することと障害を許容することを比較します。これらはシステム設計において異なる目的を果たす二つのアプローチです。

そのうえで、実践的な手法に話を移します。開発者は障害の影響範囲を見極め、システムのどの部分が影響を受け、どの部分が正常に動作し続けているかを把握する必要があります。また、ある部分の障害がプラットフォーム全体に広がらないよう、障害の影響を抑える方法も必要です。

最後に、システムが正しく動作している間に障害をどう扱うか、そして障害からの復旧をどう測定するかを解説します。システムがどれだけ速く、どれだけ完全に復旧するかを追跡することで、チームは自分たちの障害対応戦略が実際に機能しているかについて具体的なフィードバックを得られます。

É impossível construir um sistema de software à prova de falhas. Um sistema pode percorrer todo o seu ciclo de vida sem falhar, mas ninguém pode garantir que nunca falhará. Escrever código perfeito não resolve o problema, pois até um software impecável depende de um computador físico, de energia elétrica, de armazenamento funcionando e de outros componentes. Se a máquina perder energia, o software falhará independentemente de sua qualidade. Por essa razão, os engenheiros precisam projetar para falhas, decidindo antecipadamente como um sistema deve se comportar quando algumas de suas partes não estiverem funcionando corretamente.

Este artigo analisa estratégias que ajudam os desenvolvedores a lidar com falhas em seus sistemas. Ele começa pelo raciocínio por trás da mentalidade de "presumir que tudo pode quebrar", que prepara as equipes para esperar falhas em vez de tratá-las como exceções raras. Em seguida, contrasta evitar falhas com tolerá-las, duas abordagens que servem a propósitos diferentes no projeto de sistemas.

A partir daí, a discussão passa a técnicas práticas. Os desenvolvedores precisam determinar o escopo de uma falha para saber quais partes do sistema são afetadas e quais permanecem saudáveis. Também precisam de formas de reduzir o impacto de uma falha, para que um problema em um componente não se espalhe por toda a plataforma.

Por fim, o artigo aborda como tratar falhas enquanto o sistema continua funcionando corretamente e como medir a recuperação após falhas. Acompanhar a rapidez e a completude com que um sistema se recupera oferece às equipes um retorno concreto sobre a eficácia de suas estratégias de tratamento de falhas.

Создать программную систему, полностью защищенную от сбоев, невозможно. Система может проработать весь свой жизненный цикл без отказов, но никто не может гарантировать, что отказов не будет никогда. Написание идеального кода не решает проблему, поскольку даже безупречное программное обеспечение зависит от физического компьютера, электропитания, исправного накопителя и других компонентов. Если машина потеряет питание, программа выйдет из строя независимо от ее качества. По этой причине инженеры должны проектировать с учетом отказов, заранее определяя, как система должна вести себя, когда некоторые ее части работают неправильно.

В этой статье рассматриваются стратегии, которые помогают разработчикам справляться со сбоями в своих системах. Она начинается с обоснования подхода «предполагать, что всё может сломаться», который готовит команды к ожиданию неисправностей, а не к рассмотрению их как редких исключений. Затем сопоставляются избегание неисправностей и их терпимость, два подхода, которые служат разным целям в проектировании систем.

Далее обсуждение переходит к практическим методам. Разработчикам необходимо определить область действия сбоя, чтобы понимать, какие части системы затронуты, а какие остаются работоспособными. Им также нужны способы уменьшить влияние сбоя, чтобы проблема в одном компоненте не распространилась на всю платформу.

Наконец, статья рассказывает о том, как обрабатывать сбои, пока система продолжает правильно работать, и как измерять восстановление после сбоев. Отслеживание того, насколько быстро и полно система восстанавливается, дает командам конкретную обратную связь о том, действительно ли работают их стратегии обработки сбоев.

构建一个永不故障的软件系统是不可能的。系统可能在整个生命周期中都不出故障，但没有人能保证它永远不会故障。编写完美的代码也无法解决这一问题，因为即使是无懈可击的软件，也依赖于物理计算机、电力、正常运行的存储以及其他组件。如果机器断电，无论软件质量多高，都会发生故障。因此，工程师必须为故障而设计，提前决定当系统的某些部分无法正常工作时，系统应如何表现。

本文探讨了帮助开发人员应对系统故障的策略。文章首先阐述“假设一切都会损坏”这一思维方式的依据，它促使团队预期故障的发生，而不是将其视为罕见的例外。随后，文章对比了避免故障与容忍故障这两种方法，二者在系统设计中服务于不同的目的。

接下来，讨论转向实用技术。开发人员需要确定故障的范围，以便了解系统的哪些部分受到影响、哪些部分仍然正常。他们还需要降低故障的影响，使一个组件的问题不会蔓延到整个平台。

最后，本文介绍了如何在系统仍正常运行时处理故障，以及如何衡量故障后的恢复情况。跟踪系统恢复的速度和完整程度，可以为团队提供具体反馈，判断其故障处理策略是否真正有效。