184 research outputs found
Towards generating transformation rules without examples for android API replacement
National Research Foundation (NRF) Singaporeauthors' own version</p
Guiding Software Developers using Automated Adaptation of Object Ensembles Plug-in
Software developing process has been improving day by day The development process can be affected through different ways like changing the development environment strategies and upcoming technologies In order to save valuable times and to speed up the process we can guide programmer during the development time through providing relevant recommendations There are some strategies that suggest related code snippets and API-items to the software programmers There are some techniques that apply general code searching approaches and some techniques that employ online based repository mining process But it is kind of difficult tasks to guide programmers when they need specific type conversion like adapting existing interfaces from the previously used types as per their demands One of the familiar approaches to guide developers in such a situation is to adapt collections and arrays through automated adaptation of object ensembles But how does it help a novice developer in real time software development that is not explicitly exemplified In this paper we have tried to introduce a system that works as a plug-in tool incorporated with a data mining integrated environment to recommend the relevant interfaces while they look for a type conversion We have a mined repository of respective adapter classes and related APIs from where programmers search their query and get their result using the relevant transformer classes The system that recommends developers entitled automated objective ensembles AOE plug-in From the investigation that we have done we can see that our approach works much better than some of the existing approache
A Systematic Review of the Literature of the Techniques to Perform Transformations in Software Engineering / Uma revisão sistemática da literatura das técnicas para realizar transformações na engenharia de software
Along with software evolution, developers may do repetitive edits. These edits can be identical or similar to different codebase locations, which may occur as developers add features, refactor, or fix a bug. Since some of these edits are not present in Integrated Development Environments (IDEs), they are often performed manually, which is time-consuming and error-prone. In order to help developers to apply repetitive edits, some techniques were proposed. In this work, we present a systematic review of the literature of the techniques to do transformations in software engineering. As a result, this systematic review returned 51 works ranging from the domains programming-by-examples, linked editing, API usage, bug fixing, complex refactoring, and complex transformations, which can be used to help tools' designer in the proposition of new approaches. Along with software evolution, developers may do repetitive edits. These edits can be identical or similar to different codebase locations, which may occur as developers add features, refactor, or fix a bug. Since some of these edits are not present in Integrated Development Environments (IDEs), they are often performed manually, which is time-consuming and error-prone. In order to help developers to apply repetitive edits, some techniques were proposed. In this work, we present a systematic review of the literature of the techniques to do transformations in software engineering. As a result, this systematic review returned 51 works ranging from the domains programming-by-examples, linked editing, API usage, bug fixing, complex refactoring, and complex transformations, which can be used to help tools' designer in the proposition of new approaches.
Transforming Programs between APIs with Many-to-Many Mappings
Transforming programs between two APIs or different versions of
the same API is a common software engineering task. However,
existing languages supporting for such transformation cannot
satisfactorily handle the cases when the relations between
elements in the old API and the new API are many-to-many
mappings: multiple invocations to the old API are supposed to be
replaced by multiple invocations to the new API. Since the
multiple invocations of the original APIs may not appear
consecutively and the variables in these calls may have different
names, writing a tool correctly to cover all such invocation
cases is not an easy task. In this paper we propose a novel
guided-normalization approach to address this problem. Our core
insight is that programs in different forms can be
semantics-equivalently normalized into a basic form guided by
transformation goals, and developers only need to write rules for
the basic form to address the transformation. Based on this
approach, we design a declarative program transformation
language, PATL, for adapting Java programs between different
APIs. PATL has simple syntax and basic semantics to handle
transformations only considering consecutive statements inside
basic blocks, while with guided-normalization, it can be extended
to handle complex forms of invocations. Furthermore, PATL ensures
that the user-written rules would not accidentally break def-use
relations in the program. We formalize the semantics of PATL on
Middleweight Java and prove the semantics-preserving property of
guided-normalization. We also evaluated our language with three
non-trivial case studies: i.e. updating Google Calendar API,
switching from JDom to Dom4j, and switching from Swing to
SWT. The result is encouraging; it shows that our language allows
successful transformations of real world programs with a small
number of rules and little manual resolution
Towards Digital Twin-enabled DevOps for CPS providing Architecture-Based Service Adaptation & Verification at Runtime
Industrial Product-Service Systems (IPSS) denote a service-oriented (SO) way
of providing access to CPS capabilities. The design of such systems bears high
risk due to uncertainty in requirements related to service function and
behavior, operation environments, and evolving customer needs. Such risks and
uncertainties are well known in the IT sector, where DevOps principles ensure
continuous system improvement through reliable and frequent delivery processes.
A modular and SO system architecture complements these processes to facilitate
IT system adaptation and evolution. This work proposes a method to use and
extend the Digital Twins (DTs) of IPSS assets for enabling the continuous
optimization of CPS service delivery and the latter's adaptation to changing
needs and environments. This reduces uncertainty during design and operations
by assuring IPSS integrity and availability, especially for design and service
adaptations at CPS runtime. The method builds on transferring IT DevOps
principles to DT-enabled CPS IPSS. The chosen design approach integrates,
reuses, and aligns the DT processing and communication resources with DevOps
requirements derived from literature. We use these requirements to propose a
DT-enabled self-adaptive CPS model, which guides the realization of DT-enabled
DevOps in CPS IPSS. We further propose detailed design models for
operation-critical DTs that integrate CPS closed-loop control and
architecture-based CPS adaptation. This integrated approach enables the
implementation of A/B testing as a use case and central concept to enable CPS
IPSS service adaptation and reconfiguration. The self-adaptive CPS model and DT
design concept have been validated in an evaluation environment for
operation-critical CPS IPSS. The demonstrator achieved sub-millisecond cycle
times during service A/B testing at runtime without causing CPS operation
interferences and downtime.Comment: Final published version appearing in 17th Symposium on Software
Engineering for Adaptive and Self-Managing Systems (SEAMS 2022
Semantic patches for Java program transformation
National Research Foundation (NRF) Singapor
HALO : a multi-feature two-pass analysis to identify framework API evolution
Software frameworks and libraries are indispensable to today’s software systems. Because of the fast development of open-source software in recent years, frameworks and libraries have became much versatile as any open-source system or part thereof can be used as a framework (or a library). Developer can reuse frameworks in innovative ways that are not expected by the providers of frameworks. Many frameworks are not well documented and very few owners provide specific documents to describe the changes between different releases of their frameworks. When they evolve, it is often time-consuming for developers to keep their dependent code up-to-date. Approaches have been proposed to lessen the impact of framework evolution on developers by identifying API evolution or change rules between two releases of a framework. However, the precision and recall of the change rules generated by these approaches depend on the features that they use, such as call-dependency relations or text similarity. If these features do not provide enough information, the approaches can miss correct change rules and compromise the precision and recall. For example, if a method in the old release of a framework is not called by other methods, we cannot find its change rule using call-dependency relations alone. Considering more features can overcome this limitation. Yet, because many features may also give contradictory information, integrating them is not straightforward. We thus introduce Halo, a novel hybrid approach that uses multiple features, including call dependency relations, method documentations, inheritance relations, and text similarity. Halo implements a two-pass analysis inspired by pattern classification problem. We implement Halo in Java and compare it with four state-of-the-art approaches. The comparison shows that, on average, the recall and the precision of Halo are 43% and 5% higher than that of other approaches
- …