Software architecture has been identified as an increasingly important part of software development. The software architecture helps the developer of a software system to define the internal structure of the system. Several methods for evaluating software architectures have been proposed in order to assist the developer in creating a software architecture that will have a potential to fulfil the requirements on the system. Many of the evaluation methods focus on evaluation of a single quality attribute. However, in an industrial system there are normally requirements on several quality aspects of the system. Therefore, an architecture evaluation method that addresses multiple quality attributes, e.g., performance, maintainability, testability, and portability, would be more beneficial. This thesis presents research towards a method for evaluation of multiple quality attributes using one software architecture evaluation method. A prototype-based evaluation method is proposed that enables evaluation of multiple quality attributes using components of a system and an approximation of its intended runtime environment. The method is applied in an industrial case study where communication components in a distributed realtime system are evaluated. The evaluation addresses performance, maintainability, and portability for three alternative components using a single set of software architecture models and a prototype framework. The prototype framework enables the evaluation of different components and component configurations in the software architecture while collecting data in an objective way. Finally, this thesis presents initial work towards incorporating evaluation of testability into the method. This is done through an investigation of how testability is interpreted by different organizational roles in a software developing organization and which measures of source code that they consider affecting testability.

Doctor of Philosophy / Department of Computing and Information Sciences / John M. Hatcliff / Software architectures—abstract interrelation models which decompose complex artifacts into modular functional units and specify the connections and relationships among them—have become an important factor in the development and maintenance of large scale, heterogeneous, information and computation systems. In system development, software architecture design has become a main starting point, and throughout the life-cycle of a system, conformance to the architecture is important to guarantee a system's integrity and consistency. For an effective use of software architectures in initial development and ongoing maintenance, the interrelation models themselves have to be clear, consistent, well structured, and—in case substantial functionality has to be added, reduced, or changed at any stage of the life cycle—flexible and manipulable. Further, enforcing the conformance of a software artifact to its architecture is a non-trivial task. Implementation units need to be identifiable and their association to the abstract constructs of the architecture has to be maintained. Finally, since software architectures can be employed at many different levels of abstraction, with some architectures describing systems that span over multiple different computing platforms, associations have to be flexible and abstractions have to be general enough to capture all parts and precise enough to be useful. An efficient and widely used way to employ software architecture in practice are middleware-based component architectures. System development within this methodology relies on the presence of a service layer called middleware which usually resides between operating system (possibly spanning over multiple operating systems on various platforms) and the application described by the architecture. The uniform set of logistic services provided by a middleware allows that communication and context requirements of the functional units, called components, can be expressed in terms of those services and therefore more shortly and concisely than without such a layer. Also, component development in the middleware context can focus on high-level functionality since the low-level logistics is provided by the middleware. While type systems have proved effective for enforcing structural constraints in programs and data structures, most architectural modeling frameworks include only weak notions of typing or rely on first-order logic constraint languages instead. Nevertheless, a consequent, adherent, use of typing can seamlessly enforce a wide range of constraints crucial for the structural integrity of architectures and the computation systems specified by them without the steep learning curve associated with first-order logic. Also, type systems scale better than first-order logic both in use and understandability/legibility as well as in computational complexity. This thesis describes component-oriented architecture modeling with CADENA and introduces the CADENA Architecture Language with Meta-modeling (CALM). CALM uses multi-level type systems to specify complex interaction models and enforce a variety of structural properties and consistency constraints relevant for the development of large-scale component-based systems. Further, CALM generalizes the notion of middleware-based architectures and uniformly captures and maintains complex interrelated architectures integrated on multiple, differing, middleware platforms. CADENA is a robust and extensible tool based on the concepts and notions of CALM that has been used to specify a number of industrial-strength component models and applied in multiple industrial research projects on model-driven development and software product lines.

No description available.

