Domain model-driven software reengineering and maintenance

1993 ◽  
Vol 20 (1) ◽  
pp. 37-51 ◽  
Author(s):  
Stan Jarzabek
Keyword(s):  
Domain Model ◽  
Software Reengineering ◽  
Model Driven

A Unified Software Reengineering Approach towards Model Driven Architecture Environment

2011 ◽  
pp. 55-100
Author(s):  
Bing Qiao ◽  
Hongji Yang ◽  
Alan O’Callaghan
Keyword(s):  
Control Flow ◽  
Point Of View ◽  
Software System ◽  
Model Driven Architecture ◽  
Unified Framework ◽  
Software Reengineering ◽  
Model Driven ◽  
Incremental Development ◽  
Flow Graphs ◽  
And Control

When developing a software system, there are a number of principles, paradigms, and tools available to choose from. For a specific platform or programming language, a standard way can usually be found to archive the ultimate system; for example, a combination of an incremental development process, object-oriented analysis and design, and a well supported CASE (Computer-Aided Software Engineering) tool. Regardless of the technology to be adopted, the final outcome of the software development is always a working software system. However, when it comes to software reengineering, there is rather less consensus on either approaches or outcomes. Shall we use black-box or white-box reverse engineering for program understanding? Shall we produce data and control flow graphs, or some kind of formal specifications as the output of analysis? Each of these techniques has its pros and cons of tackling various software reengineering problems, and none of them on its own suffices to a whole reengineering project. A proper integration of various techniques capable of solving a specific issue could be an effective way to unravel a complicated software system. This kind of integration has to be done from an architectural point of view. One of the most exciting outcomes of recent efforts on software architecture is the Object Management Group’s (OMG) Model-Driven Architecture (MDA). MDA provides a unified framework for developing middleware-based modern distributed systems, and also a definite goal for software reengineering. This chapter presents a unified software reengineering methodology based on Model-Driven Architecture, which consists of a framework, a process, and related techniques.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 1280-1312 ◽  
Author(s):  
Gan Deng ◽  
Jeff Gray ◽  
Douglas C. Schmidt ◽  
Yuehua Lin ◽  
Aniruddha Gokhale ◽  
...  
Keyword(s):  
Model Transformation ◽  
Software Product Line ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

This chapter describes our approach to modeldriven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify model-tomodel transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 102-132 ◽  
Author(s):  
Gan Deng ◽  
Douglas C. Schmidt ◽  
Aniruddha Gokhale ◽  
Jeff Gray ◽  
Yuehua Lin ◽  
...  
Keyword(s):  
Model Transformation ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify modelto- model transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Analyses of Evolving Legacy Software into Secure Service-Oriented Software using Scrum and a Visual Model

2013 ◽  
pp. 196-217
Author(s):  
Sam Chung ◽  
Conrado Crompton ◽  
Yan Bai ◽  
Barbara Endicott-Popovsky ◽  
Seung-Ho Baeg ◽  
...  
Keyword(s):  
Web Services ◽  
Web Application ◽  
Software Reengineering ◽  
Software Application ◽  
Legacy Software ◽  
Web Technologies ◽  
Model Driven ◽  
Service Oriented ◽  
Modernization Process ◽  
Restful Web Services

This chapter explores using service-oriented computing to reengineer non-secure legacy software applications to create new secure target applications. Two objectives of this chapter are: (1) to analyze the architectural changes required in order to adopt new web technologies and cope with resultant vulnerabilities in source code; and (2) to measure the level of effort required to modernize software by adopting new web technologies and adding security countermeasures. To meet these objectives, a model-driven Scrum for Service-Oriented Software Reengineering (mScrum4SOSR) methodology was chosen and applied to a reengineering project. Scrum is employed to manage the reengineering project, as well as to measure implementation effort related to the modernization process. Further, a re-documentation technique called 5W1H Re-Doc is used to re-document the non-secure software application at a high level of abstraction in order to help project participants comprehend what is needed to identify candidate services for service-oriented reengineering. Case studies with and without security features are created for different types of applications - a desktop graphical user interface, a web application, a web services application, a restful web services application, and an enterprise service bus application.

scholarly journals Cyber Resilience Meta-Modelling: The Railway Communication Case Study

Electronics ◽  
2021 ◽  
Vol 10 (5) ◽  
pp. 583
Author(s):  
Emanuele Bellini ◽  
Stefano Marrone ◽  
Fiammetta Marulli
Keyword(s):  
Communication Networks ◽  
Cyber Security ◽  
Critical Infrastructure ◽  
Modern Society ◽  
Physical World ◽  
Domain Model ◽  
Model Driven ◽  
Essential Services ◽  
Cascade Effects ◽  
High Level

Recent times have demonstrated how much the modern critical infrastructures (e.g., energy, essential services, people and goods transportation) depend from the global communication networks. However, in the current Cyber-Physical World convergence, sophisticated attacks to the cyber layer can provoke severe damages to both physical structures and the operations of infrastructure affecting not only its functionality and safety, but also triggering cascade effects in other systems because of the tight interdependence of the systems that characterises the modern society. Hence, critical infrastructure must integrate the current cyber-security approach based on risk avoidance with a broader perspective provided by the emerging cyber-resilience paradigm. Cyber resilience is aimed as a way absorb the consequences of these attacks and to recover the functionality quickly and safely through adaptation. Several high-level frameworks and conceptualisations have been proposed but a formal definition capable of translating cyber resilience into an operational tool for decision makers considering all aspects of such a multifaceted concept is still missing. To this end, the present paper aims at providing an operational formalisation for cyber resilience starting from the Cyber Resilience Ontology presented in a previous work using model-driven principles. A domain model is defined to cope with the different aspects and “resilience-assurance” processes that it can be valid in various application domains. In this respect, an application case based on critical transportation communications systems, namely the railway communication system, is provided to prove the feasibility of the proposed approach and to identify future improvements.

