Programming Best Practices
Exception Handling Designing Robust Software
Edit
#exception-handling
#ruby-on-rails
#error-handling
#software-design
#programming-best-practices
Summarized using AI

Exception Handling Designing Robust Software

Wen Tien Chang • January 30, 2019 • Earth

In the video 'Exception Handling: Designing Robust Software,' Wen Tien Chang discusses the importance and techniques of exception handling in software design, focusing specifically on Ruby programming. The presentation is structured as follows:

  • Introduction to Exception Handling: Chang emphasizes that exception handling is essential for creating robust software, noting that most developers often neglect it, leading to increased operational costs and software failures.

  • Why Care About Exception Handling: The speaker argues that robust software can greatly reduce future operational expenses and improve customer satisfaction. He cites experiences where failure to handle exceptions appropriately led to increased costs and lost revenue.

  • Exception Handling in Ruby: Chang details the syntax and functionality of exception handling in Ruby, explaining concepts such as the 'raise' method for signaling exceptions, and the 'rescue' method for handling them. He highlights important Ruby quirks, such as differences in conventional usage of fail and raise, and emphasizes the hierarchy of exception classes to aid in proper handling.

  • Common Pitfalls: The speaker discusses common mistakes in exception handling, such as rescuing all exceptions indiscriminately, which can hide programming errors. He stresses the need for specific exception handling to avoid masking errors.

  • Strategies for Effective Exception Handling: Chang outlines various strategies, including:

    • Recovery mechanisms: Techniques to recover gracefully from errors, ensuring that the system remains operational.
    • Circuit breaker patterns: A method to prevent failures from cascading through systems.
    • Exception classification: Differentiating between operational and programmer errors to choose appropriate responses.
    • Incremental improvement: The idea that exception handling can be improved over time rather than needing a perfect solution from the start.

  • Conclusion and Key Takeaways: The speaker concludes that well-designed exception handling plays a critical role in software quality. He encourages developers to view exceptions not just as errors but as opportunities to enhance the robustness of their applications in a cost-effective manner.

Wen Tien Chang's talk provides valuable insights into the importance of careful exception handling in Ruby, helping developers make informed decisions to create reliable and maintainable software architectures.

Exception Handling Designing Robust Software
Wen Tien Chang • January 30, 2019 • Earth

Rails Pacific 2014