Orientador: Cecília Mary Fischer Rubira / Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação / Made available in DSpace on 2018-08-24T12:39:49Z (GMT). No. of bitstreams: 1 Esteve_AndrePetris_M.pdf: 5633446 bytes, checksum: 5874ca0a9d4e25e35c24df8d99a5a724 (MD5) Previous issue date: 2013 / Resumo: Os sistemas de software precisam evoluir para atender as necessidades das pessoas. Isso é natural, já que as pessoas, as sociedades mudam, novas necessidades surgem, conceitos alteram-se e o software deve adequar-se às mudanças. Ao passo que alterações são feitas em sistemas de softwares, eles começam a envelhecer. O envelhecimento de software é o termo dado a redução da vida útil de um software devido à natureza da complexidade de seus processos de criação, manutenção e entendimento. Conforme um software é modificado, ele tende a se tornar mais complexo. Assim, ao precisar atender a novos requisitos seu código torna-se mais complexo, tornando-se menos expressivo, isto é, menos legível e mais complicado de ser compreendido, ou simplesmente por ser tão imenso e intricado, com centenas de componentes e funcionalidades, entendê-lo torna-se uma tarefa desafiadora. A arquitetura de software é um conceito fundamental no desenvolvimento e evolução de software. E juntamente com o sistema de software, a arquitetura também sofre os efeitos do envelhecimento de software, conhecidos como ersoão e desvio arquiteturais. É de extrema importância o gerenciamento da evolução da arquitetura de sofware, uma vez que ela representa a visão geral do sistema e é fundamentalmente responsável por requisitos de qualidade, como segurança e performance. Eventualmente, manter e evoluir um sistema de software torna-se mais custoso que reescrevê-lo por completo. Atingido esse estado, o software original é abandonado e sua vida útil chega ao fim. Ele é substituído por uma nova implementação, mais moderna, que atende aos novos requisitos, mas que, eventualmente, também envelhecerá, e também será substituída por uma nova implementação. Este trabalho propõe uma solução, composta por método e apoio ferramental, de gerenciamento da evolução de um sistema de software, especialmente, de sua arquitetura, que é peça fundamental na longevidade do sistema. O método proposto nesta solução objetiva identificar precocemente problemas de envelhecimento de software relacionados à arquitetura do sistema, permitindo ao arquiteto de software atuar sobre eles, de forma a mitigar ou eliminar seus impactos sobre a arquitetura do sistema, consequentemente, prolongando a vida útil do mesmo / Abstract: Software systems must evolve so to fit people¿s needs. That is a natural process, in which people and societies change, new necessities arise and existing concepts are replaced by modern ones, thus forcing the software to fit into the new picture, adapting itself to the changes. As software systems are modified, they age. Software ageing is the term given to the diminishing of a software¿s life spawn due to the inherently complexity of its creation, maintenance and understanding processes. As it evolves, the system tends to grow more intricate, its source code tends to become less expressive as it needs to be adapted to new requirements, run with a better performance or simply it has become so immense and complex that understanding it is, by itself, a challenging task. Eventually, maintaining and supporting a software system will turn out to be even more expensive than rewriting it from scratch. From that point onwards, the original piece of software is abandoned, having its life spawn reached an end. The aged software is replaced by a new and modern implementation, one that fulfils the just placed requirements. However this brand new software piece will share the same fate as its predecessors, it will age and will eventually be replaced. This work proposes a solution, composed by method and computer-aided tools, for managing software architecture evolution, which is a fundamental piece in the system¿s longevity. The solution¿s method aims to identify software architecture ageing problems ahead of time, so their impact can be adequately mitigated or even completely avoided, thus extending the software¿s life spawn. So to allow the practical use of the method, as part of the proposed solution, a tool was implemented to automate most of the method¿s activities. Through automation, the tool is capable of reducing the human error associated to the processes execution, thus yielding high efficiency. By analyzing case studies, it is possible to verify that, when applied, the solution is capable to guide the software architect to uncover software ageing problems on the system under investigation. Through the computational aid offered by the solution, the architect is able to act upon the newly discovered issues, with undemanding time and effort, thus resolving or mitigating the problems that arise with software ageing / Mestrado / Ciência da Computação / Mestre em Ciência da Computação

