Dissertations / Theses on the topic 'Software architecture'

By the increasing needs of software industry, software systems became more complex constructions than ever before. As a result of increasing complexity in software systems, functional decomposition of these systems gains the status of the most important aspect in the software development process. Dividing problems to sub-problems and producing specific solutions for divided parts makes it easier to solve the main problem.

Component Based Software Engineering is a way of developing software systems that consists of logically or functionally decomposed components which integrated to each other by the help of well-defined interfaces. CBSE relies on architectural design of a software system.

Planning phase and implementation of a software project may differ time to time. Because of the complexity of software systems, solving specific problems may affect the architecture of the whole system.

In spite of sophisticated software engineering processes and CASE tools there is still a large gap between the planned and implemented architecture of software systems. Finding deviations from architecture in source code is a non-trivial task requiring tool support.

Since, matching operation of designed software architecture and implemented software architecture needs to check design documents against implementation code. This manual checking operation is nearly impossible for major software systems. Software Architecture Checker provides a great approach to check the architecture of any software system.

This bachelor thesis examines the approach behind the Software Architecture Checker.

A software architecture is one of the first steps towards a software system. A software architecture can be designed in different ways. During the design phase, it is important to select the most suitable design of the architecture, in order to create a good foundation for the system. The selection process is performed by evaluating architecture alternatives against each other. We investigate the use of continuous simulation of a software architecture as a support tool for architecture evaluation. For this purpose, we study a software architecture of an existing software system in an experiment, where we create a model of it using a tool for continuous simulation, and simulate the model. Based on the results from the simulation, we conclude that the system is too complex to be modeled for continuous simulation. Problems we identify are that we need discrete functionality to be able to correctly simulate the system, and that it is very time-consuming to develop a model for evaluation purposes. Thus, we find that continuous simulation is not appropriate for evaluating a software architecture, but that the modeling process is a valuable tool for increasing knowledge and understanding about an architecture.

Many software systems eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the causes, architecture evolution is commonplace in real-world software projects. Today’s software architects, however, have few techniques to help them plan such evolution. In particular, they have little assistance in planning alternatives, making trade-offs among these different alternatives, or applying best practices for particular domains. To address this, we have developed an approach for assisting architects in planning and reasoning about software architecture evolution. Our approach is based on modeling and analyzing potential evolution paths that represent different ways of evolving the system. We represent an evolution path as a sequence of transitional architectural states leading from the initial architecture to the target architecture, along with evolution operators that characterize the transitions among these states. We support analysis of evolution paths through the definition and application of constraints that express rules governing the evolution of the systemand evaluation functions that assess path quality. Finally, a set of these modeling elements may be grouped together into an evolution style that encapsulates a body of knowledge relevant to a particular domain of architecture evolution. We evaluate this approach in three ways. First, we evaluate its applicability to real-world architecture evolution projects. This is accomplished through case studies of two very different software organizations. Second, we undertake a formal evaluation of the computational complexity of verifying evolution constraints. Finally, we evaluate the implementability of the approach based on our experiences developing prototype tools for software architecture evolution.

Tracing the history of software engineering reveals a series of abstractions. In early days, software engineers would construct software using machine code. As time progressed, software engineers and computer scientists developed higher levels of abstraction in order to provide tools to assist in building larger software systems. This has resulted in high-level languages, modelling languages, design patterns, and software architecture. Software architecture has been recognised as an important tool for designing and building software. Some research takes the view that the success or failure of a software development project depends heavily on the quality of the software architecture. For any software system, there are a number of individuals who have some interest in the architecture. These stakeholders have differing requirements of the software architecture depending on the role that they take. Stakeholders include the architects, designers, developers and also the sales, services and support teams and even the customer for the software. Communication and understanding of the architecture is essential in ensuring that each stakeholder can play their role during the design, development and deployment of that software system. Software visualisation has traditionally been focused on aiding the understanding of software systems by those who perform development and maintenance tasks on that software. In supporting developers and maintainers, software visualisation has been largely concerned with representing static and dynamic aspects of software at the code level. Typically, a software visualisation will represent control flow, classes, objects, import relations and other such low level abstractions of the software. This research identifies the fundamental issues concerning software architecture visualisation. It does this by identifying the practical use of software architecture in the real world, and considers the application of software visualisation techniques to the visualisation of software architecture. The aim of this research is to explore the ways in which software architecture visualisation can assist in the tasks undertaken by the differing stakeholders in a software system and its architecture. A prototype tool, named ArchVis, has been developed to enable the exploration of some of the fundamental issues in software architecture visualisation. ArchVis is a new approach to software architecture visualisation that is capable of utilising multiple sources and representations of architecture in order to generate multiple views of software architecture. The mechanism by which views are generated means that they can be more relevant to a wider collection of stakeholders in that architecture. During evaluation ArchVis demonstrates the capability of utilising a number of data sources in order to produce architecture visualisations. Arch Vis' view model is capable of generating the necessary views for architecture stakeholders and those stakeholders can navigate through the views and data in order to obtain relevant information. The results of evaluating ArchVis using a framework and scenarios demonstrate that the majority of the objectives of this research have been achieved.

Software is characterized by inevitable changes and increasing complexity, which in turn may lead to huge costs unless rigorously taking into account change accommodations. This is in particular true for long-lived systems. For such systems, there is a need to address evolvability explicitly during the entire lifecycle, carry out software evolution efficiently and reliably, and prolong the productive lifetime of the software systems.

In this thesis, we study evolution of software architecture and investigate ways to support this evolution.           The central theme of the thesis is how to analyze software evolvability, i.e. a system’s ability to easily accommodate changes. We focus on several particular aspects: (i) what software characteristics are necessary to constitute an evolvable software system; (ii) how to assess evolvability in a systematic manner; (iii) what impacts need to be considered given a certain change stimulus that results in potential requirements the software architecture needs to adapt to, e.g. ever-changing business requirements and advances of technology.

To improve the capability in being able to on forehand understand and analyze systematically the impact of a change stimulus, we introduce a software evolvability model, in which subcharacteristics of software evolvability and corresponding measuring attributes are identified. In addition, a further study of one particular measuring attribute, i.e. modularity, is performed through a dependency analysis case study.

We introduce a method for analyzing software evolvability at the architecture level. This is to ensure that the implications of the potential improvement strategies and evolution path of the software architecture are analyzed with respect to the evolvability subcharacteristics. This method is proposed and piloted in an industrial setting.

The fact that change stimuli come from both technical and business perspectives spawns two aspects that we also look into in this research, i.e. to respectively investigate the impacts of technology-type and business-type of change stimuli.

Today it is more a rule than an exception that software systems have a lifecycle of more than several years. Hence, software evolution is inevitable. During the life span of a software system the domain in which the system is working evolves and changes. This causes changes to the software system, and the software system may also be evolved to satisfy new markets. The ability to evolve gracefully, and thus the long-term success of a software system, is to a large extent governed by its software architecture and the ability of the software architecture to fulfil requirements on quality attributes and to adapt to evolving requirements. In this thesis we study evolution of software architectures and what can be done to support this evolution. We focus on three particular aspects of evolution support: how to ensure that the correct blend of quality attributes is met (architecture selection), the technical means available for supporting changes in the software system (variability), and what types of changes that are likely to occur during evolution (categories of evolution). We introduce a method for architecture evaluation and selection that focus on ensuring that the selected software architecture is the architecture candidate with the most potential for fulfilling a particular blend of quality attributes. The method is based on quantification of expert opinions and focused discussions where these expert opinions differ. The architecture evaluation and selection method is studied in both an academic and in an industry setting. We also introduce a taxonomy of techniques for realising variability in a software system and study how the techniques in this taxonomy are applied in different evolution situations. The taxonomy is based on several industry case studies. Two industry cases are studied in further detail and the evolution of these systems are followed over a number of releases and generations. During this evolution it is shown how variability mechanisms are used to also support evolution, and that there are typical cases of evolution that a software system can be prepared to cope with. The contribution of this thesis is that it increases the understanding of how evolution occurs in a software system, how to create software that is flexible enough to support evolution and how to evaluate and select a software architecture that meets a particular blend of quality attributes. Together this ensures that a software system is based on a software architecture that fits the current quality requirements and that is flexible in the right places so that it is able to evolve gracefully.

