Validation of Exception Handling in the Development of Dependable Component-Based Software Systems

2011 ◽  
Author(s):  
Jeferson Ferreira ◽  
Eliane Martins ◽  
Cecilia M. F. Rubira ◽  
Patrick H. da Silva Brito
Keyword(s):  
Exception Handling ◽  
Software Systems

The Architecture Framework with Exception Handing in SOA

2010 ◽  
Vol 20-23 ◽  
pp. 992-997 ◽  
Author(s):  
Qing Wu ◽  
Shi Ying ◽  
You Cong Ni ◽  
Hua Cui
Keyword(s):  
Exception Handling ◽  
Software Systems ◽  
Separation Of Concerns ◽  
Clear Separation ◽  
Reliable Service ◽  
Architecture Framework ◽  
Service Oriented ◽  
Business Function ◽  
Oriented System

Service-oriented software systems are inherently complex and have to cope with an increasing number of exceptional conditions in order to meet the system’s dynamic requirements. This work proposes an architecture framework which has exception handling capability. This framework ensures the credibility of service-oriented software, during the architectural stage, by adding exception handling-related architecture elements and modeling exception handling process. It allows a clear separation of concerns between the business function and the exception handling unit, using reflection mechanism. It plays an important guiding role for achieving reliable service-oriented system.

SPECIFICATION OF MULTIMEDIA SOFTWARE SYSTEMS USING AN OBJECT ORIENTED ARCHITECTURE DESCRIPTION LANGUAGE

1999 ◽  
Vol 09 (06) ◽  
pp. 767-800
Author(s):  
KUANG XU ◽  
JEFFREY J. P. TSAI
Keyword(s):  
Object Oriented ◽  
Exception Handling ◽  
Multimedia System ◽  
Software Systems ◽  
Multimedia Software ◽  
Description Language ◽  
Architecture Description Language ◽  
Object Oriented Design ◽  
Architecture Description ◽  
Architecture Specification

Despite the growing importance of multimedia applications, we still know relatively little about how to specify, design, and maintain this class of complex applications in a systematic manner. The concept of software architecture has recently emerged as a way to improve our ability to effectively construct and maintain large-scale complex software systems. Under this new paradigm, software engineers are able to do evolutionary design of complex systems through architecture specification, design rationale capture, architecture validation and verification, and architecture transformation. Several architecture description languages (ADLs), such as Wright, Rapide, UniCon, ACME, etc. have been proposed to support the architecture development under this new software paradigm. Although current ADLs more or less support certain features of object-oriented design approach, few of them are purely based on object-oriented paradigm. In this paper, we present an architecture description language — OOADL (Object-Oriented Architecture Description Language) to facilitate the architecture specification of multimedia software systems. This language takes object-oriented paradigm as its backbone, and provides formal semantics for modeling architectures of software systems. It also aims at other goals such as, support for hierarchical refinement, support for reuse of architecture styles, support for analysis, and support for exception handling. We also introduce the default architecture style which brings the features of extensibility and re-usability into the language. Finally, we use OOADL to construct part of the architecture framework of a multimedia system to illustrate the usage and modeling capability of OOADL.

scholarly journals Extending programming language to support object orientation in legacy systems

2013 ◽  
Vol 10 (4) ◽  
pp. 1661-1672
Author(s):  
Hemang Mehta ◽  
S.J. Balaji ◽  
Dharanipragada Janakiram
Keyword(s):  
Programming Language ◽  
Object Orientation ◽  
Exception Handling ◽  
Target System ◽  
Software Systems ◽  
Legacy Systems ◽  
Performance Study ◽  
Tight Coupling ◽  
Runtime Support

The contemporary software systems written in C face maintainability issues because of tight coupling. Introducing object orientation can address these problems by raising the abstraction to objects, thereby providing better programmability and understandability. However, compiling a C software with a C++ compiler is difficult because of the incompatibilities between C and C++. Some of the incompatibilities such as designated initializers are nontrivial in nature and hence are very difficult to handle by automation such as scripting or by manual efforts. Moreover, runtime support for features such as global constructors, exception handling, runtime type inference, etc. is also required in the target system. Clearly, the traditional procedural language compiler cannot provide these features. In this paper, we propose extending programming language such as C++ to support object orientation in legacy systems instead of completely redesigning them. With a case study of Linux kernel, we report major issues in providing the compile and runtime support for C++ in legacy systems, and provide a solution to these issues. Our approach paves the way for converting a large C based software into C++. The experiments demonstrate that the proposed extension saves significant manual efforts with very little change in the g++ compiler. In addition, the performance study considers other legacy systems written in C and shows that the overhead resulting from the modifications in the compiler is negligible in comparison to the functionality achieved.