[pt] Durante a manutenção de sistemas de software, os projetos arquiteturais podem se degradar através dos processos de erosão e descaracterização arquitetural. Estes processos estão usualmente entrelaçados e, consequentemente, sintomas de descaracterização arquitetural favorecem a manifestação posterior de sintomas de erosão e vice-versa. De fato, estudos empíricos recentes revelam que estes sintomas tendem a afetar os mesmos módulos de um sistema. Desta forma, arquitetos devem elaborar estratégias híbridas para uma prevenção simultânea de ambos os processos de degradação arquitetural. Embora as especificações de regras arquiteturais demandem um esforço considerável, estas são frequentemente similares em diversos projetos de uma mesma companhia ou de um mesmo domínio de aplicação. Essa dissertação descreve a linguagem específica de domínio TamDera para: (i) especificar estratégias de regras para permitir prevenção simultânea de ambos os processos de erosão e descaracterização arquitetural, e (ii) prover o reúso tanto hierárquico quanto composicional de regras de projetos em múltiplos contextos. Essa dissertação apresenta a avaliação empírica da linguagem em termos de provisão de suporte para descrição e reúso de regras de projeto em cinco projetos de software. O presente trabalho também apresenta um protótipo que suporta a utilização da linguagem para detecção de sintomas de degradação arquitetural.. Nossos resultados sugerem que arquitetos podem se beneficiar de abordagens que permitam a definição e reúso de regras híbridas para detectar ocorrências de ambos os processos de erosão e descaracterização arquitetural in diversos cenários. / [en] During the maintenance of software systems, their architecture often degrades through processes of architectural erosion and drift. These processes are often intertwined and, as a consequence, a given module in the code becomes the locus of both erosion and drift symptoms. Architects should elaborate strategies for detecting co-occurrences of both degradation symptoms. Strategies for enabling the detection of these symptoms are based on design rules. While the specification of design rules is time-consuming, they are often similar across different software projects. In this context, the contribution of this dissertation is threefold. First, it presents TamDera, an unified domain-specific language for: (i) specifying rule-based strategies to detect both erosion and drift symptoms, and (ii) promoting the hierarchical and compositional reuse of design rules across multiple contexts. Second, a tool implementation for supporting the language usage and rule enforcement is also presented in this dissertation. Third, we evaluated the language in supporting the description and reuse of design rules on five software projects. Our evaluation revealed that architects could be benefited by using TamDera to blend and reuse rules for detecting erosion and drift occurrences in multiple scenarios.

Over the past 20 years, the development in ComputationalElectromagnetics has produced a vast choice of methods based onthe large number of existing mathematical formulations of theMaxwell equations. None of them dominate over the others,instead they complement each other and the choice of methoddepends on the frequency range of the electromagnetic waves.This work is focused on the most popular method in the highfrequency scenario, namely the Geometrical Theory ofDiffraction (GTD). The main advantage of GTD is the ability topredict the electromagnetic field asymptotically in the limitof vanishing wavelength, when other methods, such as the Methodof Moments, become computationally too expensive. The low cost of GTD is due to both the fact that there is noruntime penalty in increasing the frequency and that the raytracing, which GTD is based on, is a geometrical technique. Thecomplexity is then no longer dependent on electrical size ofthe problem but instead on geometrical sub problems which aremanageable. For industrial applications the geometricalstructures, with which the rays interact, are modelled bytrimmed Non-Uniform Rational B-Spline (NURBS) surfaces, themost recent standard used to represent complex free-formgeometries. Due to the introduction of NURBS, the geometrical subproblems tend to be mathematically and numerically cumbersome,but they can be highly simplified by proper Object Orientedprogramming techniques. This allowed us to create a flexiblesoftware package, MIRA: Modular Implementation of Ray Tracingfor Antenna Applications, with an architecture that separatesmathematical algorithms from their implementation details andmodelling. In addition, its design supports hybridisationtechniques in combination with other methods such as Method ofMoment (MoM) and Physical Optics (PO). In a first hybrid application, a triangle-based PO solveruses the shadowing information calculated with the ray tracerpart of MIRA. The occlusion is performed between triangles andtheir facing NURBS surfaces rather than between their facingtriangles, thus reducing the complexity. Then the shadowinginformation is used in an iterative MoM-PO process in order tocover higher frequencies, where the contribution of theshadowing effects, in the hybrid formulation, is believed to bemore significant. Thesis presented at the Royal Institute of Technology ofStockholm in 2003, for the degree of Licentiate in ScientificComputing. / NR 20140805