Software architecture design as an engineering field has evolved greatly during the last 15 years, which is evident by the number of methods, styles, patterns, and guidelines available for its practitioners in industry. This paper takes a closer look at the purposes behind this field to reveal the level of discrepancy in pursued purposes between industrial practitioners and published methods for software architecture design. In our research surveys of architecture design methods and of purposes at a number of industrial practitioners resulted in two sets of purposes which were eventually compared and the level of discrepancy identified.
Mjukvarudesign är ett område inom mjukvaruindustrin som utvecklats omfattande under de senaste 15 åren, vilket synliggjorts av de nya metoder, designstilar, designmönster och paradigmer som gjorts tillgängliga för mjukvaruutvecklare idag. Den här uppsatsen gör en djupgranskning av syftena bakom detta arbetsområde för att upptäcka eventuella skillnader mellan de syften som framhålls av befintliga arkitekturmetoder och de syften som åtsträvas av utövare inom mjukvaruindustrin.

In the past years, Software Architecture has attracted increased attention by academia and industry as the unifying concept to structure the design of complex systems. One particular research area deals with the possibility of reconfiguring architectures to adapt the systems they describe to new requirements. Reconfiguration amounts to adding and removing components and connections, and may have to occur without stopping the execution of the system being reconfigured. This work contributes to the formal description of such a process. Taking as a premise that a single formalism hardly ever satisfies all requirements in every situation, we present three approaches, each one with its own assumptions about the systems it can be applied to and with different advantages and disadvantages. Each approach is based on work of other researchers and has the aesthetic concern of changing as little as possible the original formalism, keeping its spirit. The first approach shows how a given reconfiguration can be specified in the same manner as the system it is applied to and in a way to be efficiently executed. The second approach explores the Chemical Abstract Machine, a formalism for rewriting multisets of terms, to describe architectures, computations, and reconfigurations in a uniform way. The last approach uses a UNITY-like parallel programming design language to describe computations, represents architectures by diagrams in the sense of Category Theory, and specifies reconfigurations by graph transformation rules.
Association for Computing Machinery PRAXIS XXI 2/2.1/MAT/46/94 Fundação Calouste Gulbenkian PRAXIS XXI PCEX/P/MAT/46/96 PRAXIS XXI 2/2.1/ TIT/1662/95

Graphingwiki extends the wikiengine MoinMoin by providing tools for visualizing the interconnections between the wiki pages. The extension has been used for collaborative dependency mapping. Graphingwiki can be considered a legacy system, because there is no documentation available. This thesis focuses on applied software archeology to gain understanding on the implementation in order to support decision-making as regards to its further development. An overview of the system was mapped by using code execution tracing and by reading the code manually. Performance of the Graphingwiki graph generation process and the MoinMoin user creation and authentication methods were analyzed. The results show that the undermining factor of Graphingwiki’s performance was bitmap caching of the generated graphs and, in contrast, the user creation and authentication methods were both usable and extendable. In all these aspects, there is room for improvement. The results demonstrated that by bypassing the bitmap caching, the server response time could be improved up to 90%. The password complexity requirements of MoinMoin should be updated to conform to the OWASP guidelines. Further research is recommended to solve the needs of active users and to implement the graphing process more efficiently
Graphingwiki laajentaa MoinMoin-wikiohjelmistoa tarjoamalla työkalut wikisivuston yhteyksien visualisoimiseen. Sitä on käytetty riippuvuuksien kartoitukseen yhteistyömenetelmissä. Graphingwiki voidaan katsoa ”legacy”-järjestelmäksi, koska dokumentaatiota ei ole saatavilla. Tämän työn ensisijainen fokus on sovellettussa ohjelmistoarkeologiassa nykyisen implementaation ymmärtämiseksi tukemaan päätöksentekoa sen suhteen, kuinka jatkokehitystä tulisi lähestyä. Järjestelmän yleisnäkymä kartoitettiin käyttämällä lähdekoodin suorituksen jäljitystä ja lukien koodia manuaalisesti. Graphingwikin graafigeneroinnin suorituskyky ja MoinMoinin käyttäjän luomis- sekä autentikaatiomenetelmät analysoitiin. Tulokset osoittavat, että Graphingwikin suorituskykyä heikentävä tekijä on generoitujen graafikuvien tallentaminen välimuistiin, mutta MoinMoinin käyttäjän luomis- ja autentikaatiomenetelmät ovat sekä käyttökelpoisia ja laajennettavia. Kaikilta näiltä osa-alueilta löytyi parannettavaa. Näiden tuloksien perusteella tiedetään, että ohittamalla generoitujen kuvien tallentaminen välimuistiin serverin vasteaikaa voitaisiin parantaa jopa 90%. MoinMoinin salasanojen vaatimukset olisi hyvä päivittää vastaamaan OWASP:n suosituksia. Jatkotutkimus olisi suositeltavaa nykyisten käyttäjien tarpeiden selvittämiseksi ja visualisoinnin tehokkaammaksi toteuttamiseksi

Software Architecture is a high level description of a software intensive system that enables architects to have a better intellectual control over the complete system. It is also used as a communication vehicle among the various system stakeholders. Variability in software-intensive systems is the ability of a software artefact (e.g., a system, subsystem, or component) to be extended, customised, or configured for deployment in a specific context. Although variability in software architecture is recognised as a challenge in multiple domains, there has been no formal consensus on how variability should be captured or represented. In this research, we addressed the problem of representing variability in software architecture through a three phase approach. First, we examined existing literature using the Systematic Literature Review (SLR) methodology, which helped us identify the gaps and challenges within the current body of knowledge. Equipped with the findings from the SLR, a set of design principles have been formulated that are used to introduce variability management capabilities to an existing Architecture Description Language (ADL). The chosen ADL was developed within our research group (ALI) and to which we have had complete access. Finally, we evaluated the new version of the ADL produced using two distinct case studies: one from the Information Systems domain, an Asset Management System (AMS); and another from the embedded systems domain, a Wheel Brake System (WBS). This thesis presents the main findings from the three phases of the research work, including a comprehensive study of the state-of-the-art; the complete specification of an ADL that is focused on managing variability; and the lessons learnt from the evaluation work of two distinct real-life case studies.

Thesis (MScEng)--University of Stellenbosch, 2004.
ENGLISH ABSTRACT: The high pace of technological advancement enables the realisation of ever more advanced mobile communications standards with more functionality than simple voice communications. The hardware that is used to implement the radio sections of these systems generally require long design cycles, much longer than the design cycles of the other components of a communications system. Another problem is that, once new communications standards are introduced, the current hardware platforms used in the terminal equipment becomes obsolete because they can generally not be used with the new standards. This has serious cost implications for both the service provider and the consumer, because both parties have to acquire new equipment to be able to use the new standards. An elegant solution to the above issues is to use software-defined radio sections to replace the hardware radio components. New communications standards can then be supported by simply loading new software onto the equipment, provided the maximum processing capacity of the processor(s) that the software runs on can accommodate the bandwidth requirements of that specific standard. This thesis investigates the ideas behind software defined radio and also describes the design and implementation of a software architecture that can be used to implement software defined radios on general-purpose platforms such as personal computers.
AFRIKAANSE OPSOMMING: Die hoë tempo van tegnologiese vordering maak dit moontlik om baie gevorderde mobiele kommunikasie standaarde te implementeer wat meer funksionaliteit bied as blote spraakkommunikasie. Die hardeware wat gebruik word om die radios van sulke stelsels te implementeer neem gewoonlik langer om te ontwikkel as die ander komponente van die stelsels. Die ander probleem is dat hierdie hardeware gewoonlik nie hergebruik kan word wanneer nuwe kommunikasie standaarde in gebruik geneem word nie omdat die standaarde nie versoenbaar is nie. Dit het tot gevolg dat beide die verbruiker en die diensverskaffer groot bedrae geld moet spandeer om die nuwe tegnologie te kan gebruik. 'n Elegante oplossing vir hierdie probleme is om gebruik te maak van radios waarvan die funksionaliteit in sagteware gedefiniëer word. Nuwe kommunikasie standaarde kan dan gebruik word deur slegs die nodige sagteware op die toerusting te laai, solank die verwerkingskapasiteit van die mikroverwerkers in die stelsel die benodigde bandwydte kan akkommodeer. Hierdie tesis ondersoek die konsepte van sagteware-gedefiniëerde radio en beskryf die ontwerp en implementering van 'n sagteware argitektuur vir die implementering van sagteware-gedefiniëerde radios op veeldoelige platforms soos persoonlike rekenaars.

