scholarly journals A Model Driven Approach to Upgrade Package-Based Software Systems

2010 ◽  
pp. 262-276 ◽  
Author(s):  
Antonio Cicchetti ◽  
Davide Di Ruscio ◽  
Patrizio Pelliccione ◽  
Alfonso Pierantonio ◽  
Stefano Zacchiroli
Keyword(s):  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

Pair Modeling

2010 ◽  
pp. 1171-1178 ◽  
Author(s):  
Pankaj Kamthan
Keyword(s):  
Software Development ◽  
Software Process ◽  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

We model software for a variety of reasons: to assess the viability of or plan software systems to be built, to optimize use of (minimize, or ideally, avoid waste of) resources in response to inevitable changes in business, social, or technological environments, or simply to understand existing software systems. Indeed, as indicated by the model-driven approach to software development (Beydeda, Book, & Gruhn, 2005), models are becoming first-class members of organizations and software process environments that embrace them. The examples of collaboration in implementation of software are well-known (Nosek, 1998; Williams & Kessler, 2003). As models get large and complex, the need for creating them collaboratively in a systematic manner arises, and we propose pair modeling as an approach.

A model-driven approach for the generation of configurations for highly available software systems

2018 ◽  
Vol 14 (4) ◽  
pp. 273-307 ◽  
Author(s):  
Pejman Salehi ◽  
Abdelwahab Hamou-Lhadj ◽  
Maria Toeroe ◽  
Ferhat Khendek
Keyword(s):  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

Reducing the Complexity of Modeling Large Software Systems

2009 ◽  
pp. 3399-3429
Author(s):  
Jules White ◽  
Douglas C. Schmidt ◽  
Andrey Nechypurenko ◽  
Egon Wuchner
Keyword(s):  
Constraint Satisfaction ◽  
Constraint Satisfaction Problems ◽  
Correct Solution ◽  
Software Systems ◽  
Domain Expert ◽  
Modeling Tool ◽  
Constraint Solver ◽  
Model Driven ◽  
Model Driven Approach ◽  
Domain Constraints

Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows designers to use domain notations to specify solutions and domain constraints to ensure that the proposed solutions meet the required objectives. Many domains, however, require models that are either so large or intricately constrained that it is extremely difficult to manually specify a correct solution. This chapter presents an approach to provide that leverages a constraint solver to provide modeling guidance to a domain expert. The chapter presents both a practical framework for transforming models into constraint satisfaction problems and shows how the Command Pattern can be used to integrate a constraint solver into a modeling tool.

scholarly journals Towards a model-driven approach for multiexperience AI-based user interfaces

2021 ◽  
Author(s):  
Elena Planas ◽  
Gwendal Daniel ◽  
Marco Brambilla ◽  
Jordi Cabot
Keyword(s):  
User Interface ◽  
Language Processing ◽  
User Interfaces ◽  
The Other ◽  
Software Systems ◽  
Model Driven ◽  
Software Applications ◽  
Domain Specific ◽  
Faster Development ◽  
Model Driven Approach

AbstractSoftware systems start to include other types of interfaces beyond the “traditional” Graphical-User Interfaces (GUIs). In particular, Conversational User Interfaces (CUIs) such as chat and voice are becoming more and more popular. These new types of interfaces embed smart natural language processing components to understand user requests and respond to them. To provide an integrated user experience all the user interfaces in the system should be aware of each other and be able to collaborate. This is what is known as a multiexperience User Interface. Despite their many benefits, multiexperience UIs are challenging to build. So far CUIs are created as standalone components using a platform-dependent set of libraries and technologies. This raises significant integration, evolution and maintenance issues. This paper explores the application of model-driven techniques to the development of software applications embedding a multiexperience User Interface. We will discuss how raising the abstraction level at which these interfaces are defined enables a faster development and a better deployment and integration of each interface with the rest of the software system and the other interfaces with whom it may need to collaborate. In particular, we propose a new Domain Specific Language (DSL) for specifying several types of CUIs and show how this DSL can be part of an integrated modeling environment able to describe the interactions between the modeled CUIs and the other models of the system (including the models of the GUI). We will use the standard Interaction Flow Modeling Language (IFML) as an example “host” language.

Reducing the Complexity of Modeling Large Software Systems

2009 ◽  
pp. 372-400
Author(s):  
Jules White ◽  
Douglas C. Schmidt ◽  
Andrey Nechypurenko ◽  
Egon Wuchner
Keyword(s):  
Constraint Satisfaction ◽  
Constraint Satisfaction Problems ◽  
Correct Solution ◽  
Software Systems ◽  
Domain Expert ◽  
Modeling Tool ◽  
Constraint Solver ◽  
Model Driven ◽  
Model Driven Approach ◽  
Domain Constraints

Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows designers to use domain notations to specify solutions and domain constraints to ensure that the proposed solutions meet the required objectives. Many domains, however, require models that are either so large or intricately constrained that it is extremely difficult to manually specify a correct solution. This chapter presents an approach to provide that leverages a constraint solver to provide modeling guidance to a domain expert. The chapter presents both a practical framework for transforming models into constraint satisfaction problems and shows how the Command Pattern can be used to integrate a constraint solver into a modeling tool.

Aspect Oriented Re-engineering of Legacy Software Using Cross-Cutting Concern Characterization and Significant Code Smells Detection

2016 ◽  
Vol 26 (03) ◽  
pp. 513-536
Author(s):  
Mohsin Shaikh ◽  
Chan-Gun Lee
Keyword(s):  
Source Code ◽  
Object Oriented Programming ◽  
Software Systems ◽  
Aspect Mining ◽  
Legacy Software ◽  
Model Driven ◽  
Current State ◽  
Analysis Technique ◽  
Explicit Analysis ◽  
Model Driven Approach

Although object-oriented programming (OOP) methodologies immensely promote reusable and well-factored decomposition of complex source code, legacy software systems often show symptoms of deteriorating design over time due to lack of maintenance. Software systems may have different business and application contexts, but most of these systems require similar maintenance mechanism of understanding, analysis and transformation. As a consequence, intensive re-engineering efforts based on the model driven approach can be effective ensuring that best practices are followed during maintenance and eventually reducing the development cost. In this paper, we suggest detailed framework of re-engineering which includes: (i) rigorous and automated source code analysis technique for identification, characterization and prioritization of most prominent and threatening design flaws in legacy software, (ii) migration of existing the code to aspect-oriented programming (AOP) code by exploiting current state of art for aspect mining mechanism and incorporating behavioral knowledge of cross-cutting concerns. To exemplify how the approach works a case study has been conducted to experimentally validate the idea and analyze the effect of process on specific software quality spectrum. An explicit analysis of prevalent work on the subject and their critical reviews are also presented to further enhance the recognition of proposed re-engineering framework.

Sign in / Sign up

Export Citation Format

Share Document