The Nordin group at Brigham Young University has been focused on developing 3D printing technology for fabrication of lab-on-a-chip (microfluidic) devices since 2013. As we showed in 2015, commercial 3D printers and resins have not been developed to meet the highly specialized needs of microfluidic device fabrication. We have therefore created custom 3D printers and resins specifically designed to meet these needs. As part of this development process, ad hoc 3D printer control software has been developed. However, the software is difficult to modify and maintain to support the numerous experimental iterations of hardware used in our custom 3D printers. This highlights the need for modular yet reliable system software that is easy to use, learn, and work with to adapt to the unique challenges of a student workforce. This thesis details the design and implementation of new 3D printer system software that meets these needs. In particular, a software engineering principle-based design approach is taken that lends itself to several specific development patterns that permit easy incorporation of new hardware into a 3D printer to enable rapid evaluation of and development with such new hardware.

The dynamic query language GraphQL is gaining popularity within the field as more and more software architects choose it as their architectural model of choice when designing an API. The dynamic nature of the GraphQL queries provide a different way of thinking about data fetching, focusing more on the experience for the API consumer. The language provides many exciting features for the field, but not much is known about the implications of implementing them. This thesis analyzes the architecture of GraphQL and explores its attributes in order to understand the tradeoffs and performance implications of implementing a GraphQL architecture in a data-fetching API, as opposed to a conventional REST architecture. The results from the architectural analysis suggests that the GraphQL architecture values the usability and supportability attributes higher than its REST counterpart. A performance experiment was performed, testing the internal performance of GraphQL versus REST in a use-case where its dynamic functionality is not utilized (returning the same static response as its REST equivalent). The results indicate that the performance of GraphQL implementations are lower than that of its REST equivalents in use-cases where the dynamic functionality is not utilized.

Developing software for complicated systems is often done by collaboration and consists of deliverables by a multitude of organisations. The deliverables can range from smaller devices and commercial-off-the-shelf software components, to larger systems. This is the situation during the development of the embedded system for large vehicles or machines. Many companies within the embedded industry are transitioning to using Service-Orientation to develop high-quality software and reduce costs. However, when integrating different external systems with an internal, service-oriented system there may arise difficulties since the communication patterns, i.e. interface, cannot be changed to fit the internal system. This study aims to develop a design solution that can be used to integrate different external systems with an internally developed service-oriented system in an entire software product line, including the handling of variability by parametrization. The solution is evaluated by software developers at a company in such a situation. To develop the design solution design science methodology is applied, which is an iterative process that continuously improves the candidate solution until satisfactory according to various stakeholders. The resultant design solution includes the use of wrappers-based interaction between systems, where so-called adapters are used when the internal system acts as a client to an external system, and using gateways for when the internal systems acts as a server to an external system. We also observe the need for a system integration view to describe the relations and available communication mechanisms between systems, i.e. the gateways and adapters. We conclude that to integrate a service-oriented software system with non-service-oriented systems, there can be benefits to using an abstraction layer between systems to protect the internally developed software architecture from being affected by the nature of the external system. Attempting to integrate external systems with an internal system as if also developed internally may become troublesome in terms of defining and upholding an appropriate service-oriented architecture. This is especially important when considering variability of the complete system, where different external systems are used or replaced in specific variants.

No description available.