Thesis (Ph. D. in Design and Computation)--Massachusetts Institute of Technology, Dept. of Architecture, 2012.
Cataloged from PDF version of thesis.
Includes bibliographical references (p. 365-370).
The resent shift of attention in the architectural discourse towards issues of ecological design, coupled with the undeniable role of computation, has already cast a new operative role to the notion of environment. Instead of being the passive, conceptualized or historicized context of an architectural object, environment is quite literally becoming the object of design itself. We are moving away from the imposed-preconceived Cartesian object which negotiates through its boundaries its presence within its immediate context. The discipline is already considering an architecture in which architectural form is only an instance of a designed environment. In many respects, this new understanding of environment aspires to be actively designed as a closed system of constant transformation, an autonomous milieu of exchange at all scales and all levels between substances, properties or qualities. The object of investigation in Software Tectonics is how technologies of design and construction allow newly forming propositions about the role of environment in the discipline to become operational tactics in the design practice. SOFTWARE TECTONICS proposes 3 design research projects. VSpace is a computer drawing application for designers. Unlike traditional CAD systems that work primarily by representing boundaries (B-reps), VSpace derives form by the representation and direct manipulation of properties (P-reps) in space. Boundaries and Properties here are considered simultaneously in the same design environment. Castit is a multi axis, Computer Numerically Controlled device that prints 3D objects by dynamically mixing at least two distinct but chemically compatible materials. Dynamic mixing allows for gradient transitions between two or more materials, resulting in objects with anisotropic material properties. CHUNK aims to eliminate a joint as a third mediating member between two building elements with an area of gradient transition. Conceived as a "dynamic insulation" architectural skin, this building technology project challenges the multi-trade and multi-component tectonics of dominant late-industrial building manufacture.
by Alexandros Tsamis.
Ph.D.in Design and Computation

Context. Agile Software Development has provided a new concept of Software Development based in adaptation to changes, quick decisions, low high-level design and frequent deliveries. However, this approach ignores the value that Software Architecture provides in the long term for increasing the speed in delivery working software, which may have catastrophic consequences in the long term. Objectives. In this study, the combination of these two philosophies of Software Development is investigated. Firstly, the concept of Software Architecture in Agile Projects; then, the major challenges faced concerning Software Architecture in Agile Projects, the practices and approaches that can be used to overcome these challenges and the effects that these practices may cause on the project. Methods. The research methodologies used in this study are Systematic Literature Review for gathering the highest amount possible of contributions available in the Literature at this respect, and also the conduction of Semi-Structured Interviews with Agile Practitioners, in order to obtain empirical knowledge on the problem and support or deny the SLR findings. Results. The results of the Thesis are a unified description of the concept of Software Architecture in Agile Projects, and a collection of challenges found in agile projects, practices that overcome them and a relation of effects observed. Considering the most frequent practices/approaches followed and the empirical support, it is enabled a discussion on how to combine Software Architecture and Agile Projects. Conclusions. The main conclusion is that there is not a definite solution to this question; this is due to the relevance of the context (team, project, customer, etc.) that recommends the evaluation of each situation before deciding the best way to proceed. However, there are common trends on the best-recommended practices to integrate these two concepts. Finally, it is required more empirical work on the issue, the conduction of controlled experiments that allows to quantify the success or failure of the practices implemented would be most helpful in order to create a body of knowledge that enables the application of certain practices under certain conditions.

In this thesis, we study evolution of software architecture and investigate ways to support this evolution.     The central theme of the thesis is how to analyze software evolvability, i.e., a system’s ability to easily accommodate changes. We focus on two main aspects: (i) what software characteristics are necessary for an evolvable software system; and (ii) how to assess evolvability of long-lived proprietary systems in a systematic manner. A secondary focus is to investigate how evolvability is addressed in open source software evolution. We have performed a systematic review of architecture evolution research, and proposed a software evolvability model, in which subcharacteristics of software evolvability and corresponding measuring attributes are identified. Based on this model, we have proposed the softwarearchitectureevolvabilityanalysis (AREA) process which provides repeatable techniques for supporting software architecture evolution: a)                  Qualitative evolvability analysis method that focuses on improving the capability of being able to understand and analyze systematically the impact of change stimuli on software architecture evolution; b)                  Quantitative evolvability analysis method that provides quantifications of stakeholders’ evolvability concerns and potential architectural solutions’ impacts on evolvability. These techniques have been validated in industrial settings of different domains, and can be used as an integral part of software development and evolution process. This is to ensure that the implications of the potential improvement strategies and evolution path of software architectures are analyzed with respect to the evolvability subcharacteristics. As a supplementary research contribution, we have conducted a systematic review of the existing studies in open source software (OSS) evolution, and performed a comprehensive analysis which describes how software evolvability is addressed during the development and evolution of OSS, and identified challenges and future research directions in OSS evolution.

L' architettura software è emersa come una importante tematica, nel campo del software engineering, per gestire la complessità relativa allo sviluppo e manutenzione di grandi sistemi software. L' idea chiave di questa tesi è che non c'è alcuna soluzione miracolosa nell' ambito del software engineering ma ogni tecnica ha i suoi vantaggi e svantaggi; di conseguenza, la bontà di un determinato metodo varia in base alle caratteristiche del contesto di applicazione. Un famoso proverbio dice: 1)un cattivo artigiano incolpa i suoi strumenti, 2) il peggior artigiano sceglie lo strumento sbagliato e poi da colpa allo strumento, 3) un buon artigiano sceglie ed usa gli strumenti in maniera opportuna. Mentre la comunità del software engineering si è occupata prevalentemente di offrire sempre nuovi metodi il cui utilizzo è supposto dare dei risultati migliori dei precedenti, c'è un vuoto nell' assistere l'architetto del sistema software nel selezionare o mettere a punto il giusto metodo. In questo contesto, la presente tesi offre un insieme di strumenti per la progettazione dell' architettura software, dal quale l' architetto di sistema è agevolato a selezione (e mettere appunto) il miglior strumento da utilizzare in base alle peculiarità del contesto di applicazione. Progettare una architettura software è un' attività molto complicata e involve differente tipologie di attività; la presente tesi riguarda le seguenti attività: metodi di progettazione dell' architettura software; tecniche decisionali per giungere a compromessi durane la progettazione dell' architettura software; strategie per applicare studi empirici sui metodi di progettazione architetturale; strategie di documentazioni delle decisioni progettuali
Software architecture has emerged as an important field of software engineering for managing the realm of large-system development and maintenance. The main intent of software architecture is to provide intellectual control over a sophisticated system enormous complexity. The key idea of this dissertation is that there is no silver bullet in software engineering, each method has pros and cons; the goodness of a method (tool, technique, etc.) varies based on the peculiarities of the application context. According to a famous idiom: i) a poor craftsman blames his tool, ii) a really bad craftsman chooses the wrong tool for the job and then he blames the tool, iii) a good craftsman chooses and uses the tool well. While the software engineering community has been mainly focused on providing new methods, which usage are aimed/supposed to provide better results than older methods, there is a lack in helping the software practitioners in selecting/adapting the available tools. Hence, in this view, the contribution of the present dissertation, instead of being a new method for architectural design, which would have been easily forgotten in a bookcase, is a characterization of the existing methods. In other words, this dissertation provides a toolbox for software architecture design, from which software architects can select the best method to apply, according to the application context. In this dissertation, the available architectural methods have been characterized by means of empirical studies. Unfortunately, the application of empirical methods on software architecture includes some troubles. A contribution of the present dissertation is a characterization of the available empirical methods by exposing their levels of challenges that researchers have to face when applying empiricism to software architecture. Such a proposed characterization should help to increase both the number and validity of software architecture empirical studies by allowing researchers to select the most suitable empirical method(s) to apply (i.e. the one with minor challenges), based on the application contexts (e.g. available software applications, architects, reviewers). However, in our view, in order to provide high levels of conclusion and internal validity, empirical methods for software architecture should be oriented to take advantage of both quantitative and qualitative data. Moreover, based on the results from two experiments, the challenges, in conducting evidence-based software architecture investigations, might 1) highly influence the results of the empirical studies, and 2) be faced by empiricistsâ cleverness. Architecting software system is a complex job and it encompasses several activities; this dissertation focuses on the following families of activities: software architecture design, resolving architectural tradeoffs, documenting design decisions, and enacting empirical studies on software architecture (as just described). Regarding the resolution of architectural tradeoffs, based on our review of already proposed decision making techniques, we realized that no one of the available decision-making technique can be considered in general better than another; each technique has intrinsically its own level of complexity and proneness to specific problems. Since we cannot decide in advance what degree of complexity of modeling is sufficient, instead of proceeding by trial and error, we offered guidelines on which complexity to emphasize for avoiding specific problem(s). Our key idea is to expose and organize in a useful way, namely by a characterization schema, in what extent each decision-making technique is prone to specific problems. In this way, the level of proneness of specific technique to specific problems becomes a quality attribute of the decision-making technique. Furthermore, we situated in the proposed characterization schema eighteen different decision-making techniques already proposed by the literature in the domains of architecture design, COTS selection, and release planning. Such localization validates the completeness of the proposed characterization schema, and it provides a useful reference for analyzing the state of the art Regarding software architecture design, this dissertation tried to answer to following question: " Do actual software architecture design methods meet architects needs?" To do so, we provide a characterization of the available methods by defining nine categories of software architectsâ needs, proposing an ordinal scale for evaluating the degree to which a given software architecture design method meets the needs, and then applying this to a set of software architecture design methods. Based on results from the present study, we argue that there are two opposite but valid answers to the aforementioned question: a) Yes, they do. In fact, we showed that one or more software architecture design methods are able to meet each individual architect needs that we considered. b) No, they do not. In fact, we showed that there is no software architecture design method that is able to meet any tuple of seven or more needs, which means that there is still some work to do to improve software architecture design methods to actually help architects. In order to provide directions for software architecture design method improvement, we presented couples of needs, and triplets of needs that actual software architecture design methods are unable to meet. Moreover, an architect can use such characterization to choose the software architecture design method which better meets his needs. Regarding design decision documentation, we conducted a controlled experiment for analyzing the impact of documenting design decisions rationale on effectiveness and efficiency of individual/team decision-making in presence of requirement changes. Main results show that, for both individual and team-based decision-making, effectiveness significantly improves, while efficiency remains unaltered, when decision-makers are allowed to use, rather not use, the proposed design rationale documentation technique. Being sure that documenting design-decisions rationale does help, we argued why it is not used in practice and what we can do to facilitate its usage. Older design decisions rationale documentation methods aimed at maximizing the consumer (documentation reader) benefits by forcing the producer (documentation writer) to document all the potential useful information; they eventually ran into too many inhibitors to be used in practice. In this dissertation we propose a value-based approach for documenting the reasons behind design decision, which is based on a priori understanding of who will benefit later on, from what set of information, and in which amount. Such a value-based approach for documenting the reasons behind design decision offers means to mitigate all the known inhibitors and it is based on the hypothesis that the set of required information depends on the purpose (use case) of the documentation. In order to validate such a hypothesis we ran an experiment in a controlled environment, employing fifty subjects, twenty-five decisions, and five different purposes (documentation use case) of the documentation. Each subjects practically used the documentation to enact all the five documentation use case(s) by providing an answer and a level of utility for each category of information in the provided documentation. Both descriptive and statistical results confirm our expectancies that the level of utility, related to the same category of information in the design decision rationale documentation, significantly changes according to the purpose of the documentation. Such result is novel and implies that the consumer of the rationale documentation requires, or not, a specific category of information according the specific purpose of the documentation. Consequently, empirical results suggest that the producer can tailor the design decision rationale documentation by including only the information required for the expected purposes of the documentation. This result demonstrates the feasibility of our proposed value-based approach for documenting the reasons behind design decision.