Model-Driven Exception Management Case Study

2010 ◽  
pp. 153-173
Author(s):  
Susan Entwisle ◽  
Sita Ramakrishnan ◽  
Elizabeth Kendall
Keyword(s):  
Programming Languages ◽  
Fault Tolerant ◽  
Exception Handling ◽  
Software Systems ◽  
Management Framework ◽  
Low Level ◽  
Model Driven ◽  
Level Of Abstraction ◽  
Management Case Study

Programming languages provide exception handling mechanisms to structure fault tolerant activities within software systems. However, the use of exceptions at this low level of abstraction can be errorprone and complex, potentially leading to new programming errors. To address this we have developed a model-driven exception management framework (DOVE). This approach is a key enabler to support global distributed solution delivery teams. The focus of this paper is the evaluation of the feasibility of this approach through a case study, known as Project Tracker. The case study is used to demonstrate the feasibility and to perform an assessment based on quality and productivity metrics and testing of the DOVE framework. The results of the case study are presented to demonstrate the feasibility of our approach.

A TOOL TO AUTOMATICALLY MAP IMPLEMENTATION-BASED TESTING TECHNIQUES TO CLASSES

2006 ◽  
Vol 16 (04) ◽  
pp. 585-614 ◽  
Author(s):  
PETER J. CLARKE ◽  
JUNHUA DING ◽  
DJURADJ BABICH ◽  
BRIAN A. MALLOY
Keyword(s):  
Large Scale ◽  
Object Oriented ◽  
Exception Handling ◽  
Software Systems ◽  
Test Coverage ◽  
Analysis And Design ◽  
Class A ◽  
Testing Techniques

The object-oriented (OO) paradigm provides several benefits during analysis and design of large-scale software systems, but scores lower in terms of testability. The low testability score for OO software is due mainly to the composition of OO systems exhibiting the characteristics of abstraction, encapsulation, genericity, inheritance, polymorphism, concurrency and exception handling. To address the difficulty of testing the features of a class, a plethora of implementation-based testing techniques (IBTTs) have been developed. However, no one IBTT has emerged as the preferred technique to test the implementation of a class. In this paper we present a technique that automatically identify those IBTTs that are most suitable for testing a class based on the characteristics of that class. Our approach uses a taxonomy of OO classes that is used to succinctly abstract the characteristics of a class under test (CUT). We have implemented a tool that automates the process of mapping IBTTs to a class. In addition to identifying the IBTTs that would be best suited for testing a class, our tool provides feedback to the tester facilitating the identification of the characteristics of the class that are not suitably tested by any of the IBTTs in the list. We provide results of a study supporting the notion that using more than on IBTT during testing improves test coverage of a CUT.

Methods of parallel computing for multilevel fuzzy Takagi – Sugeno systems

2016 ◽  
pp. 141-149
Author(s):  
S.V. Yershov ◽  
◽  
R.М. Ponomarenko ◽  
Keyword(s):  
Dynamic Models ◽  
Fuzzy Inference ◽  
Knowledge Bases ◽  
Comparative Characteristic ◽  
Software Systems ◽  
Scientific Papers ◽  
Speed Up ◽  
Diagnostic Software ◽  
Takagi Sugeno

Parallel tiered and dynamic models of the fuzzy inference in expert-diagnostic software systems are considered, which knowledge bases are based on fuzzy rules. Tiered parallel and dynamic fuzzy inference procedures are developed that allow speed up of computations in the software system for evaluating the quality of scientific papers. Evaluations of the effectiveness of parallel tiered and dynamic schemes of computations are constructed with complex dependency graph between blocks of fuzzy Takagi – Sugeno rules. Comparative characteristic of the efficacy of parallel-stacked and dynamic models is carried out.

Sign in / Sign up

Export Citation Format

Share Document