75 research outputs found
A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw
Aspect oriented programming aims at achieving better modularization for a
system's crosscutting concerns in order to improve its key quality attributes,
such as evolvability and reusability. Consequently, the adoption of
aspect-oriented techniques in existing (legacy) software systems is of interest
to remediate software aging. The refactoring of existing systems to employ
aspect-orientation will be considerably eased by a systematic approach that
will ensure a safe and consistent migration.
In this paper, we propose a refactoring and testing strategy that supports
such an approach and consider issues of behavior conservation and (incremental)
integration of the aspect-oriented solution with the original system. The
strategy is applied to the JHotDraw open source project and illustrated on a
group of selected concerns. Finally, we abstract from the case study and
present a number of generic refactorings which contribute to an incremental
aspect-oriented refactoring process and associate particular types of
crosscutting concerns to the model and features of the employed aspect
language. The contributions of this paper are both in the area of supporting
migration towards aspect-oriented solutions and supporting the development of
aspect languages that are better suited for such migrations.Comment: 25 page
A systematic aspect-oriented refactoring and testing strategy, and its application to JHotDraw.
Aspect oriented programming aims at achieving better modularization for a system's crosscutting concerns in order to improve its key quality attributes, such as evolvability and reusability. Consequently, the adoption of aspect-oriented techniques in existing (legacy) software systems is of interest to remediate software aging. The refactoring of existing systems to employ aspect-orientation will be considerably eased by a systematic approach that will ensure a safe and consistent migration. In this paper, we propose a refactoring and testing strategy that supports such an approach and consider issues of behavior conservation and (incremental) integration of the aspect-oriented solution with the original system. The strategy is applied to the JHotDraw open source project and illustrated on a group of selected concerns. Finally, we abstract from the case study and present a number of generic refactorings which contribute to an incremental aspect-oriented refactoring process and associate particular types of crosscutting concerns to the model and features of the employed aspect language. The contributions of this paper are both in the area of supporting migration towards aspect-oriented solutions and supporting the development of aspect languages that are better suited for such migration
Handling High-Level Model Changes Using Search Based Software Engineering
Model-Driven Engineering (MDE) considers models as first-class artifacts during the software
lifecycle. The number of available tools, techniques, and approaches for MDE is increasing as its
use gains traction in driving quality, and controlling cost in evolution of large software systems.
Software models, defined as code abstractions, are iteratively refined, restructured, and evolved.
This is due to many reasons such as fixing defects in design, reflecting changes in requirements,
and modifying a design to enhance existing features.
In this work, we focus on four main problems related to the evolution of software models: 1) the
detection of applied model changes, 2) merging parallel evolved models, 3) detection of design
defects in merged model, and 4) the recommendation of new changes to fix defects in software
models.
Regarding the first contribution, a-posteriori multi-objective change detection approach has been
proposed for evolved models. The changes are expressed in terms of atomic and composite
refactoring operations. The majority of existing approaches detects atomic changes but do not
adequately address composite changes which mask atomic operations in intermediate models.
For the second contribution, several approaches exist to construct a merged model by
incorporating all non-conflicting operations of evolved models. Conflicts arise when the
application of one operation disables the applicability of another one. The essence of the problem
is to identify and prioritize conflicting operations based on importance and context – a gap in
existing approaches. This work proposes a multi-objective formulation of model merging that
aims to maximize the number of successfully applied merged operations.
For the third and fourth contributions, the majority of existing works focuses on refactoring at
source code level, and does not exploit the benefits of software design optimization at model
level. However, refactoring at model level is inherently more challenging due to difficulty in
assessing the potential impact on structural and behavioral features of the software system. This requires analysis of class and activity diagrams to appraise the overall system quality, feasibility,
and inter-diagram consistency. This work focuses on designing, implementing, and evaluating a
multi-objective refactoring framework for detection and fixing of design defects in software
models.Ph.D.Information Systems Engineering, College of Engineering and Computer ScienceUniversity of Michigan-Dearbornhttp://deepblue.lib.umich.edu/bitstream/2027.42/136077/1/Usman Mansoor Final.pdfDescription of Usman Mansoor Final.pdf : Dissertatio
Refactoring and representation independence for class hierarchies
AbstractRefactoring transformations are important for productivity and quality in software evolution. Modular reasoning about semantics preserving transformations is difficult even in typed class-based languages because transformations can change the internal representations for multiple interdependent classes and because encapsulation can be violated by pointers to mutable objects. In this paper, an existing theory of representation independence for a single class, based on a simple notion of ownership confinement, is generalized to a hierarchy of classes and used to prove refactoring rules that embody transformations of complete class trees. This allows us to formalize refactorings that inherently involve class inheritance, such as Pull Up or Push Down Field; moreover, this makes it possible to generalize refactorings previously restricted to change of data representation of private attributes (like Extract Class and Encapsulate Field) to address data refinement of protected attributes, dealing with the impact that the corresponding transformations may cause in the subclasses. The utility of the proposed rules is shown in a relatively extensive case study. Shortcomings of the theory are described as a challenge to other approaches to heap encapsulation and relational reasoning for classes
An Empirical Study of Refactorings and Technical Debt in Machine Learning Systems
Machine Learning (ML), including Deep Learning (DL), systems, i.e., those with ML capabilities, are pervasive in today’s data-driven society. Such systems are complex; they are comprised of ML models and many subsystems that support learning processes. As with other complex systems, ML systems are prone to classic technical debt issues, especially when such systems are long-lived, but they also exhibit debt specific to these systems. Unfortunately, there is a gap of knowledge in how ML systems actually evolve and are maintained. In this paper, we fill this gap by studying refactorings, i.e., source-to-source semantics-preserving program transformations, performed in real-world, open-source software, and the technical debt issues they alleviate. We analyzed 26 projects, consisting of 4.2 MLOC, along with 327 manually examined code patches. The results indicate that developers refactor these systems for a variety of reasons, both specific and tangential to ML, some refactorings correspond to established technical debt categories, while others do not, and code duplication is a major cross-cutting theme that particularly involved ML configuration and model code, which was also the most refactored. We also introduce 14 and 7 new ML-specific refactorings and technical debt categories, respectively, and put forth several recommendations, best practices, and anti-patterns. The results can potentially assist practitioners, tool developers, and educators in facilitating long-term ML system usefulness
SAVCBS 2004 Specification and Verification of Component-Based Systems: Workshop Proceedings
This is the proceedings of the 2004 SAVCBS workshop. The workshop is concerned with how formal (i.e., mathematical) techniques can be or should be used to establish a suitable foundation for the specification and verification of component-based systems. Component-based systems are a growing concern for the software engineering community. Specification and reasoning techniques are urgently needed to permit composition of systems from components. Component-based specification and verification is also vital for scaling advanced verification techniques such as extended static analysis and model checking to the size of real systems. The workshop considers formalization of both functional and non-functional behavior, such as performance or reliability
Model-Driven Engineering in the Large: Refactoring Techniques for Models and Model Transformation Systems
Model-Driven Engineering (MDE) is a software engineering paradigm that
aims to increase the productivity of developers by raising the
abstraction level of software development. It envisions the use of
models as key artifacts during design, implementation and deployment.
From the recent arrival of MDE in large-scale industrial software
development – a trend we refer to as MDE in the large –, a set of
challenges emerges: First, models are now developed at distributed
locations, by teams of teams. In such highly collaborative settings, the
presence of large monolithic models gives rise to certain issues, such
as their proneness to editing conflicts. Second, in large-scale system
development, models are created using various domain-specific modeling
languages. Combining these models in a disciplined manner calls for
adequate modularization mechanisms. Third, the development of models is
handled systematically by expressing the involved operations using model
transformation rules. Such rules are often created by cloning, a
practice related to performance and maintainability issues.
In this thesis, we contribute three refactoring techniques, each aiming
to tackle one of these challenges. First, we propose a technique to
split a large monolithic model into a set of sub-models. The aim of this
technique is to enable a separation of concerns within models, promoting
a concern-based collaboration style: Collaborators operate on the
submodels relevant for their task at hand. Second, we suggest a
technique to encapsulate model components by introducing modular
interfaces in a set of related models. The goal of this technique is to
establish modularity in these models. Third, we introduce a refactoring
to merge a set of model transformation rules exhibiting a high degree of
similarity. The aim of this technique is to improve maintainability and
performance by eliminating the drawbacks associated with cloning. The
refactoring creates variability-based rules, a novel type of rule
allowing to capture variability by using annotations.
The refactoring techniques contributed in this work help to reduce the
manual effort during the refactoring of models and transformation rules
to a large extent. As indicated in a series of realistic case studies,
the output produced by the techniques is comparable or, in the case of
transformation rules, partly even preferable to the result of manual
refactoring, yielding a promising outlook on the applicability in
real-world settings
Quality Assurance of Software Models - A Structured Quality Assurance Process Supported by a Flexible Tool Environment in the Eclipse Modeling Project
The paradigm of model-based software development (MBSD) has become more and more popular since it promises an increase in the efficiency and quality of software development. In this paradigm, software models play an increasingly important role and software quality and quality assurance consequently leads back to the quality and quality assurance of the involved models.
The fundamental aim of this thesis is the definition of a structured syntax-oriented process for quality assurance of software models that can be adapted to project-specific and domain-specific needs. It is structured into two sub-processes: a process for the specification of project-specific model quality assurance techniques, and a process for applying them on concrete software models within a MBSD project. The approach concentrates on quality aspects to be checked on the abstract model syntax and is based on quality assurance techniques model metrics, smells, and refactorings well-known from literature. So far, these techniques are mostly considered in isolation only and therefore the proposed process integrates them in order to perform model quality assurance more systematically. Three example cases performing the process serve as proof-of-concept implementations and show its applicability, its flexibility, and hence its usefulness.
Related to several issues concerning model quality assurance minor contributions of this thesis are (1) the definition of a quality model for model quality that consists of high-level quality attributes and low-level characteristics, (2) overviews on metrics, smells, and refactorings for UML class models including structured descriptions of each technique, and (3) an approach for composite model refactoring that concentrates on the specification of refactoring composition.
Since manually reviewing models is time consuming and error prone, several tasks of the proposed process should consequently be automated. As a further main contribution, this thesis presents a flexible tool environment for model quality assurance which is based on the Eclipse Modeling Framework (EMF), a common open source technology in model-based software development. The tool set is part of the Eclipse Modeling Project (EMP) and belongs to the Eclipse incubation project EMF Refactor which is available under the Eclipse public license (EPL). The EMF Refactor framework supports both the model designer and the model reviewer by obtaining metrics reports, by checking for potential model deficiencies (called model smells) and by systematically restructuring models using refactorings. The functionality of EMF Refactor is integrated into standard tree-based EMF instance editors, graphical GMF-based editors as used by Papyrus UML, and textual editors provided by Xtext. Several experiments and studies show the suitability of the tools for supporting the techniques of the structured syntax-oriented model quality assurance process
- …