Quando è necessario valutare la qualità del software, è possibile prendere in considerazione diversi aspetti: ad esempio i code smell, gli architectural smell e le metriche. I code smell sono sintomi di possibili problemi a livello di codice, i quali possono essere rimossi attraverso diverse tecniche di refactoring e possono essere considerati come sintomi di problemi a livello di design. La controparte dei code smell a livello architetturale sono gli architectural smell: questi possono nascere a partire da decisioni architetturali comunemente adottate che impattano negativamente la qualità interna del software, con pesanti conseguenze sulla mantenibilità dello stesso. Per quanto riguarda code smell e metriche, sono stati sviluppati molti tool, sia di carattere commerciale che open source. Lo studio degli architectural smell ha ricevuto meno attenzione, pochi tool sono stati sviluppati per la loro rilevazione. Nel corso della mia tesi, ho concentrato l’attenzione sulla rilevazione e rimozione degli smell architetturali; inoltre mi sono occupato della definizione di un nuovo indice di qualità. Ho sviluppato un tool per la rilevazione di architectural smell, in particolare per quelli che ho definito instability architectural smell. Quesi smell impattano la metrica che riguarda l’instabilità, cioè l’impegno necessario per modificare un package senza influenzare altri package all’interno dell’applicazione, l’evoluzione del software stesso e la sua mantenibilità. Ho identificato sei architectural smell: Unstable Dependency, Cross Package Dependency, Hub Like Dependency, Cyclic Dependency, Multiple Architectural Smell and Specification-Implementation Violation. Lo smell chiamato Implicit Cross Package Dependency viene rilevato a livello di file usando la storia dello sviluppo software, mentre gli altri sono rilevati sia a livello di classe che a livello di package. Il tool, di nome Arcan, rileva tutti gli smell citati. Sono interessato alla rilevazione di architectural smell e al loro impatto sulla qualità del sistema attraverso l’uso della storia dello sviluppo software. Ho studiato alcune tecniche per estrarre regole dalla presenza di architectural smell in modo da prevedere possibili problemi futuri. Ho applicato algoritmi di apprendimento automatico sui dati della storia dello sviluppo di molti progetti open source. Quando i processi che portano alla definizione del design e dell’architettura sono compromessi dall’adozione di decisioni precarie o frettolose, l’architettura è spesso soggetta a molti problemi e anomalie: queste possono portare a guasti e fallimenti software oppure al tracollo della qualità, come per esempio una progressiva erosione dell’architettura. I sistemi software sono soggetti all’erosione nel tempo quando evolvono portando con sé un’architettura e un’applicazione degradata; la sfida di mantenere l’architettura definita in fase di progettazione allineata con il codice vero e proprio è ancora più ardua quando gli ingegneri software devono confrontarsi con l’obsolescenza e la manutenzione del software. Alcuni tool offrono tipologie di Indice di Qualità, come il Technical Debt, che propone una valutazione della qualità generale del software sotto analisi. Il termine Technical Debt Index(TDI) fa riferimento a tutti i tipi di indice di qualità calcolati dai tool. Nella maggior parte dei casi, gli indici disponibili non offrono un’immediata utilità nella valutazione di singoli progetti. Questi indici sono invece particolarmente utili quando un solo team si trova a dover valutare un intero portfolio applicativo e classificare nuovi progetti rispetto progetti più vecchi/già esistenti. Ho lavorato alla definizione di un nuovo TD index sfruttando il tool Arcan, concentrandomi sulla valutazione della severità degli architectural smell dove la severità misura l’impatto negativo di un singolo smell sul progetto.
When it is necessary to evaluate software quality, it is possible to consider different features: such as code smells, architectural smells and metrics. Code smells are symptoms of possible problems at code level that can be removed through different refactoring techniques and can be used as surface indicators of design problems. Instead, architectural smells can be seen as their counterpart at the architecture level. Architectural smells can derive from commonly used architectural decisions, intentional or not, that negatively impact internal software quality with large effects on software maintainability. If identified in a system, they are usually considered more critical than code smells, due to their effect on maintainability issues. For what concerns code smells and metrics, many tools have been developed, both open source and commercial. Architectural smells (AS) received less attention, even if some tools have been developed. During my thesis, I focused my attention on architectural smells detection, architectural smell refactoring and a definition of a new quality index. I have developed an architectural smells detection tool with a focus on the detection of architectural smells, that I call instability architectural smells. The instability architectural smells have an impact on the Instability metric, that it is the effort to change a package without impact other packages within the application, software evolution and maintainability. I have identified six architectural smells: Unstable Dependency, Implicit Cross Package Dependency, Hub-Like Dependency, Cyclic Dependency, Multiple Architectural Smell and Specification-Implementation Violation. The Implicit Cross Package Dependency is detected at file level using the development history and the others are detected both at class and/or package level. The tool, called Arcan, detects all these smells. I have developed Arcan through an evaluation of different dependency issues. I also worked on the prediction of architectural smells and their impact on system’s quality using the development history. I studied techniques to spot rules among architectural smells to forecast possible problems in the future, by applying machine learning algorithms on the history data of several open source projects. When that architecture and design process are compromised by poor or hasted design choices, the architecture is often subject to different architectural problems or anomalies, that can lead to software faults, failures or quality downfalls such as a progressive architecture erosion. Systems erode over time when they evolve bringing architectural erosion and degradation of applications, and the challenge to keep the intended architecture aligned with code is still hard when software engineers must deal with obsolescence and maintenance. In order to combat obsolescence and rigidity of designs, the metaphor of Technical Debt (TD) sign debt) introduced by Cunningham to explain the causes and need of refactoring, covers an important role for software maintenance. Some tools offer some kind of Technical Quality Index, e.g., Technical Debt Index, that offers an evaluation of the overall quality of an analyzed project.. In most cases, the available Indexes are not directly useful when evaluating a single project. These Indexes are in particular useful on a relative scale; in the case a single team evaluates an entire portfolio of applications and to rank new projects with respect to the old/existing ones. In this context, I worked on the definition of a new TD index through Arcan, with a focus on architectural smell detection and the severity evaluation of each architectural smell (i.e., severity measures the negative impact on the project), and I experimented this new index on a large dataset of projects.

