Exception Handling: A Field Study in Java and .NET

Cabral, Bruno; Marques, Paulo

doi:10.1007/978-3-540-73589-2_8

Cited by 74 publications

(115 citation statements)

References 7 publications

Supporting

Mentioning

102

Contrasting

Unclassified

Order By: Relevance

“…This kind of solution makes it difficult to track the specific exception type when an exception is caught, since all exceptions are caught as Exception, and one has to parse their message to identify the type. Such a solution was also found in the work of Cabral and Marques (2007), and therefore it is difficult to provide a distinct solution for each exception. Hence, this solution may fit into the second level of assimilation in our SOLO-based taxonomy.…”

Section: S4: Java Exceptionmentioning

confidence: 93%

“…Exception handling may result in either the termination of the program or in a corrective action being performed. In order to correct a problem using the try-catch block, it should be located inside a loop which will increase the complexity of the code (Cabral & Marques, 2007). Robillard and Murphy (2000) stated that a lack of knowledge regarding the design and implementation of exceptions can lead to complex and spaghetti-like exception handling codes.…”

Section: Difficulties In Applying Exception Handlingmentioning

confidence: 99%

See 1 more Smart Citation

Students’ Strategies for Exception Handling

Rashkovits

Lavy

2011

JITE:Research

View full text Add to dashboard Cite

Executive SummaryThis study discusses and presents various strategies employed by novice programmers concerning exception handling. The main contributions of this paper are as follows: we provide an analysis tool to measure the level of assimilation of exception handling mechanism; we present and analyse strategies to handle exceptions; we present and analyse solutions provided by novice programmers; we classify and analyse the participants' reflections concerning their solutions. Modern programming languages, such as Java, provide the programmer an elaborated object oriented exception mechanism; enable him to handle exceptions in a more convenient way. The aim of this study was to discover the strategies novice programmers are using to handle exceptions and whether they utilise the advantage of the modern exception handling mechanism. For that matter the participants (college students) had to provide a written solution to a given problem with a special focus on exception handling. In addition each of them was interviewed. The analysis of the solutions provided was carried out according to a set of software quality criteria (clarity, modularity and extensibility) adapted to exception handling characteristics. These criteria were used to explain the advantages and disadvantages of the solutions from a software engineering perspective. The solutions provided were also analysed according to a classification of levels of assimilation concerning the structure of exceptions, based on the SOLO taxonomy. The first level of assimilation refers to solutions in which no exception mechanism was used, and the errors were handled in the old fashion way (local handling or return of an error code). The fifth and last level refers to solutions that used adequate hierarchy of exception classes allowing easy extension according to future requirements and enabling the handling of multiple exception altogether or handle each separately. In between these levels there are strategies that used exception mechanisms without the exhausting of its advantages. The results obtained reveal that only few participants (7 out of 56) provided a solution that was classified to one of the two highest assimilation levels, while many (23 out of 56) did not use exception mechanism at all. The rest of the students (25 out of 56) used the exception mechanism poorly (i.e., used only Exception class or did not use hierarchy of exceptions). The participants had difficulties in utilising the advanced exception handling mechanisms and in exhibiting a high level of abstraction with regard to the proper design of a hierarchy of exceptions. The students' statements collected during the interviews were classified into the following categories: misconceptions concerning code quality; misconceptions concerning exception handling; difficulties in understanding the exception handling mechanism; the perceived importance of exception handling; and a lack of programming experience. During the interviews the students provided explanations concerning the reasons they wer...

show abstract

Section: S4: Java Exceptionmentioning

confidence: 93%

Section: Difficulties In Applying Exception Handlingmentioning

confidence: 99%

Students’ Strategies for Exception Handling

Rashkovits

Lavy

2011

JITE:Research

View full text Add to dashboard Cite

show abstract

“…According to an analysis performed over a sample of 100 open source projects called SF100 [8] 1 , we discovered that almost one third of the methods have at least one EDP [7]. Although the number of EDPs of a program is high, and exception handling is an important topic in software development [4], the influence of exception mechanisms to unit test data generation using symbolic execution has not been widely explored [1,3,5].Taking into account the implicit constraints that stem from exception handling mechanisms can significantly increase the number of path constraints. This has the potential to exacerbate a well-known issue faced by symbolic execution approaches: path explosion [1,5,6], which is usually caused by complex loop structures.…”

mentioning

confidence: 99%

Analyzing Exceptions in the Context of Test Data Generation Based on Symbolic Execution

Eler

Durelli

Endo

2015

International Conferences on Software Engineering and Knowledge Engineering

View full text Add to dashboard Cite

