PhD Candidate, Queen's University
Studies show software developers spend around 50% of their time on debugging applications. Improving software debugging techniques not only facilitates the development of high-quality software, but it can also have a considerable economic impact. There is enormous space for research and economic achievement in this area, and even a little improvement can result in significant financial success.
Also, debugging issues are a primary obstacle in the adaptation of the Model-driven Development (MDD) approach, which is one of the most promising approaches to increase the productivity of software development. Ideally, debuggers for (MDD) tools would allow users to ‘stay on the model level’ and would not require them to refer to the generated source code or figure out how the code generator works.
Existing approaches to model-level debugging do not satisfy this requirement and are unnecessarily complex and platform dependent. We introduce a novel approach to model-level debugging that formulates debugging services at model-level And implements them using model transformation. Our prototype, called MDebugger, implements this approach using Papyrus-RT, an open source MDD tool for the modeling language UML-RT.
References:  https://github.com/moji1/MDebugger
Abstract: Abstract The widespread usage of various types of computer devices with different platform characteristics created a need for new methods and tools to support the development of context-aware applications capable of dynamically adapting themselves to context changes. In this paper, we present a new model-based approach that addresses the development of context-aware applications from both the theoretical and practical perspectives and that supports all development phases of context-aware systems. On the one hand, we describe how our approach is applied to dynamically capture, observe the change of the context and notify the system at runtime. On the other hand, we show how our approach is used by programmers to develop a context- aware application.AbstractThe widespread usage of various types of computer devices with different platform characteristics created a need for new methods and tools to support the development of context-aware applications capable of dynamically adapting themselves to context changes. In this paper, we present a new model-based approach that addresses the development of context-aware applications from both the theoretical and practical perspectives and that supports all development phases of context-aware systems. On the one hand, we describe how our approach is applied to dynamically capture, observe the change of the context and notify the system at runtime. On the other hand, we show how our approach is used by programmers to develop a context- aware application.
Pub.: 13 Oct '16, Pinned: 27 Jun '17
Abstract: A solution providing for the dynamic design, use, and modification of models using a declarative software application meta-model that provides for self-modification of a collection of the models is provided. The solution can enable continuous real-time testing, simulation, deployment, and modification of the collection of the models. A model in the collection of the models can represent an entity or a function and can be included in a set of related models. Additionally, a set of related models can include a plurality of sets of related models. The collection of the models can represent, for example, one or more software applications, processes, and/or the like.
Pub.: 01 Nov '16, Pinned: 27 Jun '17
Abstract: Publication date: December 2016 Source:Journal of Systems and Software, Volume 122 Author(s): Tomas Skersys, Paulius Danenas, Rimantas Butleris In the context of model-driven development, model-to-model (M2M) transformations are often positioned as one of the key selling features of this ever-growing paradigm. Indeed, M2M transformations can speed up the development process by automating certain modeling tasks, enable reusability of existing models within a single or even multiple projects, and bring other actual benefits to a systems developer. Nevertheless, CASE tool-supported M2M transformations are quite often represented as hard-coded “black-box” solutions lacking flexibility and customization features. This paper presents main conceptual and implementation aspects of a practical approach for both the development and application of model-based, customizable M2M transformations. The transformation is triggered by so called drag-and-drop action, which is enacted after a certain element is dragged from a model browser and dropped into a diagram or onto some other element representation in the diagram. Another distinctive feature of the presented approach is the introduction of “partial M2M transformation”. The term assumes a transformation of a user-defined fragment of the source model into a fragment of the target model, instead of taking whole models as in case of full M2M transformation. The presented solution improves overall usability of such M2M transformations in an actual CASE tool environment.
Pub.: 09 Oct '16, Pinned: 27 Jun '17
Abstract: The increasing flexibility in industry leads to an ecosystem of change, affecting the balance of processes and technology as well as the developers who have to cope with the change. Furthermore, the change itself might impact the ability to use quantitative methods to learn from previous experience. The goal of this study is to better understand the ecosystem of mutual impacts and changes of process and technologies as well as how developers perceive a technology setting and deal with its change. Therefore, we conducted a case study at Ericsson, performing a series of interviews among 6 employees (senior developers and architects). We identified a time line of changes that happened over 7 years. A set of observations about the relation between processes and tooling, and observations about developer's perceptions of the technology settings, and their strategy to deal with these changing technology settings. We discuss how the observed change impacts the ability to perform quantitative evaluations of technology and processes. The findings show that a bad choice of technologies can lead to unexpected impact on team dynamics. Furthermore, change happens so regular that it needs to be considered when collecting data for a quantitative evaluation of, eg, productivity.
Pub.: 17 Mar '17, Pinned: 27 Jun '17
Abstract: Model-driven development is a pragmatic approach to software development that embraces domain-specific languages (DSLs), where models correspond to DSL programs. A distinguishing feature of model-driven development is that clients of a model can select from an open set of alternative semantics of the model by applying different model transformation. However, in existing model-driven frameworks, dependencies between models, model transformations, and generated code artifacts are either implicit or globally declared in build scripts, which impedes modular reasoning, separate compilation, and programmability in general. We propose the design of a new module system that incorporates models and model transformations as modules. A programmer can apply transformations in import statements, thus declaring a dependency on generated code artifacts. Our design enables modular reasoning and separate compilation by preventing hidden dependencies, and it supports mixing modeling artifacts with conventional code artifacts as well as higher-order transformations. We have formalized our design and the aforementioned properties and have validated it by an implementation and case studies that show that our module system successfully integrates model-driven development into conventional programming languages.
Pub.: 31 Mar '17, Pinned: 27 Jun '17