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.

Tool Based Integration of Requirements Modeling and Validation into Business Process Modeling

2014 ◽  
pp. 285-309
Author(s):  
Sven Feja ◽  
Sören Witt ◽  
Andreas Speck
Keyword(s):  
Business Process ◽  
Process Modeling ◽  
Process Models ◽  
Software Systems ◽  
Functional Requirements ◽  
Model Driven ◽  
Level Of Abstraction ◽  
Textual Representations ◽  
Model Driven Software Development ◽  
The One

Business process models (BPM) are widely used for specification of software systems, as the basis for model driven software development. Hence, it is crucial to ensure that these BPMs fulfill the requirements they have to comply with. These requirements may originate from various domains. Many may be considered non-functional requirements. They are affecting privacy, security, as well as compliance or economic aspects. In order to avoid error-prone manual checking, automated checking techniques should be applied wherever possible. This requires expressing requirements in a formal manner. The common textual representations for such formal requirements are not well accepted in the modeling domain, since they are settled on a lower level of abstraction, compared to BPMs. In this chapter, the authors present the Business Application Modeler (BAM), which integrates formal requirement specification and automated checking with process modeling. On the one hand BAM supports different notations for process modeling. On the other hand a graphical notation, called G-CTL, for the formal specification of requirements is provided. G-CTL is based on temporal logic, and statements are expressed on the level of abstraction of the graphical process models. Furthermore BAM provides the ability to define selective views on process models. This allows complex domain specific annotations of processes as well as the assignment of responsibilities regarding functional domains. Moreover, BAM integrates into common requirements engineering processes.

Tool Based Integration of Requirements Modeling and Validation into Business Process Modeling

2012 ◽  
pp. 512-536
Author(s):  
Sven Feja ◽  
Sören Witt ◽  
Andreas Speck
Keyword(s):  
Business Process ◽  
Process Modeling ◽  
Process Models ◽  
Software Systems ◽  
Functional Requirements ◽  
Model Driven ◽  
Level Of Abstraction ◽  
Textual Representations ◽  
Model Driven Software Development ◽  
The One

Business process models (BPM) are widely used for specification of software systems, as the basis for model driven software development. Hence, it is crucial to ensure that these BPMs fulfill the requirements they have to comply with. These requirements may originate from various domains. Many may be considered non-functional requirements. They are affecting privacy, security, as well as compliance or economic aspects. In order to avoid error-prone manual checking, automated checking techniques should be applied wherever possible. This requires expressing requirements in a formal manner. The common textual representations for such formal requirements are not well accepted in the modeling domain, since they are settled on a lower level of abstraction, compared to BPMs. In this chapter, the authors present the Business Application Modeler (BAM), which integrates formal requirement specification and automated checking with process modeling. On the one hand BAM supports different notations for process modeling. On the other hand a graphical notation, called G-CTL, for the formal specification of requirements is provided. G-CTL is based on temporal logic, and statements are expressed on the level of abstraction of the graphical process models. Furthermore BAM provides the ability to define selective views on process models. This allows complex domain specific annotations of processes as well as the assignment of responsibilities regarding functional domains. Moreover, BAM integrates into common requirements engineering processes.

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.

Requirements Engineering for Integrating the Enterprise

2011 ◽  
pp. 92-104
Author(s):  
Raghvinder S. Sangwan
Keyword(s):  
Requirements Engineering ◽  
Health Care Providers ◽  
Global Economy ◽  
Software Systems ◽  
Care Providers ◽  
Strategic Partnerships ◽  
Health Networks ◽  
Model Driven ◽  
The Right

In an era of global economy, an enterprise must demonstrate agility in order to stay competitive. Agility requires continuous monitoring of the ever-changing business landscape and quick adaptation to that change. Often times, this means businesses must merge to form strategic partnerships allowing them to provide new products and services. Such partnerships create the need for critical information to flow seamlessly across the newly formed enterprise and be available on demand for effective collaboration and decision making. However, the legacy business information systems that each partner brings into the newly formed enterprise typically have a very narrow focus serving the needs of a single business unit within an enterprise. As such, it becomes necessary to integrate multiple different systems before the right information can be delivered to the right person at the right time. Integrating disparate systems from a technical perspective is not hard to achieve since the Webservices standard is fairly mature and provides an open infrastructure for software systems to interoperate. One must, however, first understand the need and level of cooperation and collaboration among the different segments of an enterprise, its suppliers, and its customers in order for this integration to be effective. This chapter motivates the need for model-driven requirements engineering for enterprise integration, reviews the research to date on model-driven requirements engineering, and examines a case study on integrating health-care providers to form integrated health networks to gain insight into challenges and issues.

scholarly journals Detecting Source Code Plagiarism on .NET Programming Languages using Low-level Representation and Adaptive Local Alignment