Abstract-Testing exception scenarios is a challenging task in the context of test data generation based on symbolic execution. In such a context, test data is generated based on constraints explicitly declared in the code. However, constraints required to activate specific exceptions may not be directly declared in the code. In such a case, implicit constraints have to be inferred from exception handling mechanisms. Given that exceptions can be raised in several situations, finding constraints to generate test data to exercise all possible faulty scenarios can significantly increase the number of paths and constraints, which can cause or aggravate path explosion issues. This paper reports on an investigation that we carried out to gauge the cost (i.e., number of path constraints) of four data generation approaches aimed at covering exception dependent paths.Keywords -Exception handling; symbolic execution; test data generation; software analysisAutomatic test data generation is a notorious complex problem. Symbolic execution and constraint solving have been used as an approach to generate test data that achieve high control-flow coverage [5,9]. During symbolic execution, program elements are represented as functions of symbolic input values [5,9]. Each path is represented by a path constraint, which is a sequence of constraints that should be satisfied so that the underlying path can be traversed. Constraint solvers are thus used to generate concrete input values (i.e., test data) that satisfy each set of constraints.Often, the constraints required to traverse a path are explicitly declared in the code by means of control-flow statements, such as if and while. However, some constraints are not explicitly declared in the code because they do not stem from conventional control-flow statements. Some of these constraints implicitly derive from exception handling mechanisms such as Java's try-catch-finally blocks. For instance, a block that declares a NullPointerException will be executed only when such an exception is thrown. However, in general, there are no constraint indicating in which condition such an exception will be thrown.We classify paths that depend on an exception being thrown as exception-dependent paths (EDPs) [7], as oppose to exception-free paths (EFPs) [14]. According to an analysis performed over a sample of 100 open source projects called SF100 [8] 1 , we discovered that almost one third of the methods have at least one EDP [7]. Although the number of EDPs of a program is high, and exception handling is an important topic in software development [4], the influence of exception mechanisms to unit test data generation using symbolic execution has not been widely explored [1,3,5].Taking into account the implicit constraints that stem from exception handling mechanisms can significantly increase the number of path constraints. This has the potential to exacerbate a well-known issue faced by symbolic execution approaches: path explosion [1,5,6], which is usually caused by complex loop structures.The c...

show abstract

“…Cabral and Marques (CABRAL and MARQUES, 2007) performed a study in the context of 16 di↵erent programs implemented in Java and of 16 di↵erent programs implemented in the .NET platform. These programs were divided into four groups: "Servers", "Libraries", "Stand-alone applications" and "Server-apps".…”

Section: Exception Handling Implementationmentioning

confidence: 99%

“…For the Java programs, the authors also observed in the four groups of programs that 95% of the handlers were in these categories. Table 2.1 summarizes the distribution of handlers in these categories, as reported by Cabral and Marques (CABRAL and MARQUES, 2007). Other handlers analyzed in this study were categorized as: "Assert", "Close", "Continue", "Rollback" and "Others".…”

Section: Exception Handling Implementationmentioning

confidence: 99%

Global-Aware Recommendations for Repairing Exception Handling Violations

BARBOSA¹

View full text Add to dashboard Cite

Exception handling is the most common way of dealing with exceptions in robust software development. Exception handling refers to the process of signaling exceptions upon the detection of runtime errors and taking actions to respond to their occurrence. Despite being aimed at improving software robustness, software systems are still implemented without relying on explicit exception handling policies. Each policy defines the design decisions governing how exception handling should be implemented in a system. These policies are often not documented and are only implicitly defined in the system design. Thus, developers tend to introduce in the source code violations of implicit policies and these violations commonly cause failures in software systems. In this context, the goal of this thesis is to support developers in detecting and repairing exception handling violations. To achieve this goal, two complementary solutions were proposed. The first solution is based on a domain-specific language supporting the detection of violations by explicitly defining exception handling policies to be enforced in the source code. The proposed language was evaluated with a user-centric study and a case study. With the observations and experiences gathered in the user-centric study, we identified some language characteristics that hindered its use and that motivated new language constructs. In addition, the results of the case study showed that violations and faults in exception handling share common causes. Therefore, violations can be used to detect potential causes of exceptionrelated failures. To complement the detection of exception handling violations, this work also proposed a solution for supporting the repair of exception handling violations. Repairing these violations requires reasoning about the global impact that exception handling changes might have in di↵erent parts of the system. Thus, this work proposed a recommender heuristic strategy that takes into account the global context of where violations occur to produce recommendations. Each recommendation produced consists of a sequence of modifications that serves as a detailed blueprint of how an exception handling violation can be removed from the source code. The proposed recommender strategy also takes advantage of explicit policy specifications, although their availability is not mandatory. The results of our empirical assessments revealed that the proposed recommender strategy produced recommendations able to Tratamento de exceçõesé o modo mais comum de lidar com erros no desenvolvimento de software robusto. Tratamento de exceções refere-se ao processo de sinalizar exceções quando erros em tempo de execução são detectados e de tomar ações para responderà ocorrência destas exceções. Apesar de objetivarem a melhoria da robustez de software, sistemas de software ainda são implementados sem se basear em uma política explícita para tratamento de exceções. Cada política define as decisões de projeto que governam como tratamento de exceções deve ser implementado num sis...

show abstract

Exception Handling: A Field Study in Java and .NET

Cited by 74 publications

References 7 publications

Students’ Strategies for Exception Handling

Students’ Strategies for Exception Handling

Analyzing Exceptions in the Context of Test Data Generation Based on Symbolic Execution

Global-Aware Recommendations for Repairing Exception Handling Violations

Contact Info

Product

Resources

About