{"id":20685,"date":"2023-02-07T02:17:03","date_gmt":"2023-02-07T02:17:03","guid":{"rendered":"https:\/\/www.booksofall.com\/cn\/?post_type=product&p=20685"},"modified":"2023-02-07T02:17:04","modified_gmt":"2023-02-07T02:17:04","slug":"stuff-goes-bad-erlang-in-anger","status":"publish","type":"product","link":"https:\/\/www.booksofall.com\/cn\/stuff-goes-bad-erlang-in-anger\/","title":{"rendered":"Stuff Goes Bad: Erlang in Anger"},"content":{"rendered":"

There\u2019s something rather unique in Erlang<\/a> in how it approaches failure compared to most other programming languages<\/a>. There\u2019s this common way of thinking where the language, programming environment, and methodology do everything possible to prevent errors. Something going wrong at run-time is something that needs to be prevented, and if it cannot be prevented, then it\u2019s out of scope for whatever solution people have been thinking about.<\/p>\n

The program is written once, and after that, it\u2019s off to production, whatever may happen there. If there are errors, new versions will need to be shipped.<\/p>\n

Erlang, on the other hand, takes the approach that failures will happen no matter what, whether they\u2019re developer-, operator-, or hardware-related. It is rarely practical or even possible to get rid of all errors in a program or a system. If you can deal with some errors rather than preventing them at all cost, then most undefined behaviours of a program can go in that “deal with it” approach. This is where the “Let it Crash” idea comes from: Because you can now deal with failure, and because the cost of weeding out all of the complex bugs from a system before it hits production is often prohibitive, programmers should only deal with the errors they know how to handle, and leave the rest for another process (a supervisor) or the virtual machine to deal with.<\/p>\n

Given that most bugs are transient, simply restarting processes back to a state known to be stable when encountering an error can be a surprisingly good strategy.<\/p>\n

Erlang is a programming environment<\/a> where the approach taken is equivalent to the human body\u2019s immune system, whereas most other languages only care about hygiene to make sure no germ enters the body. Both forms appear extremely important to me. Almost every environment offers varying degrees of hygiene. Nearly no other environment offers the immune system where errors at run time can be dealt with and seen as survivable.<\/p>\n

Because the system doesn\u2019t collapse the first time something bad touches it, Erlang\/OTP<\/a> also allows you to be a doctor. You can go in the system, pry it open right there in production, carefully observe everything inside as it runs, and even try to fix it interactively. To continue with the analogy, Erlang allows you to perform extensive tests to diagnose the problem and various degrees of surgery (even very invasive surgery<\/a>), without the patients needing to sit down or interrupt their daily activities.<\/p>\n

This book intends to be a little guide about how to be the Erlang medic in a time of war. It is first and foremost a collection of tips and tricks to help understand where failures come from, and a dictionary of different code snippets and practices that helped developers debug production systems that were built in Erlang.<\/p>\n","protected":false},"excerpt":{"rendered":"