Model-Driven Exception Management Case Study

Model-Driven Exception Management Case Study

Susan Entwisle (Monash University, Australia), Sita Ramakrishnan (Monash University, Australia) and Elizabeth Kendall (Melbourne Institute of Technology, Australia)
DOI: 10.4018/978-1-60566-731-7.ch012
OnDemand PDF Download:
No Current Special Offers


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.
Chapter Preview


Rapid advances in information technology and consumer demand have motivated the development of increasingly rich, complex software systems. Within these software systems, exceptions are inevitable and increasing due to the diverse range of potential points of deviations and errors, including hardware, software, and human error (Garcia, F.Rubira, Romanovsky, & Xu, 2001; Patterson et al., 2002). Modern programming languages, including Java (Arnold, Gosling, & Homes, 2000) and C# (Williams, 2002), provide exception handling mechanisms to systematically handle errors within these software system to meet reliability requirements (Alexander Romanovsky, 2003; Perry, Romanovsky, & Tripathi, 2000). However, while exception handling can improve the design of an application, the use of exception handling is labor intensive, error prone, provides limited support for communication, and is inflexible (Howell & Vecellio, 2000; Klein & Dellarocas, 2000; Reimer & Srinivasan, 2003).

Much of the exception handling research to date has concentrated on addressing the objectives of exception handling as a language design issue (Garcia et al., 2001), or providing the software developer with exception usage design patterns and software frameworks (Anderson, Feng, Riddle, & Romanovsky, 2003; Garcia & Rubira, 2000; Reimer & Srinivasan, 2003). However, despite the advantages, experience has shown that progress in understandability and reusability within most problem domains other than limited vertical frameworks and class libraries, (such as user interface, databases, virtual machines, etc), has failed to meet expectation (Eisenecker & Czarnecki, 2000; Greenfield, Short, Cook, & Kent, 2004).

This finding extends beyond just exception handling, to a wider range of software development. (Coplien, 1998; Eisenecker & Czarnecki, 2000; Greenfield et al., 2004; Mellor, Scott, Uhl, & Weise, 2004) argue that significant advances in reuse and the management of complexity can be potentially achieved by transitioning to system families. These families are represented using higher level abstractions of the problem domain, represented as models, in order to meet problem domain requirements. Model transformation facilitates the automatic construction of highly customized intermediate or end applications based on high-level problem domain models. These models are configured to leverage elementary, reusable domain-specific assets rather than programming languages (Eisenecker & Czarnecki, 2000; Greenfield et al., 2004; Mellor et al., 2004). The model-driven approach is a key enabler to support global application delivery teams to design and deliver projects using geographically distributed teams. This approach allows the architect that is co-located with the customer to design the system using high-level models. These models can then be provided to the application development team to automatically construct the application.

Key Terms in this Chapter

Model-Driven Development: Model-driven development paradigm is an evolutionary shift in software development. It aims to facilitate the automatic construction of highly customised intermediate or end software products based on high-level problem domain models. These models are configured to leverage elementary, reusable domain-specific assets rather than programming languages.

Feature Model: The features of the software system are captured within a feature model. While the specific notation of the feature model varies based on the domain engineering methods, a feature model typically consists of four main elements. They are: feature diagram, feature definitions, composition rules, and the rationale for including the feature.

Feature Modelling: Feature modelling is a domain analysis technique that is used to define the software product-line and system families. Features are used to identify and organise the commonalities and variabilities within a domain, and to model the functional and non-functional properties.

RELIANT Domain Engineering Method: The RELIANT Domain Engineering Method provides a tailorable framework that guides the domain engineer in the design and development activities from initial conception to implementation and deployment of reusable modules for a range of exception domains. The process consists of guidance, common patterns for exceptions, and other assets to support the design of domain-specific modules for different classes of exceptions.

Feature Set: Feature set is the set of features within a specific domain. A feature set defines the features and their attributes (such as type, cardinality, etc), including constraints that must be enforced amongst features.

Exception Management: Exception management features within an application are based on its exception handling strategies, policies and requirements. Exception management features aim to support a consistent approach to managing software failures. Exception management includes the detection, diagnosis and resolution of software failures.

DOVE Framework: DOVE framework provides the modelling languages, core services and tools that enable an application engineer to model concurrent exceptions and sequential exceptions that aid in the detection, diagnosis, and resolution of software failures. The application engineer specifies the exception management capabilities in feature and software models that guide the automated generation of implementation assets that can be re-configured, as required, to detect, diagnose and resolve software failures.

Domain Engineering: Domain Engineering consists of three core phases: Domain Analysis, Domain Design and Domain Implementation. Domain analysis is the activity of gathering and analysing experiences in building systems or parts of a system within a specific domain in the form of reusable assets. Domain design and domain implementation focus of designing and implementing reusable domain-specific languages, components, and code generators to support model-driven development, respectively. Domain Engineering is also referred to as System Family Engineering.

Complete Chapter List

Search this Book: