18,028 research outputs found
MULTIAGENT SYSTEMS FOR SHOP FLOOR ARHITECTURE MANAGEMENT
The paper presents the problem of shop floor agility. In order to cope with the disturbances and uncertainties that characterise the current business scenarios faced by manufacturing companies, the capability of their shop floors needs to be improved quickly, such that these shop floors may be adapted, changed or become easily modifiable (shop floor reengineering). One of the critical elements in any shop floor reengineering process is the way the control/supervision architecture is changed or modified to accommodate for the new process and equipment. This paper, therefore, proposes an multi-agent architecture to support the fast adaptation or changes in the control/supervision architecture.multi-agent system, shop floor agility, control/supervision architecture, virtual organisation.
Software (Re-)Engineering with PSF II: from architecture to implementation
This paper presents ongoing research on the application of PSF in the field
of software engineering and reengineering. We build a new implementation for
the simulator of the PSF Toolkit starting from the specification in PSF of the
architecture of a simple simulator and extend it with features to obtain the
architecture of a full simulator. We apply refining and constraining techniques
on the specification of the architecture to obtain a specification low enough
to build an implementation from
Feature-based methodology for supporting architecture refactoring and maintenance of long-life software systems
Zusammenfassung
Langlebige Software-Systeme durchlaufen viele bedeutende Veraenderungen im Laufe ihres Lebenszyklus,
um der Weiterentwicklung der Problemdomaenen zu folgen. Normalerweise ist es schwierig eine
Software-Systemarchitektur den schnellen Weiterentwicklungen einer Problemdomaene anzupassen und
mit der Zeit wird der Unterschied zwischen der Problemdomaene und der Software-Systemarchitektur
zu groĂ, um weitere Softwareentwicklung sinnvoll fortzufuehren. Fristgerechte Refactorings der Systemarchitektur
sind notwendig, um dieses Problem zu vermeiden.
Aufgrund des verhaeltnismaeĂig hohen Gefahrenpotenzials und des zeitlich stark verzoegerten Nutzens
von Refactorings, werden diese MaĂnahmen normalerweise bis zum letztmoeglichen Zeitpunkt hinausgeschoben.
In der Regel ist das Management abgeneigt Architektur-Refactorings zu akzeptieren,
auĂer diese sind absolut notwendig. Die bevorzugte Vorgehensweise ist, neue Systemmerkmale ad hoc
hinzuzufuegen und nach dem Motto âAendere nie etwas an einem funktionierenden System!â vorzugehen.
Letztlich ist das Ergebnis ein Architekturzerfall (Architekturdrift). Die Notwendigkeit kleiner
Refactoring-Schritte fuehrt zur Notwendigkeit des Architektur-Reengineerings. Im Gegensatz zum
Refactoring, das eine normale Entwicklungstaetigkeit darstellt, ist Reengineering eine Form der Software-
âRevolutionâ. Reengineeringprojekte sind sehr riskant und kostspielig. Der Nutzen des Reengineerings
ist normalerweise nicht so hoch wie erwartet. Wenn nach dem Reengineering schlieĂlich die erforderlichen
Architekturaenderungen statt.nden, kann dies zu spaet sein. Trotz der enormen in das Projekt
gesteckten Bemuehungen erfuellen die Resultate des Reengineerings normalerweise nicht die Erwartungen.
Es kann passieren, dass sehr bald ein neues, kostspieliges Reengineering erforderlich wird.
In dieser Arbeit werden das Problem der Softwareevolution und der Zerfall von Softwarearchitekturen
behandelt. Eine Methode wird vorgestellt, welche die Softwareentwicklung in ihrer entscheidenden
Phase, dem Architekturrefactoring, unterstuetzt. Die Softwareentwicklung wird sowohl in technischer
als auch organisatorischer Hinsicht unterstuetzt. Diese Arbeit hat neue Techniken entwickelt,
welche die Reverse-Engineering-, Architecture-Recovery- und Architecture-Redesign-Taetigkeiten unterst
uetzen. Sie schlaegt auch Aenderungen des Softwareentwicklungsprozesses vor, die fristgerechte Architekturrefactorings
erzwingen koennen und damit die Notwendigkeit der Durchfuehrung eines Architektur-
Reengineerings vermeiden.
In dieser Arbeit wird die Merkmalmodellierung als Hauptinstrument verwendet. Merkmale werden
genutzt, um die Abstraktionsluecke zwischen den Anforderungen der Problemdomaene und der Systemarchitektur
zu fuellen. Merkmalmodelle werden auch als erster Grundriss fr die Wiederherstellung
der verlorenen Systemarchitektur genutzt. Merkmalbasierte Analysen fuehren zu diversen, nuetzlichen
Hinweisen fuer den erneuten Entwurf (das Re-Design) einer Architektur. SchlieĂlich wird die Merkmalmodellierung
als Kommunikationsmittel zwischen unterschiedlichen Projektbeteiligten (Stakeholdern)
im Verlauf des Softwareengineering-Prozesses verwendet und auf dieser Grundlage wird ein neuer
Anforderungsde.nitionsprozess vorgeschlagen, der die erforderlichen Architekturrefactorings erzwingt.The long-life software systems withstand many significant changes throughout their life-cycle in order
to follow the evolution of the problem domains. Usually, the software system architecture can not
follow the rapid evolution of a problem domain and with time, the diversion of the architecture in
respect to the domain features becomes prohibiting for software evolution. For avoiding this problem,
periodical refactorings of the system architecture are required.
Usually, architecture refactorings are postponed until the very last moment, because of the relatively
high risk involved and the lack of short-term profit. As a rule, the management is unwilling to accept
architecture refactorings unless they become absolutely necessary. The preferred way of working is to
add new system features in an ad-hoc manner and to keep the rule âNever touch a running system!â.
The final result is an architecture decay. The need of performing small refactoring activities turns into
need for architecture reengineering. In contrast to refactoring, which is a normal evolutionary activity,
reengineering is a kind of software ârevolutionâ. Reengineering projects are risky and expensive. The
effectiveness of reengineering is also usually not as high as expected. When finally after reengineering
the required architecture changes take place, it can be too late. Despite the enormous invested efforts,
the results of the reengineering usually do not satisfy the expectations. It might happen that very
soon a new expensive reengineering is required.
This thesis deals with the problem of software evolution and the decay of software architectures.
It presents a method, which assists software evolution in its crucial part, the architecture refactoring.
The assistance is performed for both technical and organizational aspects of the software evolution.
The thesis provides new techniques for supporting reverse engineering, architecture recovery and redesigning
activities. It also proposes changes to the software engineering process, which can force
timely architecture refactorings and thus avoid the need of performing architecture reengineering.
For the work in this thesis feature modeling is utilized as a main asset. Features are used to fill the
abstraction gap between domain requirements and system architecture. Feature models are also used
as an outline for recovering of lost system architectures. Through feature-based analyses a number of
useful hints and clues for architecture redesign are produced. Finally, feature modeling is used as a
communication between different stakeholders of the software engineering process and on this basis a
new requirements engineering process is proposed, which forces the needed architecture refactorings
Software-Architecture Recovery from Machine Code
In this paper, we present a tool, called Lego, which recovers object-oriented software architecture from stripped binaries. Lego takes a stripped binary as input, and uses information obtained from dynamic analysis to (i) group the functions in the binary into classes, and (ii) identify inheritance and composition relationships between the inferred classes. The information obtained by Lego can be used for reengineering legacy software, and for understanding the architecture of software systems that lack documentation and source code. Our experiments show that the class hierarchies recovered by Lego have a high degree of agreement---measured in terms of precision and recall---with the hierarchy defined in the source code
A Repository for a CARE Environment
Repositories in CASE hold information about the development process and the structure of developing software. The migration or reuse of CASE repositories for CARE (Computer Aided Re-Engineering) is not adequate for the reengineering process. The main reasons for its inadequacy are the emptiness of such repositories and the nature of the process itself. In the following report we will define a CARE architecture, from the reengineering point of view, and derive a structure of a repository appropriate to the reengineering process
Privacy-Preserving Reengineering of Model-View-Controller Application Architectures Using Linked Data
When a legacy systemâs software architecture cannot be redesigned, implementing
additional privacy requirements is often complex, unreliable and
costly to maintain. This paper presents a privacy-by-design approach to
reengineer web applications as linked data-enabled and implement access
control and privacy preservation properties. The method is based on the
knowledge of the application architecture, which for the Web of data is
commonly designed on the basis of a model-view-controller pattern. Whereas
wrapping techniques commonly used to link data of web applications duplicate
the security source code, the new approach allows for the controlled
disclosure of an applicationâs data, while preserving non-functional properties
such as privacy preservation. The solution has been implemented
and compared with existing linked data frameworks in terms of reliability,
maintainability and complexity
Program Understanding: A Reengineering Case for the Transformation Tool Contest
In Software Reengineering, one of the central artifacts is the source code of
the legacy system in question. In fact, in most cases it is the only definitive
artifact, because over the time the code has diverged from the original
architecture and design documents. The first task of any reengineering project
is to gather an understanding of the system's architecture. Therefore, a common
approach is to use parsers to translate the source code into a model conforming
to the abstract syntax of the programming language the system is implemented in
which can then be subject to querying. Despite querying, transformations can be
used to generate more abstract views on the system's architecture. This
transformation case deals with the creation of a state machine model out of a
Java syntax graph. It is derived from a task that originates from a real
reengineering project.Comment: In Proceedings TTC 2011, arXiv:1111.440
Analysis of Software Binaries for Reengineering-Driven Product Line Architecture\^aAn Industrial Case Study
This paper describes a method for the recovering of software architectures
from a set of similar (but unrelated) software products in binary form. One
intention is to drive refactoring into software product lines and combine
architecture recovery with run time binary analysis and existing clustering
methods. Using our runtime binary analysis, we create graphs that capture the
dependencies between different software parts. These are clustered into smaller
component graphs, that group software parts with high interactions into larger
entities. The component graphs serve as a basis for further software product
line work. In this paper, we concentrate on the analysis part of the method and
the graph clustering. We apply the graph clustering method to a real
application in the context of automation / robot configuration software tools.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301
- âŠ