Trading robustness for maintainability: an empirical study of evolving c# programs

@article{Cacho2014TradingRF,
  title={Trading robustness for maintainability: an empirical study of evolving c\# programs},
  author={Nelio Alessandro Azevedo Cacho and Thiago C{\'e}sar and Thomas Filipe and Eliezio Soares and Arthur Cassio and Rafael Souza and Israel Garc{\'i}a and Eiji Adachi Barbosa and Alessandro F. Garcia},
  journal={Proceedings of the 36th International Conference on Software Engineering},
  year={2014}
}
Mainstream programming languages provide built-in exception handling mechanisms to support robust and maintainable implementation of exception handling in software systems. Most of these modern languages, such as C#, Ruby, Python and many others, are often claimed to have more appropriated exception handling mechanisms. They reduce programming constraints on exception handling to favor agile changes in the source code. These languages provide what we call maintenance-driven exception handling… 

Figures and Tables from this paper

How Does Exception Handling Behavior Evolve? An Exploratory Study in Java and C# Applications
TLDR
An empirical study aimed at understanding the relationship between changes in Java and C# programs and their robustness and evaluated how changes in the normal and exceptional code were related to exception handling faults.
Revisiting Exception Handling Practices with Exception Flow Analysis
  • G. B. D. Pádua, Weiyi Shang
  • Computer Science
    2017 IEEE 17th International Working Conference on Source Code Analysis and Manipulation (SCAM)
  • 2017
TLDR
This 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, and shows that there is a lack of documentation of the possible exceptions and their sources.
Studying the Relationship between Exception Handling Practices and Post-Release Defects
  • G. B. D. Pádua, Weiyi Shang
  • Computer Science
    2018 IEEE/ACM 15th International Conference on Mining Software Repositories (MSR)
  • 2018
TLDR
It is found that exception flow characteristics in Java projects have a significant relationship with post- release defects, and development teams should consider allocating more resources to improving their exception handling practices and avoid the anti-patterns that are found to have a relationship withPost-release defects.
The use of C++ exception handling constructs: A comprehensive study
TLDR
Results of an empirical study that use a mixed-method approach to investigate the adoption of the exception handing mechanism in C++ reveal that, for several projects, the use of exception handling constructs is scarce and developers favor theUse of other strategies to deal with exceptional conditions.
Categorizing Faults in Exception Handling: A Study of Open Source Projects
TLDR
This paper presents a categorization of the causes of exceptional faults observed in two mainstream open source projects, most of which were never reported before in the literature.
Contrasting exception handling code across languages: An experience report involving 50 open source projects
TLDR
The analysis confirms the existing belief that developers often pay little attention to developing exception scoping and handling behaviour and suggests that certain exception handling mechanisms are less explored by programmers using certain programming languages.
How Swift Developers Handle Errors
TLDR
It is indicated that there is ample opportunity to improve the way Swift developers use error handling mechanisms, and some recommendations derived in this work are not well spread in the corpus of studied Swift projects.
Studying the evolution of exception handling anti-patterns in a long-lived large-scale project
TLDR
It is suggested that the absence of an explicit exception handling policy impacts negatively in the developers’ perception and implementation of exception handling, leading developers to replicate existing anti-patterns and spread them through new features added during system evolution.
Enforcing Exception Handling Policies with a Domain-Specific Language
TLDR
Exception Handling Policies Language is presented, a domain-specific language to specify and verify exception handling policies and some language characteristics that hindered its use and that motivated new language constructs are identified.
Preventing Erosion in Exception Handling Design Using Static-Architecture Conformance Checking
TLDR
The ArCatch is proposed: an architectural conformance checking solution to deal with the exception handling design erosion and proves useful and effective in the identification of existing exception handling erosion problems and locating its causes in the source code.
...
1
2
3
4
...

References

SHOWING 1-10 OF 55 REFERENCES
Assessing the Impact of Aspects on Exception Flows: An Exploratory Study
TLDR
The findings show that exception handling code in AO systems is error-prone, since all versions analyzed presented an increase in the number of uncaughtexceptions and exceptions caught by the wrong handler.
Exception Handling Defects: An Empirical Study
TLDR
An exploratory study to determine whether using exception handling is relatively risky by analyzing the defect densities of exception handling code and the overall source code found that the density of defects that are closely related to exception handling constructs is relatively high compared to the overall defect density.
Improving robustness of evolving exceptional behaviour in executable models
TLDR
The proposed exception handling model extends the aspect-oriented language constructs and the control-flow analysis of the Motorola WEAVR with the aim of promoting enhanced robustness and program modularization.
EJFlow: taming exceptional control flows in aspect-oriented programming
TLDR
This paper presents an innovative aspect-oriented model for exception handling implementation that provides abstractions to explicitly describe global views of exceptional control flows and leverages existing pointcut languages to make the association of handlers with normal code more flexible.
Exception Handling: A Field Study in Java and .NET
TLDR
To the knowledge, this is the most comprehensive study done on exception handling to date, providing a quantitative measure useful for guiding the development of new error handling mechanisms.
Eliminating Exception Handling Errors with Dependability Cases: A Comparative, Empirical Study
Programs fail mainly for two reasons: logic errors in the code and exception failures. Exception failures can account for up to two-thirds of system crashes, hence, are worthy of serious attention.
Static analysis to support the evolution of exception structure in object-oriented systems
TLDR
This article presents a model that encapsulates the minimal concepts necessary for a developer to determine exception flow for object-oriented languages that define exceptions as objects, and describes Jex, a static analysis tool developed to provide exception-flow information for Java systems based on this model.
Exceptional situations and program reliability
TLDR
A programming language feature is proposed, the compensation stack, that keeps track of obligations at run time and ensures that they are discharged and a type system for compensation stacks that tracks collections of obligations is presented.
Extracting Error Handling to Aspects: A Cookbook
TLDR
This paper proposes a classification for error handling code based on the factors that are found out have more influence on its aspectization and presents a scenario catalog comprising combinations of these factors and analyzes how these scenarios positively or negatively affect the task of aspectizing exception handling.
...
1
2
3
4
5
...