A systematic approach for implementing fault tolerant software designs in Ada

Litke, John D.

doi:10.1145/255471.255565

Cited by 14 publications

(9 citation statements)

References 6 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…To investigate how a more thorough method could help, we tried applying the the principles of compartmented software, initially described by Litke for designing fault-tolerant systems in Ada [9]. Litke describes the approach as follows.…”

Section: Software Compartmentsmentioning

confidence: 99%

“…As described earlier, Litke [9] proposed an approach to designing fault-tolerant systems in Ada. Similarly, de Lemos and Romanovsky have suggested a framework for integrating exception handling into the early phases of the software life-cycle [5].…”

Section: Related Workmentioning

confidence: 99%

“…To provide an example of how design methods can help, we describe an approach we have used to simplify the exception structure in existing systems (Section 4). This approach is based on a proposed method for designing fault-tolerant Ada systems [9]. We discuss the outcome of applying this approach to three different Java systems (Section 4 and 5) and analyze its costs and benefits (Section 6).…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Designing robust Java programs with exceptions

Robillard

Murphy

2000

SIGSOFT Softw. Eng. Notes

View full text Add to dashboard Cite

Exception handling mechanisms are intended to help developers build robust systems. Although an exception handling mechanism provides a basis for structuring source code dealing with unusual situations, little information is available to help guide a developer in the appropriate application of the mechanism. In our experience, this lack of guidance leads to complex exception structures. In this paper, we reflect upon our experiences using the Java exception handling mechanism. Based on these experiences, we discuss two issues we believe underlie the difficulties encountered: exceptions are a global design problem, and exception sources are often difficult to predict in advance. We then describe a design approach, based on work by Litke for Ada programs, which we have used to simplify exception structure in existing Java programs.

show abstract

Section: Software Compartmentsmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Designing robust Java programs with exceptions

Robillard

Murphy

2000

SIGSOFT Softw. Eng. Notes

View full text Add to dashboard Cite

show abstract

“…The focus is software design, namely how to regularize the exceptions that are passed between components of a software system, but intertwined in the discussion is the essential character of exceptions and their handling in Java. The technique applied is software compartmenting, first described by Litke [1990] at the TRI-Ada 1990 Conference. This technique divides software into compartments, defines precise and complete exception interfaces for each compartment, and automatically verifies the conformance of the actual program to compartment specification [Robillard and Murphy 2000].…”

mentioning

confidence: 99%

The impact of software engineering research on modern programming languages

Ryder

Soffa

Burnett

2005

ACM Trans. Softw. Eng. Methodol.

View full text Add to dashboard Cite

Software engineering research and programming language design have enjoyed a symbiotic relationship, with traceable impacts since the 1970s, when these areas were first distinguished from one another. This report documents this relationship by focusing on several major features of current programming languages: data and procedural abstraction, types, concurrency, exceptions, and visual programming mechanisms. The influences are determined by tracing references in publications in both fields, obtaining oral histories from language designers delineating influences on them, and tracking cotemporal research trends and ideas as demonstrated by workshop topics, special issue publications, and invited talks in the two fields. In some cases there is conclusive This article has been developed under the auspices of the Impact Project. The aim of the project is to provide a scholarly study of the impact that software engineering research-both academic and industrial-has had upon practice. The principal output of the project is a series of individual papers covering the impact upon practice of research in several selected major areas of software engineering. Each of these papers is being published in ACM TOSEM. Additional information about the project can be found at http://www.acm.org/sigsoft/impact/. This article is based upon work supported by the U.S. National Science Foundation (NSF) under award number CCF-0137766, the Association of Computing Machinery Special Interest Group on Software Engineering (ACM SIGSOFT), the Institution of Electrical Engineers (IEE), and the Japan Electronics and Information Technology Association (JEITA). Any opinions, findings and conclusions or recommendations, expressed in this publication are those of the authors and do not necessarily reflect, of the NSF, ACM SIGSOFT, the IEE, or JEITA. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or direct commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permissions may be requested from Publications Dept., ACM, Inc., 1515 Broadway, New York, NY 10036 USA, fax: +1 (212) 869-0481, or permissions@acm.org. data supporting influence. In other cases, there are circumstantial arguments (i.e., cotemporal ideas) that indicate influence. Using this approach, this study provides evidence of the impact of software engineering research on modern programming language design and documents the close relationship between these two fields.

show abstract

“…Finally, in the exception handling literature there are also a few e↵orts to support developers in properly designing exception handling of software systems. Litke (LITKE, 1999) proposed a method to design fault tolerant Ada systems. Litke's method proposes exhaustive specification of exceptions at modules boundaries by enumerating and defining the semantics of all exceptions that cross these boundaries.…”

Section: Related Workmentioning

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

A systematic approach for implementing fault tolerant software designs in Ada

Cited by 14 publications

References 6 publications

Designing robust Java programs with exceptions

Designing robust Java programs with exceptions

The impact of software engineering research on modern programming languages

Global-Aware Recommendations for Repairing Exception Handling Violations

Contact Info

Product

Resources

About