2017 ◽  
Vol 41 (1) ◽  
pp. 105-123 ◽  
Author(s):  
Faqih Salban Rabbani ◽  
Oscar Karnalim
Keyword(s):  
Programming Languages ◽  
State Of The Art ◽  
Source Code ◽  
Point Of View ◽  
Local Alignment ◽  
Plagiarism Detection ◽  
Low Level ◽  
Intermediate Language ◽  
Token Sequence

Even though there are various source code plagiarism detection approaches, only a few works which are focused on low-level representation for deducting similarity. Most of them are only focused on lexical token sequence extracted from source code. In our point of view, low-level representation is more beneficial than lexical token since its form is more compact than the source code itself. It only considers semantic-preserving instructions and ignores many source code delimiter tokens. This paper proposes a source code plagiarism detection which rely on low-level representation. For a case study, we focus our work on .NET programming languages with Common Intermediate Language as its low-level representation. In addition, we also incorporate Adaptive Local Alignment for detecting similarity. According to Lim et al, this algorithm outperforms code similarity state-of-the-art algorithm (i.e. Greedy String Tiling) in term of effectiveness. According to our evaluation which involves various plagiarism attacks, our approach is more effective and efficient when compared with standard lexical-token approach. 

scholarly journals A UML 2.0 Activity Diagrams/CSP Integrated Approach for Modeling and Verification of Software Systems

2021 ◽  
Vol 22 (2) ◽  
Author(s):  
Raida Elmansouri ◽  
Said Meghzili ◽  
Allaoua Chaoui
Keyword(s):  
Model Transformation ◽  
Integrated Approach ◽  
Software Systems ◽  
Sequential Process ◽  
Model Checker ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Activity Diagrams ◽  
Uml 2.0

This paper proposes an approach integrating UML 2.0 Activity Diagrams (UML2-AD) and Communicating Sequential Process (CSP) for modeling and verication of software systems. A UML2-AD is used for modeling a software system while CSP is used for verication purposes. The proposed approach consists of another way of transforming UML2-AD models to Communicating Sequential Process (CSP) models. It focuses also on checking the correctness of some properties of the transformation itself. These properties are specified using Linear Temporal Logic (LTL) and verified using the GROOVE model checker. This approach is based on Model Driven Engineering (MDE). The meta-modelling is realized using AToMPM tool while the model transformation and the correctness of its properties are realized using GROOVE tool. Finally, we illustrated this approach through a case study.

scholarly journals Sukuk Issuance in Malaysia: Lessons for Pakistan

2018 ◽  
Vol 4 (2) ◽  
pp. 159-176 ◽  
Author(s):  
Sumaira Ghafoor ◽  
Irum Saba ◽  
Rehana Kouser
Keyword(s):  
Islamic Finance ◽  
Underlying Structure ◽  
Short Term ◽  
Liquidity Management ◽  
Management Framework ◽  
Low Level ◽  
Finance Industry ◽  
Trading Market ◽  
Increasing Trend

Pakistan need to enhance the liquidity management framework for its growing Islamic finance industry. Sukuk is a best Shariah-compliant debt instrument for short term liquidity needs since Sukuk is highly tradable instrument with low level of market risk. In view of that, there is an increasing trend in the global issuances of corporate and sovereign Sukuk. Therefore, this case study aims to explore the issuance of Sukuk in Malaysia as an example. Malaysia is dominating the Sukuk Market and has been issuing Sukuk since 1990. The underlying structure of the proposed Sukuk model for Pakistan is Istisna that is an Islamic project bond. Pakistan has the potential to replicate the Sukuk model of Malaysia. However, it is required to have an active secondary trading market in order to develop an effective and dynamic Sukuk market.

SUMMING UP THE PARTS

2010 ◽  
pp. 231-235
Author(s):  
Liliana María Favre
Keyword(s):  
Reverse Engineering ◽  
Programming Languages ◽  
Information Integration ◽  
Software Evolution ◽  
Engineering Industry ◽  
Software Systems ◽  
Model Driven ◽  
Architectural Framework ◽  
Integration Problem ◽  
Definition Of

This chapter summarizes the main results described in this book and challenges and strategic directions in MDA reverse engineering. Reverse engineering is the process of analyzing software systems to extract software artifacts at a higher level of abstraction. Nowadays, software and system engineering industry evolves to manage new platform technologies, design techniques and processes. Architectural framework for information integration and tool interoperation, such as MDA, had created the need to develop new analysis tools and specific techniques. MDA is not itself a technology specification but it represents an evolving plan to achieve cohesive model-driven technology specifications. The original inspiration around the definition of MDA had to do with the middleware integration problem in internet. Beyond interoperability reasons, there are other good benefits to use MDA such as to improve the productivity, process quality and maintenance costs. The outstanding ideas behind MDA are separating the specification of the system functionality from its implementation on specific platforms, managing the software evolution from abstract models to implementations increasing the degree of automation and achieving interoperability with multiple platforms, programming languages and formal languages.

Sign in / Sign up

Export Citation Format

Share Document