In recent years studies have been conducted which suggest that taking an architecture first approach to managing large software projects can reduce a significant amount of the uncertainty present in project estimates. As the project progresses, more concrete information is known about the planned system and less risk is present. However, the rate at which risk is alleviated varies across the life-cycle. Research suggests that there exists a significant drop off in risk when the architecture is developed. Software risk assessment techniques have been developed which attempt to quantify the amount of risk that varying uncertainties convey to a software project. These techniques can be applied to architecture specific issues to show that in many cases, conducting an architecture centric approach to development will remove more risk than the cost of developing the architecture. By committing to developing the architecture prior to the formal estimation process, specific risks can be more tightly bounded, or even removed from the project. The premise presented here is that through the process of architecture-centric management, it is possible to remove substantial risk from the project. This decrease in risk exceeds that at other phases of the life-cycle, especially in comparison of the effort involved. Notably, at architecture, a sufficient amount knowledge is gained by which effort estimations may be tightly bounded, yet the project is early enough in the life-cycle for proper planning and scheduling. Thus, risk is mitigated through the increase in knowledge and the ability to maintain options at an early point. Further, architecture development and evaluation has been shown to incorporate quality factors normally insufficiently considered in the system design. The approach taken here is to consider specific knowledge gained through the architecting process and how this is reflected in parametric effort estimation models. This added knowledge is directly reflected in risk reduction. Drawing on experience of architecture researchers as well as project managers employing this approach, this thesis considers what benefits to the software development process are gained by taking this approach. Noting a strong reluctance of owners to incorporate solid software engineering practices, the thesis concludes with an outline for an experiment which goes about proving the reduction in risk at architecture exceeds the cost of that development.
Master of Science

Complex modern software is often built using existing application frameworks and middleware frameworks. These frameworks provide useful common services, while simultaneously imposing architectural rules and constraints. Existing software architecture evaluation methods do not explicitly consider the implications of these frameworks for software architecture. This research extends scenario-based architecture evaluation methods by incorporating framework-related information into different evaluation activities. I propose four techniques which target four different activities within a scenario-based architecture evaluation method. 1) Scenario development: A new technique was designed aiming to extract general scenarios and tactics from framework-related architectural patterns. The technique is intended to complement the current scenario development process. The feasibility of the technique was validated through a case study. Significant improvements of scenario quality were observed in a controlled experiment conducted by another colleague. 2) Architecture representation: A new metrics-driven technique was created to reconstruct software architecture in a just-in-time fashion. This technique was validated in a case study. This approach has significantly improved the efficiency of architecture representation in a complex environment. 3) Attribute specific analysis (performance only): A model-driven approach to performance measurement was applied by decoupling framework-specific information from performance testing requirements. This technique was validated on two platforms (J2EE and Web Services) through a number of case studies. This technique leads to the benchmark producing more representative measures of the eventual application. It reduces the complexity behind the load testing suite and framework-specific performance data collecting utilities. 4) Trade-off and sensitivity analysis: A new technique was designed seeking to improve the Analytical Hierarchical Process (AHP) for trade-off and sensitivity analysis during a framework selection process. This approach was validated in a case study using data from a commercial project. The approach can identify 1) trade-offs implied by an architecture alternative, along with the magnitude of these trade-offs. 2) the most critical decisions in the overall decision process 3) the sensitivity of the final decision and its capability for handling quality attribute priority changes.

This thesis describes how sustainable development definitions can be transposed to the software architecture environment for the industrial software system domain. In a case study, sustainable development concerns from three companies are investigated for their influence on the dimensions of sustainable development: economical, environmental, and social sustainability. Classifying the case study’s concerns, in the thesis’s Software Engineering taxonomy, shows that the software development concerns are in majority and the software architecture concerns surprisingly few. The economical sustainability concerns dominate followed by social sustainability concerns, including both concerns successfully met and concerns to be met.

Sustainable industrial software system development is in the thesis defined as: “Sustainable industrial software system development meets current stakeholders’ needs without compromising the software development organization’s ability to meet the needs of future stakeholders”. Understanding current and future stakeholders concerns is necessary for the formulation of sustainability goals and metrics. Clarifying the interrelationships among stakeholders’ concerns’ impact on business goals and software qualities, in the thesis’s Influencing Factors method, proves to help stakeholders understand their future needs.

Trust is found to be critical for sustainable development. For the establishing of trust between system and system users, the usability quality is vital. To implement usability support in the architecture in the early design phase, reusable architectural responsibilities are created. The reusable architectural responsibilities are integrated into an experience factory and used by the product line system architects, resulting in a return of investment of 25:2.

Pasas- Analyzing the enterprise-, system-, and software architecture impact of stakeholders’ concerns for profitable industrial software systems

Many software development projects start with an existing code base that has to be tightly integrated into a new system. In order to make a robust system that will achieve the desired business goals, developers must be able to understand the architecture of the old code base and its rationale. This thesis presents a lightweight approach for the recovery of software architecture. The main goal of the approach is to provide an efficient way for architecture recovery that works on small to mid-sized software systems, and gives a useful starting point on large ones. The emphasis of the process is on the use of well established development techniques and tools, in order to minimize adoption costs and maximize the return on investment.

For a long time radio devices have been constructed in hardware with a fixed functionality. This way of constructing radio devices is starting to change with the concept of Software Defined Radio (SDR) evolving. The SDR concept leads to more flexible and long lasting radio devices. In order to make the radio software more standardized and portable, the U.S. military has defined the Software Communication Architecture (SCA). Internal communication within the SCA is done by CORBA, which limit waveforms to be only distributed over CORBA-capable hardware. The U.S. military has defined the Modem Hardware Abstraction Layer(MHAL) to enable distribution over devices not supporting CORBA. This thesis presents an implementation of MHAL and an underlying transport mechanism based on Ethernet. The implementation is done for the OSSIE package. The implementation is evaluated both in terms of real-time and throughput performance. The results show that MHAL achieves good performance, in comparison to CORBA, and can greatly be used to distribute waveforms over both CORBA and non-CORBA capable devices.

Development of software-intensive systems such as embedded systems for telecommunications, avionics and automotives occurs under severe quality, schedule and budget constraints. As the size and complexity of software-intensive systems increase dramatically, the problems originating from the design and specification of the system architecture becomes increasingly significant. Architecture-based development approaches promise to improve the efficiency of software-intensive system development processes by reducing costs and time, while increasing quality. This paradox is partially explained by the fact that the system architecture abstracts away unnecessary details, so that developers can concentrate both on the system as a whole, and on its individual pieces, whether it's the components, the components' interfaces, or connections among components. The use of architecture description languages (ADLs) provides an important basis for verification since it describes how the system should behave, in a high level view and in a form where automated tests can be generated. Analysis and testing based on architecture specifications allow detection of problems and faults early in the development process, even before the implementation phase, thereby reducing a significant amount of costs and time. Furthermore, tests derived from the architecture specification can later be applied to the implementation to see the conformance of the implementation with respect to the specification. This thesis extends the knowledge base in the area of architecture-based verification. In this thesis report, an airplane control system is specified using the Architecture Analysis and Description Language (AADL). This specification will serve as a starting point of a system development process where developed architecture-based verification algorithms are applied.

Pattern matching approaches in reverse engineering aim to incorporate domain knowledge and system documentation in the software architecture extraction process, hence provide a user/tool collaborative environment for architectural design recovery. This thesis presents a model and an environment for recovering the high level design of legacy software systems based on user defined architectural patterns and graph matching techniques. In the proposed model, a high-level view of a software system in terms of the system components and their interactions is represented as a query, using a description language. A query is mapped onto a pattern-graph, where a module and its interactions with other modules are represented as a group of graph-nodes and a group of graph-edges, respectively. Interaction constraints can be modeled by the description language as a part of the query. Such a pattern-graph is applied against an entity-relation graph that represents the information extracted from the source code of the software system. An approximate graph matching process performs a series of graph edit operations (i. e. , node/edge insertion/deletion) on the pattern-graph and uses a ranking mechanism based on data mining association to obtain a sub-optimal solution. The obtained solution corresponds to an extracted architecture that complies with the given query. An interactive prototype toolkit implemented as part of this thesis provides an environment for architecture recovery in two levels. First the system is decomposed into a number of subsystems of files. Second each subsystem can be decomposed into a number of modules of functions, datatypes, and variables.