00:00:13.130 Hello everyone! Today, I'm going to talk about exception handling. It's about how to design robust software. I know most of you are probably expecting me to dive right in, but I must admit that I don’t often practice my English outside of conferences.
00:00:22.580 My name is Wen Tien Chang, and I hope you'll enjoy this talk. Here’s my blog and Twitter account, where you can follow my updates. I currently work for Avec M, a professional school for software developers, particularly those who specialize in Ruby on Rails. I've been using Ruby on Rails since version 1.1.6, which was released way back in 2006.
00:00:40.040 Now, let’s move on to today's agenda. I will first discuss why we should care about exception handling. Then, we will quickly learn how to handle exceptions in a graphical user interface (GUI) framework. After that, we will look at sound concepts in the command line, and finally, we will explore some vital strategies for handling exceptions.
00:01:08.750 Before I dive into my talk, I want to thank two great books that have influenced my understanding of exception handling. The first book is a Chinese publication by Teddy Chen, which covers exception handling in great detail. Although some of the examples are flawed, I learned a lot of concepts from his writing.
00:01:32.060 The second book is 'Exceptional Ruby' by Avdi Grimm. I learned many Ruby tricks from this book. Besides writing this book, Avdi also gives talks at various Ruby conferences, and I highly recommend reading both of these books if you want to deepen your knowledge after my talk.
00:02:03.799 Now, let’s discuss why we should care about exception handling. Ask yourself: is the feature in your software that's susceptible to failure essential? We all know that failure can happen, but we must expect that our applications will run in unstable environments. We must be ready to handle those failures gracefully.
00:02:30.440 There’s a misconception that robust software can run without any hiccups. However, the reality is often very different. Many times we ignore the critical aspects of software quality because we want to meet deadlines, which can lead to significant long-term costs.
00:03:10.910 Software quality, including how we handle exceptions, is crucial. We often focus on high-level architecture and design patterns, thinking they will help us save development costs. However, my experience with production software has shown me that development costs do not equal operational costs. As Michael Feathers said, 'Don’t avoid one-time development expenses at the cost of recurring operational expenses.'
00:03:49.880 Decisions made during the development phase greatly affect the quality of software after release. In the past, I made decisions based only on development costs, neglecting operational costs. This led to unhappy customers and significant financial losses for my company, which was a wake-up call for me.
00:04:40.940 This is why I began to focus more on exception handling and the implications of poor handling strategies. If your goal is to reduce development costs without considering the cost of handling failures, then I hope my talk offers you some new insights.
00:05:05.450 Now, let’s start learning what an exception is in Ruby. Steve Klabnik explained that raising an exception is like signaling that something has gone wrong. It's essentially saying, 'I don't know how to handle this.'
00:05:10.880 David explained more straightforwardly that raising an exception halts the normal execution of a program and alerts the user to the error, which may involve exiting the program entirely. Modern programming languages, including Java, C#, and Python, have robust exception handling built-in, and Ruby is no exception.
00:05:53.110 In Ruby, the syntax for exception handling is relatively simple. The raised exceptions disrupt the normal flow, which is a critical aspect of the Ruby language. One thing you might not know is the distinction between 'fail' and 'raise.' 'Fail' is commonly used in error handling conventions.
00:06:05.330 The method of raising an exception can accept various arguments. If you omit all arguments, it behaves as if you called it with a standard error. If you provide a string, it becomes the error message. If you provide an exception class, Ruby will create a new instance of that exception. The last argument is usually the backtrace, which is critical for debugging.
00:07:10.900 Looking at the rescue method, this is where we define how to handle a raised exception. The 'rescue' keyword is followed by the exception class. A rescue block can include multiple rescue clauses, allowing flexibility in dealing with various types of exceptions.
00:07:36.380 It is important to note that not being specific about which exceptions to rescue could lead to unintended behavior by capturing too broad a scope of errors, such as typos. This could make debugging much harder. Ruby encourages you to be specific in which exceptions you want to rescue.
00:08:23.919 Rails also uses its own methods for rescuing exceptions. For instance, it includes methods to ignore specific exception types during handling. This allows a developer to control which exceptions to mitigate effectively.
00:09:05.310 As a rule of thumb, you should always try to handle exceptions as close to where they occur as possible, while maintaining the integrity and clarity of your code.
00:09:37.529 Now, let’s wrap up what we learned regarding exception handling strategies. First, we should be cautious and approach exception handling systematically. Errors should be reported effectively so that we can process and manage them properly.
00:10:18.220 We also discussed the 'ensure' keyword, which is useful for making sure that certain code runs no matter what happens — whether an exception gets raised or not. This can be particularly helpful for resource management.
00:11:03.220 Furthermore, the 'retry' keyword allows looping back on the block of code, but with great care, as careless use can create infinite loops.
00:11:37.290 Now, let’s dive deeper into the philosophy of exception handling. It’s essential to understand what types of exceptions we are facing: are they programmer errors or operational errors? This distinction will drastically alter how we approach error handling.
00:12:07.500 Operational errors usually signal issues that are beyond your control — like network failures, downtime, or unavailable resources. Programmer errors stem from code errors and what we build into our systems.
00:12:56.180 Given this knowledge, we can see how defining the scope of our error handling can lead to better software. It's also vital to consider how much information we need to expose when something goes wrong.
00:13:49.370 Another critical factor is defining the granularity of error recovery. For example, can the application restore state without user intervention? Errors and recovery must be managed in ways that users remain informed without overwhelming them with details.
00:14:36.240 In programming, it's important to catch errors early and allow the program to either recover or fail gracefully. This flexibility is what leads to robust software.
00:15:08.710 As we explore exception handling further, consider how these discussions tie back to your projects. Using exceptions inappropriately or without thought can lead to a cycle of debugging without resolution.
00:15:50.400 In a nutshell, effectively addressing exceptions is pivotal for building reliable software—the guiding principle being to catch the right exceptions with clarity.
00:16:01.040 Our discussion surrounding robust error handling also emphasizes having a solid understanding of what can go wrong and how it should be addressed, acknowledging that error handling is as crucial as the application design itself.
00:16:46.020 As we draw to a close, remember to maintain a balance in your approach. Embrace simplicity in your handling logic and avoid over-complicating your solutions.
00:17:19.090 The key points we covered today highlight the importance of strategic exception handling, focusing on minimizing the complexity and maximizing the clarity of your code.
00:18:16.510 Moreover, remember to build your applications with the expectation that errors will occur. As developers, it is our responsibility to foresee potential issues and design our systems accordingly.
00:18:35.070 I encourage all of you to take these principles back to your projects, fostering better understanding and improvements around how we handle exceptions, leading to more robust and reliable software.
00:19:22.230 Thank you all for your attention! I hope you found this talk insightful.
Wen Tien Chang
@ihower
Explore all talks recorded at Rails Pacific 2014
+2