84 research outputs found
A Reference Architecture for Provisioning of Tools as a Service: Meta-Model, Ontologies and Design Elements
Abstract not availableMuhammad Aufeef Chauhan, Muhammad Ali Babar, Quan Z. Shen
Preserving the Quality of Architectural Tactics in Source Code
In any complex software system, strong interdependencies exist between requirements and software architecture. Requirements drive architectural choices while also being constrained by the existing architecture and by what is economically feasible. This makes it advisable to concurrently specify the requirements, to devise and compare alternative architectural design solutions, and ultimately to make a series of design decisions in order to satisfy each of the quality concerns.
Unfortunately, anecdotal evidence has shown that architectural knowledge tends to be tacit in nature, stored in the heads of people, and lost over time. Therefore, developers often lack comprehensive knowledge of underlying architectural design decisions and inadvertently degrade the quality of the architecture while performing maintenance activities. In practice, this problem can be addressed through preserving the relationships between the requirements, architectural design decisions and their implementations in the source code, and then using this information to keep developers aware of critical architectural aspects of the code.
This dissertation presents a novel approach that utilizes machine learning techniques to recover and preserve the relationships between architecturally significant requirements, architectural decisions and their realizations in the implemented code.
Our approach for recovering architectural decisions includes the two primary stages of training and classification. In the first stage, the classifier is trained using code snippets of different architectural decisions collected from various software systems. During this phase, the classifier learns the terms that developers typically use to implement each architectural decision. These ``indicator terms\u27\u27 represent method names, variable names, comments, or the development APIs that developers inevitably use to implement various architectural decisions. A probabilistic weight is then computed for each potential indicator term with respect to each type of architectural decision. The weight estimates how strongly an indicator term represents a specific architectural tactics/decisions. For example, a term such as \emph{pulse} is highly representative of the heartbeat tactic but occurs infrequently in the authentication. After learning the indicator terms, the classifier can compute the likelihood that any given source file implements a specific architectural decision.
The classifier was evaluated through several different experiments including classical cross-validation over code snippets of 50 open source projects and on the entire source code of a large scale software system. Results showed that classifier can reliably recognize a wide range of architectural decisions.
The technique introduced in this dissertation is used to develop the Archie tool suite. Archie is a plug-in for Eclipse and is designed to detect wide range of architectural design decisions in the code and to protect them from potential degradation during maintenance activities. It has several features for performing change impact analysis of architectural concerns at both the code and design level and proactively keep developers informed of underlying architectural decisions during maintenance activities.
Archie is at the stage of technology transfer at the US Department of Homeland Security where it is purely used to detect and monitor security choices. Furthermore, this outcome is integrated into the Department of Homeland Security\u27s Software Assurance Market Place (SWAMP) to advance research and development of secure software systems
Software Documentation Guidelines For Maintainability
Software maintenance is the final stage in the software engineering process; and can also be the longest and most costly. The ability of, and ease in which software upkeep and change is performed is an important software quality attribute called maintainability. Software maintenance however is an expensive process in both time and financial cost and can account for a majority of a system\u27s overall lifetime cost. It would be beneficial then to have a set of guidelines for obtaining a higher degree of maintainability in software before and after its release and evolution stage in order to limit the cost of change. Six suggested steps for achieving a higher degree of maintainability through software documentation are provided along with a short case study, followed by a discussion on potential results and future enhancements to the proposed method
Software product quality requirements engineering method : SOQUAREM
The IT industry needs reliable data about Quality Requirements (QRs) to adequately evaluate systems and their architecture. Quality requirements management of the software product is an emerging discipline aiming to enhance the software product quality by addressing its quality requirements. Dealing with this kind of requirements is not easy and implies much effort from practitioners, better involvement of interested stakeholders and a solid knowledge in quality management techniques. In fact they are vague, difficult to define and often conflict with other requirements. New approaches toward QRs management are developed to resolve problems of traditional software engineering views as: a) lack of systematic guidelines on how to elicit QRs; b) difficulty to identify QRs and to represent them in models and processes.
In the context of a proposal for a SOftware product QUAlity Requirements Engineering Method (SOQUAREM), this thesis provides a structured QRs engineering process with its supporting ISO/IEC SQuaRE 25030 standard, management techniques and concepts. SOQUAREM process spans 2 high levels of abstraction (business and system) and six conceptual phases such as: identification and refinement of business goals, derivation and consolidation of the quality attributes and their integration into the functional process. The proposed SOQUAREM illustrates in a structured and easy to use way how several concepts can be combined at different organizational levels to identify, represent, document and retrace quality attributes.
This document is divided into six chapters: the first chapter presents a background and related work on "Quality requirements" in general and on various quality requirements management methods such as MOQARE (Misuse-Oriented QuAlity Requirements Engineering)), IESE NFR (Institute for Experimental Software Engineering Non Functional Requirements), Soft Goal Notation (Chung Framework), FDAF (Formal Design and Analysis Framework) and ATAM (Architecture Tradeoff Analysis Method). The second chapter introduces the research topic with its objectives, its limits, the research methodology and research steps. The third chapter describes the research execution by analyzing the current situation of quality requirements with the resulted indicators from academic and industrial environments and formulating the future requirements of the proposed research solution. An overview of the innovative aspects of proposed method like its specific features, metamodel, building process, and process structure are pinpointed. The fourth chapter describes primarily the most important parts of the research which are the development of a new quality requirements engineering method called SOftware product QUAlity Requirements Engineering Method including fundamentals, key concepts and a process model. The fifth chapter presents an illustrative example applied to a building automation system called MSLite. Applicability of SOQUAREM process in this example is developed and analyzed. The last chapter presents a conclusion on this research work and its expected evolution in the future
Quality Goal Oriented Architectural Design and Traceability for Evolvable Software Systems
Softwaresysteme werden heute z.B. aufgrund sich ändernder Geschäftsprozesse
oder Technologien mit häufigen Veränderungen konfrontiert. Die Software und
speziell ihre Architektur muss diese Ă„nderungen zur dauerhaften Nutzbarkeit
ermöglichen.Während der Software-Evolution können Änderungen zu einer
Verschlechterung der Architektur fĂĽhren, der Architekturerosion. Dies
erschwert oder verhindert weitere Ă„nderungen wegen Inkonsistenz oder
fehlendem Programmverstehen. Zur Erosionsvermeidung müssen Qualitätsziele
wie Weiterentwickelbarkeit, Performanz oder Usability sowie die
Nachvollziehbarkeit von Architekturentwurfsentscheidungen berĂĽcksichtigt
werden. Dies wird jedoch oft vernachlässigt.Existierende Entwurfsmethoden
unterstützen den Übergang von Qualitätzielen zu geeigneten
Architekturlösungen nur unzureichend aufgrund einer Lücke zwischen Methoden
des Requirements Engineering und des Architekturentwurfs. Insbesondere gilt
dies fĂĽr Weiterentwickelbarkeit und die Nachvollziehbarkeit von
Entwurfsentscheidungen durch explizite Modellabhängigkeiten.Diese Arbeit
präsentiert ein neues Konzept, genannt Goal Solution Scheme, das
Qualitätsziele über Architekturprinzipien auf Lösungsinstrumente durch
explizite Abhängigkeiten abbildet. Es hilft somit, Architekturlösungen
entsprechend ihrem Einfluss auf Qualitätsziele auszuwählen. Das Schema wird
speziell hinsichtlich Weiterentwickelbarkeit diskutiert und ist in ein
zielorientiertes Vorgehen eingebettet, das etablierte Methoden und Konzepte
des Requirements Engineering und Architekturentwurfs verbessert und
integriert. Dies wird ergänzt durch ein Traceability-Konzept, welches einen
regelbasierten Ansatz mit Techniken des Information Retrieval verbindet.
Dies ermöglicht eine (halb-) automatische Erstellung von Traceability Links
mit spezifischen Linktypen und Attributen fĂĽr eine reichhaltige Semantik
sowie mit hoher Genauigkeit und Trefferquote.Die Realisierbarkeit des
Ansatzes wird an einer Fallstudie einer Software fĂĽr mobile Serviceroboter
gezeigt. Das Werkzeug EMFTrace wurde als eine erweiterbare Plattform
basierend auf Eclipse-Technologie implementiert, um die Anwendbarkeit der
Konzepte zu zeigen. Es integriert Entwurfsmodelle von externen CASE-Tools
mittels XML-Technologie in einem gemeinsamen Modell-Repository, wendet
Regeln zur Linkerstellung an und bietet Validierungsfunktionen fĂĽr Regeln
und Links.Today software systems are frequently faced with demands for changes, for
example, due to changing business processes or technologies. The software
and especially its architecture has to cope with those frequent changes to
permanently remain usable.During software evolution changes can lead to a
deterioration of the structure of software architectures called
architectural erosion, which hampers or even inhibits further changes
because of inconsistencies or lacking program comprehension. To support
changes and avoid erosion, especially quality goals, such as evolvability,
performance, or usability, and the traceability of design decisions have to
be considered during architectural design. This however often is
neglected.Existing design methods do not sufficiently support the
transition from the quality goals to appropriate architectural solutions
because there is still a gap between requirements engineering and
architectural design methods. Particularly support is lacking for the goal
evolvability and for the traceability of design decisions by explicit model
dependencies.This thesis presents a new concept called Goal Solution
Scheme, which provides a mapping from goals via architectural principles to
solution instruments by explicit dependencies. Thus it helps to select
appropriate architectural solutions according to their influence on quality
goals. The scheme is discussed especially regarding evolvability, and it is
embedded in a goal-oriented architectural design method, which enhances and
integrates established methods and concepts from requirements engineering
as well as architectural design. This is supplemented by a traceability
concept, which combines a rule-based approach with information retrieval
techniques for a (semi-) automated establishment of links with specific
link types and attributes for rich semantics and a high precision and
recall.The feasibility of the design approach has been evaluated in a case
study of a software platform for mobile robots. A prototype tool suite
called EMFTrace was implemented as an extensible platform based on Eclipse
technology to show the practicability of the thesis' concept. It integrates
design models from external CASE tools in a joint model repository by means
of XML technology, applies rules for link establishment, and provides
validation capabilities for rules and links
Assisting software architects in architectural decision-making using Quark
Non-Functional Requirements (NFRs) and constraints are among the principal drivers of architectural decision-making. NFRs are improved or damaged by architectural decisions (ADs), while constraints directly include or exclude parts of the architecture (e.g., logical components or technologies). We may determine the impact of an AD, or which parts of the architecture are affected by a constraint, but at the end it is hard to know if we are respecting the NFRs and the imposed constraints with all the ADs made. In the usual approach, architects use their own experience to produce software architectures
that comply with the NFRs and imposed constraints, but at the end, especially for crucial decisions, the architect has to deal with complex trade-offs between NFRs and juggle with possible incompatibilities raised by the imposed constraints. In this paper we present Quark, a method to assist software architects in architectural decision-making, and the conceptualization of the relationship between NFRs and ADs defined in Arteon, an ontology to represent and manage architectural knowledge. Finally, we provide an overview of the Quark and Arteon implementation, the ArchiTech tool.Peer ReviewedPostprint (published version
Deducing Requirements From Agile Software Processes
In classical engineering practice, the elicitation of requirements is an important early project phase. Requirements help to define the project goals and scope, they serve as a basis for cost estimation, and in validated projects they are the cornerstone of the traceability matrix. However, requirements elicitation is difficult because of the abstract nature of the process and because there is uncertainty at the start of a project about what can be done.
In recent software development practice, waterfall methods have fallen into disfavor, and agile methods are preferred. Agile methods avoid formal requirements specification, and instead use techniques such as scrums and user stories to specify development phases that are performed iteratively. In agile methods, requirements remain implicit and undocumented.
While agile may avoid the difficulties of formal elicitation of requirements, it may in the process bypass the activity of analysis of user needs, and the generation of a baseline against which the implemented system can be validated.
In this thesis we show that requirements can be deduced from the user stories and process maps that result from agile methodologies. A modified failure mode effects analysis approach is used to identify risks, failure modes, and countermeasures, and to evaluate risks and countermeasures by computing severity and likelihood of the risks, and the benefits of the countermeasures.
The deduction of requirements from agile artifacts encourages an agile team to think through its preferences and proposed implementations, and objectively rate them. It captures the rationale for the user stories and process maps, and provides traceability from business goals to the functional requirements
- …