Thesis (M.S. in Computer Science)--Naval Postgraduate School, March 2008.
Thesis Advisor(s): Michael, James B. ; Shing, Man-Tak. "March 2008." Description based on title screen as viewed on May 1, 2008. Includes bibliographical references (p. 75). Also available in print.

Variability (the ability of a software system or software artifact to be adapted for use in a specific context) is reflected in and facilitated through the software architecture. The Second International Workshop on Variability in Software Architecture (VARSA) was held in conjunction with the Joint 10th Working IEEE/IFIP Conference on Software Architecture & 6th European Conference on Software Architecture 2012 in Helsinki, Finland. The workshop aimed at exploring current and emerging methods, languages, notations, technologies and tools to model, implement, and manage variability in the software architecture. It featured one industrial talk, five research paper presentations, and three working group discussions. Working groups discussed topics that emerged during the workshop. This report summarizes the themes of the workshop and presents the results of the working group discussions.

University of Central Florida College of Engineering Thesis
The problem of building large, reliable software systems in a controlled, cost effective way, the so-called software crisis problem, is one of computer science's great challenges. From the very outset of computing as science, software reuse has been touted as a means to overcome the software crisis issue
Ph.D.
Doctorate;
School of Electrical Engineering and Computer Science
Engineering and Computer Science
Electrical Engineering and Computer Science
221 p.
xix, 221 leaves, bound : ill. ; 28 cm.

COORDENAÇÃO DE APERFEIÇOAMENTO DO PESSOAL DE ENSINO SUPERIOR
A engenharia de software baseada em componentes é uma abordagem que prevê a reutilização de artefatos de software na geração de um conjunto de aplicações. Ao desenvolver aplicações com esta abordagem, é preciso reunir ou compor componentes de software já existentes. Após compor estas unidades, é necessário coordenar as interdependências estabelecidas entre elas para adequar a aplicação em desenvolvimento à resolução do problema. Esta dissertação propõe uma arquitetura de software que separa e estrutura os conceitos de coordenação, composição e componentes de software em camadas arquiteturais. A partir desta estrutura, espera-se que modificações específicas em construções de uma camada tenham o mínimo de influência sobre as demais. ACCA (Arquitetura para a Coordenação e a Composição de Artefatos de Software) deve ser entendida como uma estrutura conceitual utilizada para organizar o desenvolvimento de software baseado em componentes. Além disto, são apresentados um framework para ilustrar a realização da camada de composição de ACCA, o processo de reificação de ACCA e um processo de desenvolvimento de software utilizando a abordagem proposta.
Component Based Software Engineering is an approach for reusing software artifacts when developing applications. In order to develop solutions using this approach, it is necessary to compose software using components that have already been developed. After putting those pieces together, we need to coordinate the interdependencies established among those compositions to fulfill the requirements, needed to resolve a problem. This dissertation proposes a software architecture that separates and structures the concepts of coordination, composition and software components in different architectural layers. Using this approach, we expect that specific modifications in layer constructions have the minimum impact on the others layers. ACCA (Architecture for Coordination and Composition of software Artifacts) must be understood as a conceptual structure that is used to organize component based software development. It also presents a composition framework, the reification process for ACCA and a software development process organized using this approach.

ITC/USA 2008 Conference Proceedings / The Forty-Fourth Annual International Telemetering Conference and Technical Exhibition / October 27-30, 2008 / Town and Country Resort & Convention Center, San Diego, California
Building modern telemetry systems is fraught with challenges involving subsystem integration, the role and management of data, scalability issues, disparate technologies, concerns about cost-effectiveness and more. This article addresses today's challenges with a solution based on adopting a data-oriented architecture and relying on a standards-based, integrated high-performance middleware platform with standards-based programmable components. Key to the solution is integrating around the system information model instead of the application or technology infrastructure. A standards-based middleware infrastructure that breaks away from traditional assumptions is at the core of this approach. The article also presents successful applications of data-oriented architecture using standards-based middleware.

International Telemetering Conference Proceedings / October 28-31, 1985 / Riviera Hotel, Las Vegas, Nevada
A generic software architecture has been developed to support the typical functionality required of the host computer in a telemetry ground station system. The architecture provides sufficient flexibility to permit support of the wide spectrum of requirements typically placed on such systems, while at the same time providing a structural shell which helps to minimize the complexity of applications software. The general issues addressed by this architecture include: - The need to interface to a wide variety of telemetry front end equipments. - The need to provide a convenient consistent, and efficient operator interface to the integrated telemetry system. - The need to support a variable amount and wide range of applications specific processing. - The need to be adaptable across different sizes of host computers. - The need to be adaptable across different host computer systems. This paper defines, at a high level, the architecture that has been defined and the general data structure concepts required to make it work. It further addresses the standardized operator interface supported by the architecture and finally, summarizes the benefits that have been demonstrated to be derived through the use of this standardized approach in the development of telemetry host computer software.

Doctor en Ciencias, Mención Computación
La Arquitectura de Software juega un rol crucial en la Ingeniería de Software, permitiendo el control intelectual, la integridad conceptual, la comunicación efectiva, la administración de un conjunto relacionado de variantes de sistemas, y la reutilización de conocimiento, experiencia, diseño e implementación. Aplicar el conocimiento arquitectónico promueve la calidad, reduce los riesgos, y es esencial para alcanzar las expectativas de los interesados con resultados predecibles. El conocimiento arquitectónico actual es vasto y está en constante aumento, pero a su vez, es heterogéneo y disperso, está expresado en diferentes niveles de abstracción y rigor, y requiere de herramientas que raramente están disponibles en los ambientes de desarrollo. En la práctica, el diseño arquitectónico está limitado por las habilidades y experiencia del arquitecto y por el conocimiento que domina, y requiere de gran esfuerzo para ajustarlo y adaptarlo al escenario de desarrollo. Así, el diseño arquitectónico rara vez alcanza el nivel de calidad que es posible dado el conocimiento arquitectónico disponible. Además, el esfuerzo del arquitecto no es repetible ya que resultan embebidos en las descripciones de las arquitecturas. Aunque las técnicas de modelado están siendo usadas en Arquitectura de Software, la mayoría de los enfoques carecen de generalidad y homogeneidad, dificultando su integración y aplicación. En este trabajo, usamos megamodelado para definir un mecanismo unificado y homogéneo para capturar conocimiento arquitectónico, haciéndolo compartible, reusable, manejable por herramientas, y directamente aplicable. Definimos una interpretación formal de los conceptos principales de la disciplina en términos de artefactos de modelado. Además, cambiamos el foco de construir la descripción de la arquitectura directamente, a capturar cómo dicha descripción es creada. Para ello, definimos un lenguaje para capturar las acciones de diseño, y lo interpretamos en términos de técnicas de modelado haciendo el diseño repetible. Validamos nuestro enfoque definiendo procedimientos para guiar a la comunidad en cómo capturar conocimiento arquitectónico usando nuestra interpretación formal, aplicando estos procedimientos para capturar las técnicas de descripción y diseño del SEI, y aplicando el conocimiento capturado al diseño de la línea de productos de mallas geométricas. Nuestro trabajo realiza dos contribuciones originales. Primero, definimos un mecanismo unificado y homogéneo para capturar conocimiento arquitectónico, usando técnicas de Ingeniería Dirigida por Modelos, particularmente el enfoque de megamodelado Global Model Management, y usando semántica denotacional para la formalización. Segundo, definimos una representación de decisiones y soluciones arquitectónicas en términos de un lenguaje específico, haciéndolas descriptivas y aplicables. Así, facilitamos el cambio de foco del arquitecto haciendo el diseño arquitectónico explícito, repetible y reusable, y obteniendo descripciones de arquitectura implícitas y generables en forma automática.

Dissertação apresentada na Faculdade de Ciências e Tecnologia da Universidade Nova de Lisboa para obtenção do grau de Mestre em Engenharia Electrotécnica
This dissertation presents a software architecture called the Distributed Software Architecture for Autonomous Robots (DSAAR), which is designed to provide the fast development and prototyping of multi-robot systems. The DSAAR building blocks allow engineers to focus on the behavioural model of robots and collectives. This architecture is of special interest in domains where several human, robot, and software agents have to interact continuously. Thus, fast prototyping and reusability is a must. DSAAR tries to cope with these requirements towards an advanced solution to the n-humans and m-robots problem with a set of design good practices and development tools. This dissertation will also focus on Human-Robot Interaction, mainly on the subject of teleoperation. In teleoperation human judgement is an integral part of the process, heavily influenced by the telemetry data received from the remote environment. So the speed in which commands are given and the telemetry data is received, is of crucial importance. Using the DSAAR architecture a teleoperation approach is proposed. This approach was designed to provide all entities present in the network a shared reality, where every entity is an information source in an approach similar to the distributed blackboard. This solution was designed to accomplish a real time response, as well as, the completest perception of the robots’ surroundings. Experimental results obtained with the physical robot suggest that the system is able to guarantee a close interaction between users and robot.

