524,251 research outputs found
Engineering model transformations with transML
The final publication is available at Springer via http://dx.doi.org/10.1007%2Fs10270-011-0211-2Model transformation is one of the pillars of model-driven engineering (MDE). The increasing complexity of systems and modelling languages has dramatically raised the complexity and size of model transformations as well. Even though many transformation languages and tools have been proposed in the last few years, most of them are directed to the implementation phase of transformation development. In this way, even though transformations should be built using sound engineering principles—just like any other kind of software—there is currently a lack of cohesive support for the other phases of the transformation development, like requirements, analysis, design and testing. In this paper, we propose a unified family of languages to cover the life cycle of transformation development enabling the engineering of transformations. Moreover, following an MDE approach, we provide tools to partially automate the progressive refinement of models between the different phases and the generation of code for several transformation implementation languages.This work has been sponsored by the Spanish Ministry of Science and Innovation with project METEORIC (TIN2008-02081), and by the R&D program of the Community of Madrid with projects “e-Madrid" (S2009/TIC-1650). Parts of this work were done during the research stays of Esther and Juan at the University of York, with financial support from the Spanish Ministry of Science and Innovation (grant refs. JC2009-00015, PR2009-0019 and PR2008-0185)
Large-Scale Agile Transformation: A Case Study of Transforming Business, Development and Operations
Today, product development organizations are adopting agile methods in units outside the software development unit, such as in sales, market, legal, operations working with the customer. This broader adoption of agile methods has been labeled large-scale agile transformation and is considered a particular type of organizational change, originating in the software development units. So far, there is little research-based advice on conducting such transformations. Aiming to contribute towards providing relevant research advice on large-scale agile transformation, we apply a research-based framework for evaluating organizational agility on a product development program in a maritime service provider organization. We found that doing a large-scale agile transformation involves many significant challenges, such as having a shared understanding of the problem, getting access to users, and getting commitment to change that needs to be done. In order to overcome such challenges, we discuss the need for a holistic and integrated approach to agile transformation involving all the units linked to software development.publishedVersio
Support for collaborative component-based software engineering
Collaborative system composition during design has been poorly supported by traditional CASE tools (which have usually concentrated on supporting individual projects) and almost exclusively focused on static composition. Little support for maintaining large distributed collections of heterogeneous software components across a number of projects has been developed. The CoDEEDS project addresses the collaborative determination, elaboration, and evolution of design spaces that describe both static and dynamic compositions of software components from sources such as component libraries, software service directories, and reuse repositories. The GENESIS project has focussed, in the development of OSCAR, on the creation and maintenance of large software artefact repositories. The most recent extensions are explicitly addressing the provision of cross-project global views of large software collections and historical views of individual artefacts within a collection. The long-term benefits of such support can only be realised if OSCAR and CoDEEDS are widely adopted and steps to facilitate this are described.
This book continues to provide a forum, which a recent book, Software Evolution with UML and XML, started, where expert insights are presented on the subject.
In that book, initial efforts were made to link together three current phenomena: software evolution, UML, and XML. In this book, focus will be on the practical side of linking them, that is, how UML and XML and their related methods/tools can assist software evolution in practice.
Considering that nowadays software starts evolving before it is delivered, an apparent feature for software evolution is that it happens over all stages and over all aspects.
Therefore, all possible techniques should be explored. This book explores techniques based on UML/XML and a combination of them with other techniques (i.e., over all techniques from theory to tools).
Software evolution happens at all stages. Chapters in this book describe that software evolution issues present at stages of software architecturing, modeling/specifying,
assessing, coding, validating, design recovering, program understanding, and reusing.
Software evolution happens in all aspects. Chapters in this book illustrate that software evolution issues are involved in Web application, embedded system, software repository, component-based development, object model, development environment, software metrics, UML use case diagram, system model, Legacy system, safety critical system, user interface, software reuse, evolution management, and variability modeling. Software evolution needs to be facilitated with all possible techniques. Chapters in this book demonstrate techniques, such as formal methods, program transformation,
empirical study, tool development, standardisation, visualisation, to control system changes to meet organisational and business objectives in a cost-effective way. On the journey of the grand challenge posed by software evolution, the journey that we have to make, the contributory authors of this book have already made further
advances
Development of a computer algorithm for the analysis of variable-frequency AC drives: Case studies included
The development of computer software for performance prediction and analysis of voltage-fed, variable-frequency AC drives for space power applications is discussed. The AC drives discussed include the pulse width modulated inverter (PWMI), a six-step inverter and the pulse density modulated inverter (PDMI), each individually connected to a wound-rotor induction motor. Various d-q transformation models of the induction motor are incorporated for user-selection of the most applicable model for the intended purpose. Simulation results of selected AC drives correlate satisfactorily with published results. Future additions to the algorithm are indicated. These improvements should enhance the applicability of the computer program to the design and analysis of space power systems
Development of Village Administration Data E-Monography Application
Utilization and processing of basic village data by the Kedungluk Village Government, Candi District, Sidoarjo Regency, through e-monograph is an effort by the village government to carry out a transformation process to develop an information culture. This study aims to determine the development and design of an application-based information system prototype (village monograph) that provides information and potential as well as village profiles, and provides convenience for village monograph data managers and users. In addition to providing benefits to the village government through the e-monograph application prototype, this research is also expected to contribute to learning in the State Administration Study Program by presenting a learning model that can provide opportunities for students to learn directly (become a laboratory) related to the use of information technology in designing and managing public sector organizations in accordance with the learning outcomes of the fourth study program. The research method used is the Research & Development (R&D) method where one of the models suitable for this research is the SDLC (Software Development Life Cycle) model and specifically the Waterfall model which consists of six stages of software development namely requirements, design, implementation, testing, deployment and maintenance. The output of this research is software or software
Towards Practical Graph-Based Verification for an Object-Oriented Concurrency Model
To harness the power of multi-core and distributed platforms, and to make the
development of concurrent software more accessible to software engineers,
different object-oriented concurrency models such as SCOOP have been proposed.
Despite the practical importance of analysing SCOOP programs, there are
currently no general verification approaches that operate directly on program
code without additional annotations. One reason for this is the multitude of
partially conflicting semantic formalisations for SCOOP (either in theory or
by-implementation). Here, we propose a simple graph transformation system (GTS)
based run-time semantics for SCOOP that grasps the most common features of all
known semantics of the language. This run-time model is implemented in the
state-of-the-art GTS tool GROOVE, which allows us to simulate, analyse, and
verify a subset of SCOOP programs with respect to deadlocks and other
behavioural properties. Besides proposing the first approach to verify SCOOP
programs by automatic translation to GTS, we also highlight our experiences of
applying GTS (and especially GROOVE) for specifying semantics in the form of a
run-time model, which should be transferable to GTS models for other concurrent
languages and libraries.Comment: In Proceedings GaM 2015, arXiv:1504.0244
ArĂs 2.1: Adapting ArĂs for Object Oriented Language
In the software development area, software verification is important such that it can guarantee the software
fulfills its requirements. Despite its importance, verifying software is difficult to achieve. Additional
knowledge and effort are needed to write specification especially if the software is complex and big in
size. Nevertheless, there are some software that already have verified specifications. This project will
focus on extending ArĂs (Analogical Reasoning for reuse of Implementation & Specification) which has
been developed to increase verified software by reusing and transferring the specification from a similar
implementation to a target code. The extension is done to facilitate specification transferring to program
written in language other than C#, in this case Java. This extension will add functions to existing ArĂs
that will receive Conceptual Graphs representation of a program and write the specification to a file.
Another companion system is also built from Java to generate the Conceptual Graphs in Conceptual
Graph Interchange Format (CGIF) and transform the Spec# specification to JML. Finally, this new
system is evaluated by running some testing. From the result that we have, we can conclude that the
building of conceptual graph and the specification transformation is the most difficult part in our system
ArĂs 2.1: Adapting ArĂs for Object Oriented Language
In the software development area, software verification is important such that it can guarantee the software
fulfills its requirements. Despite its importance, verifying software is difficult to achieve. Additional
knowledge and effort are needed to write specification especially if the software is complex and big in
size. Nevertheless, there are some software that already have verified specifications. This project will
focus on extending ArĂs (Analogical Reasoning for reuse of Implementation & Specification) which has
been developed to increase verified software by reusing and transferring the specification from a similar
implementation to a target code. The extension is done to facilitate specification transferring to program
written in language other than C#, in this case Java. This extension will add functions to existing ArĂs
that will receive Conceptual Graphs representation of a program and write the specification to a file.
Another companion system is also built from Java to generate the Conceptual Graphs in Conceptual
Graph Interchange Format (CGIF) and transform the Spec# specification to JML. Finally, this new
system is evaluated by running some testing. From the result that we have, we can conclude that the
building of conceptual graph and the specification transformation is the most difficult part in our system
Supporting Automatic Interoperability in Model-Driven Development Processes
By analyzing the last years of software development evolution, it is possible to observe that
the involved technologies are increasingly focused on the definition of models for the
specification of the intended software products. This model-centric development schema is the
main ingredient for the Model-Driven Development (MDD) paradigm.
In general terms, the MDD approaches propose the automatic generation of software
products by means of the transformation of the defined models into the final program code.
This transformation process is also known as model compilation process. Thus, MDD is
oriented to reduce (or even eliminate) the hand-made programming, which is an error-prone and
time-consuming task. Hence, models become the main actors of the MDD processes: the
models are the new programming code.
In this context, the interoperability can be considered a natural trend for the future of
model-driven technologies, where different modeling approaches, tools, and standards can be
integrated and coordinated to reduce the implementation and learning time of MDD solutions
as well as to improve the quality of the final software products. However, there is a lack of
approaches that provide a suitable solution to support the interoperability in MDD processes.
Moreover, the proposals that define an interoperability framework for MDD processes are still
in a theoretical space and are not aligned with current standards, interoperability approaches,
and technologies.
Thus, the main objective of this doctoral thesis is to develop an approach to achieve the
interoperability in MDD processes. This interoperability approach is based on current
metamodeling standards, modeling language customization mechanisms, and model-to-model
transformation technologies. To achieve this objective, novel approaches have been defined to
improve the integration of modeling languages, to obtain a suitable interchange of modeling
information, and to perform automatic interoperability verification.Giachetti Herrera, GA. (2011). Supporting Automatic Interoperability in Model-Driven Development Processes [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/11108Palanci
- …