  Modern programming languages, such as Java and C#, typically provide features
that handle exceptions. These features separate error-handling code from
regular source code and aim to assist in the practice of software comprehension
and maintenance. Having acknowledged the advantages of exception handling
features, their misuse can still cause reliability degradation or even
catastrophic software failures. Prior studies on exception handling aim to
understand the practices of exception handling in its different components,
such as the origin of the exceptions and the handling code of the exceptions.
Yet, the observed findings were scattered and diverse. In this paper, to
complement prior research findings on exception handling, we study its features
by enriching the knowledge of handling code with a flow analysis of exceptions.
Our case study is conducted with over 10K exception handling blocks, and over
77K related exception flows from 16 open-source Java and C# (.NET) libraries
and applications. Our case study results show that each try block has up to 12
possible potentially recoverable yet propagated exceptions. More importantly,
22% of the distinct possible exceptions can be traced back to multiple methods
(average of 1.39 and max of 34). Such results highlight the additional
challenge of composing quality exception handling code. To make it worse, we
confirm that there is a lack of documentation of the possible exceptions and
their sources. However, such critical information can be identified by
exception flow analysis on well- documented API calls (e.g., JRE and .NET
documentation). Finally, we observe different strategies in exception handling
code between Java and C#. Our findings highlight the opportunities of
leveraging automated software analysis to assist in exception handling
practices and signify the need of more further in-depth studies on exception
handling practice.