La plupart des projets de développement logiciel actuel dépendent de l'utilisation des solutions existantes pour gagner du temps et réduire les coûts de développement. Pour atteindre cet objectif, les entreprises doivent tirer parti des fonctionnalités offertes par les services techniques ou les interfaces de programmation applicatives exposées par les solutions existantes. La collecte et la qualification de ces composants ou services techniques permet de les réutiliser directement ou par orchestration. L'objectif de ce travail est double. Tout d'abord, nous visons la conception d'un conteneur de capacités logicielles qui offre une vision plus large des solutions applicatives internes ou externes d'une organisation. Le deuxième objectif est de définir un modèle d'exploitation de ces profils de capacités logicielles en adéquation avec l'ingénierie des besoins et l'architecture d'entreprise, afin de combler l'écart entre les objectifs des parties prenantes et ce qui peut être fourni comme solution pratique. Cependant, pour atteindre les objectifs susmentionnés, il y a de nombreux défis à relever pour gérer la complexité de l'exploitation des profils de capacités logicielles internes ou externes, afin de sélectionner les meilleurs composants candidats pour servir d'éléments constitutifs dans un nouveau système. Parmi ces défis, on peut citer l'identification des connaissances architecturales pour l'évaluation et la réutilisation des composants techniques, ou l'alignement des besoins et des artefacts d'architecture dans un cycle d'ingénierie pour la consolidation et le raffinement des exigences, afin de faciliter la découverte et la réutilisation des solutions applicatives existantes. A cet effet, nous définissons un Framework offrant un processus de qualification qui permet de recueillir les exigences initiales utilisées pour guider le développement des applications existantes et des services techniques exposés. Le processus de qualification est4basé sur un profil de capacité d'architecture d'entreprise proposé et de son ontologie associée. Cette dernière est utile pour spécifier formellement le profil de capacité produit qui offre une qualification couvrant les aspects organisationnels, opérationnels et techniques des applications orientées services. De plus, une méthodologie d'exploitation du conteneur conçu pour agréger ces profiles est proposée avec le Framework et basée sur l'alignement du processus d'ingénierie des besoins avec une méthode de développement d'architecture. Ces derniers évoluent ensemble pour étudier la plus grande compatibilité fonctionnelle et technique des fonctionnalités souhaitées et des contraintes associées, pour répondre aux besoins des utilisateurs finaux et réutiliser efficacement les solutions qualifiées.Notre contribution vise à améliorer l'évaluation, la découverte et la réutilisation des applications et des services techniques associés. Par ailleurs, l'originalité de ce travail de recherche consiste à mettre à niveau la recherche sur la consommation et l'orchestration des services au niveau des besoins des utilisateurs finaux, afin d'accélérer et de faciliter le développement d'applications métier futures. Une implémentation du Framework ainsi qu'une étude de cas industriels sont proposés pour valider et démontrer l'efficacité de cette approche
Most of today's software development projects depend on the usage of existing solutions to save time and development cost. To achieve this goal, companies should take advantage of the features provided by services or application programming interfaces exposed by existing solutions. Collecting and qualifying IT components and services helps to reuse them directly or via orchestration. The goal of this work is twofold. First, we target the design of a software capability container that provides a broader view of an organization’s internal and external software. The second objective is to define an exploitation model of the software capability profiles in line with requirements engineering and enterprise architecture, to fill the gap between the goals of the stakeholders and what can be delivered as a practical solution. However, to achieve the above-stated objectives, there are many challenges to manage the complexity of the exploitation of internal or external’s software capability profiles, to select the best candidate components to act as a building blocks in a new system. Among those challenges, one can mention the identification of architectural artifacts for the evaluation and reuse of software components. Adding to this challenge, the alignment of requirements and architectural artifacts in engineering cycle for requirements consolidation and refinement to facilitate the discovery and reuse of existing solutions.For this purpose, we define a Framework offering a qualification process that helps to retrieve and gather initial requirements used to guide the development of existing software and related services. The qualification process is based on a proposed Enterprise Architecture Capability Profile and its associated ontology. This latter is useful to formally specify and encode the produced capability2profile that offers a qualification and covers business, operational and technical aspects for service-oriented software. Furthermore, an exploitation methodology of the designed container is proposed along with the Framework and based on the alignment of requirements engineering process with an architecture development method. These latter evolve together to investigate the highest functional and technical compatibility of the desired functionalities and related constraints, to respond to end-user’s requirements and efficiently reuse the qualified solutions.Our contribution aims to improve the evaluation, discovery, and reuse of existing software and related services. Besides, the originality of this research work consists in upgrading research on services consumption and orchestration to the level of end-users’ requirements, mapped with advanced service assets as an enabler for accelerating business application development. An implementation of the Framework along with an industrial case study are proposed to validate and demonstrate the effectiveness of this approach

Doutoramento em Ciências da Computação
When developing software for autonomous mobile robots, one has to inevitably tackle some kind of perception. Moreover, when dealing with agents that possess some level of reasoning for executing their actions, there is the need to model the environment and the robot internal state in a way that it represents the scenario in which the robot operates. Inserted in the ATRI group, part of the IEETA research unit at Aveiro University, this work uses two of the projects of the group as test bed, particularly in the scenario of robotic soccer with real robots. With the main objective of developing algorithms for sensor and information fusion that could be used e ectively on these teams, several state of the art approaches were studied, implemented and adapted to each of the robot types. Within the MSL RoboCup team CAMBADA, the main focus was the perception of ball and obstacles, with the creation of models capable of providing extended information so that the reasoning of the robot can be ever more e ective. To achieve it, several methodologies were analyzed, implemented, compared and improved. Concerning the ball, an analysis of ltering methodologies for stabilization of its position and estimation of its velocity was performed. Also, with the goal keeper in mind, work has been done to provide it with information of aerial balls. As for obstacles, a new de nition of the way they are perceived by the vision and the type of information provided was created, as well as a methodology for identifying which of the obstacles are team mates. Also, a tracking algorithm was developed, which ultimately assigned each of the obstacles a unique identi er. Associated with the improvement of the obstacles perception, a new algorithm of estimating reactive obstacle avoidance was created. In the context of the SPL RoboCup team Portuguese Team, besides the inevitable adaptation of many of the algorithms already developed for sensor and information fusion and considering that it was recently created, the objective was to create a sustainable software architecture that could be the base for future modular development. The software architecture created is based on a series of di erent processes and the means of communication among them. All processes were created or adapted for the new architecture and a base set of roles and behaviors was de ned during this work to achieve a base functional framework. In terms of perception, the main focus was to de ne a projection model and camera pose extraction that could provide information in metric coordinates. The second main objective was to adapt the CAMBADA localization algorithm to work on the NAO robots, considering all the limitations it presents when comparing to the MSL team, especially in terms of computational resources. A set of support tools were developed or improved in order to support the test and development in both teams. In general, the work developed during this thesis improved the performance of the teams during play and also the e ectiveness of the developers team when in development and test phases.
Durante o desenvolvimento de software para robôs autónomos móveis, e inevitavelmente necessário lidar com algum tipo de perceção. Al em disso, ao lidar com agentes que possuem algum tipo de raciocínio para executar as suas ações, há a necessidade de modelar o ambiente e o estado interno do robô de forma a representar o cenário onde o robô opera. Inserido no grupo ATRI, integrado na unidade de investigação IEETA da Universidade de Aveiro, este trabalho usa dois dos projetos do grupo como plataformas de teste, particularmente no cenário de futebol robótico com robôs reais. Com o principal objetivo de desenvolver algoritmos para fusão sensorial e de informação que possam ser usados eficazmente nestas equipas, v arias abordagens de estado da arte foram estudadas, implementadas e adaptadas para cada tipo de robôs. No âmbito da equipa de RoboCup MSL, CAMBADA, o principal foco foi a perceção da bola e obstáculos, com a criação de modelos capazes de providenciar informação estendida para que o raciocino do robô possa ser cada vez mais eficaz. Para o alcançar, v arias metodologias foram analisadas, implementadas, comparadas e melhoradas. Em relação a bola, foi efetuada uma análise de metodologias de filtragem para estabilização da sua posição e estimação da sua velocidade. Tendo o guarda-redes em mente, foi também realizado trabalho para providenciar informação de bolas no ar. Quanto aos obstáculos, foi criada uma nova definição para a forma como são detetados pela visão e para o tipo de informação fornecida, bem como uma metodologia para identificar quais dos obstáculos são colegas de equipa. Além disso foi desenvolvido um algoritmo de rastreamento que, no final, atribui um identicador único a cada obstáculo. Associado a melhoria na perceção dos obstáculos foi criado um novo algoritmo para realizar desvio reativo de obstáculos. No contexto da equipa de RoboCup SPL, Portuguese Team, al em da inevitável adaptação de vários dos algoritmos j a desenvolvidos para fusão sensorial e de informação, tendo em conta que foi recentemente criada, o objetivo foi criar uma arquitetura sustentável de software que possa ser a base para futuro desenvolvimento modular. A arquitetura de software criada e baseada numa série de processos diferentes e métodos de comunicação entre eles. Todos os processos foram criados ou adaptados para a nova arquitetura e um conjunto base de papeis e comportamentos foi definido para obter uma framework funcional base. Em termos de perceção, o principal foco foi a definição de um modelo de projeção e extração de pose da câmara que consiga providenciar informação em coordenadas métricas. O segundo objetivo principal era adaptar o algoritmo de localização da CAMBADA para funcionar nos robôs NAO, considerando todas as limitações apresentadas quando comparando com a equipa MSL, principalmente em termos de recursos computacionais. Um conjunto de ferramentas de suporte foram desenvolvidas ou melhoradas para auxiliar o teste e desenvolvimento em ambas as equipas. Em geral, o trabalho desenvolvido durante esta tese melhorou o desempenho da equipas durante os jogos e também a eficácia da equipa de programação durante as fases de desenvolvimento e teste.