A Context-Aware MDA Approach for Content Personalization in User Interface Development

2014 ◽  
pp. 88-105
Author(s):  
Firas Bacha ◽  
Káthia Marçal de Oliveira ◽  
Mourad Abed
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Smart Phone ◽  
Domain Model ◽  
Context Aware ◽  
Context Model ◽  
Interface Elements ◽  
Model Driven ◽  
Software Applications ◽  
The Right

User Interface (UI) personalization aims at providing the right information, at the right time, and on the right support (tablets, smart-phone, etc.). Personalization can be performed on the interface elements’ presentation (e.g. layout, screen size, and resolution) and on the content provided (e.g., data, information, document). While many existing approaches deal with the first type of personalization, this chapter explores content personalization. To that end, the authors define a context-aware Model Driven Architecture (MDA) approach where the UI model is enriched by data from a domain model and its mapping to a context model. They conclude that this approach is better used only for domains where one envisions several developments of software applications and/or user interfaces.

Foundations for MDA Case Tools

2011 ◽  
pp. 1566-1573 ◽  
Author(s):  
Liliana María Favre ◽  
Claudia Teresa Pereira ◽  
Liliana Inés Martinez
Keyword(s):  
Unified Modeling Language ◽  
Specific Model ◽  
Domain Model ◽  
Model Transformations ◽  
Software Systems ◽  
Object Constraint Language ◽  
Data Types ◽  
Model Driven ◽  
View Transformation ◽  
Independent Model

The model driven architecture (MDA) is an initiative proposed by the object management group (OMG), which is emerging as a technical framework to improve productivity, portability, interoperability, and maintenance (MDA, 2003). MDA promotes the use of models and model-to-model transformations for developing software systems. All artifacts, such as requirement specifications, architecture descriptions, design descriptions, and code are regarded as models. MDA distinguishes four main kinds of models: computation independent model (CIM), platform independent model (PIM), platform specific models (PSM), and implementation specific model (ISM). A CIM describes a system from the computation independent viewpoint that focuses on the environment of and the requirements for the system. In general, it is called domain model. A PIM is a model that contains no reference to the platforms that are used to realize it. A PSM describes a system with full knowledge of the final implementation platform. In this context, a platform is “a set of subsystems and technologies that provide a coherent set of functionality which any application supported by that platform can use without concern for the details of how the functionality is implemented” (MDA, 2003, p. 2-3). PIMs and PSMs are expressed using the unified modeling language (UML) combined with the object constraint language (OCL) (Favre, 2003; OCL, 2004; UML, 2004). The idea behind MDA is to manage the evolution from CIMs to PIMs and PSMs that can be used to generate executable components and applications. In MDA is crucial to define, manage, and maintain traces and relationships between different models and automatically transform them and produce code that is complete and executable. Metamodeling has become an essential technique in model-centric software development. The metamodeling framework for the UML itself is based on architecture with four layers: meta-metamodel, metamodel, model, and user objects. A metamodel is an explicit model of the constructs and rules needed to build specific models, its instances. A meta-metamodel defines a language to write metamodels. OCL can be used to attach consistency rules to models and metamodels. Related OMG standard metamodels and metametamodels such as meta object facility (MOF), software process engineering metamodel (SPEM) and common warehouse model (CWM) share a common design philosophy (CWM, 2001; MOF, 2005; SPEM, 2005). MOF defines a common way for capturing all the diversity of modeling standards and interchange constructs. MOF uses an object modeling framework that is essentially a subset of the UML core. The four main modeling concepts are “classes, which model MOF metaobjects; associations, which model binary relationships between metaobjects; data types, which model other data; and packages, which modularize the models” (MOF, 2005, p. 2-6). The query, view, transformation (QVT) standard depends on MOF and OCL for specifying queries, views, and transformations. A query selects specific elements of a model, a view is a model derived from other model, and a model transformation is a specification of a mechanism to convert the elements of a model, into elements of another model, which can be instances of the same or different metamodels (QVT, 2003).

Developing User Interfaces for Community-Oriented Workflow Information Systems

2010 ◽  
pp. 308-330
Author(s):  
Josefina Guerrero Garcia ◽  
Jean Vanderdonckt ◽  
Juan Manuel Gonzalez Calleros
Keyword(s):  
Information Systems ◽  
Support Groups ◽  
User Interfaces ◽  
Domain Model ◽  
Automated Generation ◽  
Model Driven ◽  
Ubiquitous Access ◽  
Computing Platforms ◽  
New Generation ◽  
The Web

Technology to support groups is rapidly growing in use. In recent years, the Web has become a privileged platform for implementing community-oriented workflows, giving rise to a new generation of workflow information systems. Specifically, the Web provides ubiquitous access to information, supports explicit distribution of business process across workers, workplaces, and computing platforms. These processes could be all supported by platform-independent user interfaces. This chapter presents a model-driven engineering method that provides designers with methodological guidance on how to systematically derive user interfaces of workflow information systems from a series of models. For this purpose, the workflow is recursively decomposed into processes which are in turn decomposed into tasks. Each task gives rise to a task model whose structure, ordering, and connection with the domain model allows the automated generation of corresponding user interfaces in a transformational approach. The various models involved in the method can be edited in a workflow editor based on Petri nets and simulated interactively.

Sign in / Sign up

Export Citation Format

Share Document