The CubeSat pico-satellite is gaining popularity in both the educational and aerospace industries. Due to a lack of experience and constrained hardware capabilities, most of the university missions have been educational in nature. Cal Poly's project, PolySat, has gained significant experience from the launch of five CubeSats and has designed an entirely new hardware platform based on the knowledge gained from these missions. This hardware is a significant upgrade from what the previous missions used and has greatly increased the capabilities of the software, including supporting the use of the open source operating system Linux. Leveraging the previous PolySat experience, a new design approach has been followed for the development of a fault tolerant and flexible software architecture. As a result, a set of processes and custom libraries that run within Linux have been designed and implemented. Furthermore, an emphasis has been placed on fault tolerance with two features: a software watchdog and digital command signing capability. Lastly, a survey of related CubeSat projects and software fault tolerance papers has been conducted to determine that this new system is sufficient to meet the desired goals.

Contemporary software engineering practice overemphasizes the distinction of software design from software implementation, and designer (“software architect”) from implementor (“computer programmer”). In this contemporary meme, software architects are concerned with large-grained system structures, quality attributes that arise from these structures (security, availability, performance, etc.) and quality attribute tradeoff to satisfy conflicting stakeholder needs; programmers are concerned with low–level algorithms and data structures, program functionality, and with satisfying architectural intent. However, software is unique in that design and implementation are not cleanly separable. While architect and programmer may have many different design concerns, they also have many complementary and interacting concerns; their respective design practices must be well–integrated. Instead, contemporary architecture and programming practices are diverging. Architects are likely to regard programming as a routine production activity, while programmers are likely to regard architecture as a routine management activity; communication is hindered by a lack of shared vocabulary or appreciation of mutual concerns. Instead of effective integration, a gap has opened in software architecture and programming practice. The research reported here defines the architecture/program seam (“the Seam”), a region of overlap in software architecture and programming practice. The Seam emphasizes design concerns centered on achieving predictable runtime behavior. For a behavior to be predictable it must be described in a theory that must ultimately be consistent with basic theories of computation, and each such theory must have objective evidence to demonstrate that theory observations correspond to system observations. The validity of a theory will likely depend on invariants that can be expressed, and enforced, by means of theory–induced design rules. A system that satisfies the design rules of a theory is then regarded as having behavior that is predictable by construction with respect to that theory. Predictability by construction reduces uncertainty, and hence risk in design, and helps designers explain complex design decisions. The research reported here also defines prediction–enabled component technology (PECT) as a foundation technology to support the Seam, and demonstrates a prototype on industrial problems in electric grid substation control, industrial robot control, and desktop streaming audio. The prototype PECT extends a basic component technology of pure assembly (“Pin”) with theory extension points (“reasoning frameworks”) that are used to achieve predictability by construction. Reasoning frameworks for real–time performance and temporal–logic model checking have been developed, with statistical confidence intervals providing evidence of predictive quality for the former, and code–embeddable proof certificates providing evidence for the latter. Finally, the research reported here defines the Seam itself as inducing a new kind of evolutionary design problem, whose solutions require the integration of programming language theory, design theory, specialized theories of system behavior and deep systems expertise.

The purpose of this thesis is to characterize, compare and contrast four network-centric software architectures, namely Client-Server Architecture (CSA), Distributed Objects Architecture (DOA), Service-Oriented Architecture (SOA) and Peer-to-Peer Architecture (PPA) and seven associated frameworks consisting of .NET, Java EE, CORBA, DCOM, Web Services, Jini and JXTA with respect to a set of derived criteria. Network-centric systems are gaining in popularity as they have the potential to solve more complex problems than we have been able to in the past. However, with the rise of SOA, Web Services, a set of standards widely used for implementing service-oriented solutions, is being touted as the â silver bulletâ to all problems afflicting the software engineering domain with the danger of making other architectures seem obsolete. Thus, there is an urgent need to study the various architectures and frameworks in comparison to each other and understand their relative merits and demerits for building network-centric systems. The architectures studied here were selected on the basis of their fundamentality and generality. The frameworks were chosen on the basis of their popularity and representativeness to build solutions in a particular architecture. The criteria used for comparative assessment are derived from a combination of two approaches â by a close examination of the unique characteristics and requirements of network-centric systems and then by an examination of the constraints and mechanisms present in the architectures and frameworks under consideration that may contribute towards realizing the requirements of network-centric systems. Not all of the criteria are equally relevant for the architectures and frameworks. Some, when relevant, are relevant in a different sense from one architecture (or framework) to another. One of the conclusions that can be drawn from this study is that the different architectures are not completely different from each other. In fact, CSA, DOA and SOA are a natural evolution in that order and share several characteristics. At the same time, significant differences do exist, so it is clearly possible to judge/differentiate one from the other. All three architectures can coexist in a single system or system of systems. However, the advantages of each architecture become apparent only when they are used in their proper scope. At the same time, a sharp difference can be perceived between these three architectures and the peer-to-peer architecture. This is because PPA aims to solve a totally different class of problems than the other three architectures and hence has certain unique characteristics not observed in the others. Further, all of the frameworks have certain unique architectural features and mechanisms not found in the others that contribute towards achieving network-centric quality characteristics. The two broad frameworks, .NET and Java EE offer almost equivalent capabilities and features; what can be achieved in one can be achieved in the other. This thesis deals with the study of all the four architectures and their related frameworks. The criteria used, while fairly comprehensive, are not exhaustive. Variants of the fundamental architectures are not considered. However, system/software architects seeking an understanding of the tradeoffs involved in using the various architectures and frameworks and their subtle nuances should benefit considerably from this work.
Master of Science

In the software development life cycle, changes are inevitable. Designing the architecture of the software and writing the source code does not end the software life cycle. The software system evolves as changes in the environment and requirements are incorporated in the system. If these changes are not managed properly, the architecture of the software deteriorates and leads to architecture erosion. This study is an effort to address the problem of architecture erosion and to keep the software architecture live and up to date. In this study we propose a method to minimize or avoid architecture erosion. This method provides a systematic way to design the architecture of the software system. It is based on the concept of architecture vision that is the ideal representation of the architecture of the software in hand. This method treats architecture document and architecture design document as two completely different documents. Moreover this study presents an effort to establish a relationship between the implemented architecture of the system, the architecture design document and an architecture vision. The dynamic validation of the devised method shows that this method is suitable for medium to large scale projects that have several releases. All the activities of this method revolve around the efforts to keep the architecture of the software aligned with an architecture vision. The iterative nature of the method and synchronization of the implemented architecture with the architecture vision helps to detect and reduce architecture erosion. This method does not conflict with or replaces any development or management process or method (like RUP, agile, water fall etc), but exists parallel to them.
0739 229 759 - Aamir 0737 351 062 - Mustafa