Submitted by JOSIANE SANTOS DE OLIVEIRA (josianeso) on 2018-04-25T16:10:27Z No. of bitstreams: 1 Maicon dos Santos_.pdf: 3747706 bytes, checksum: ef8b81f35d6d19fc23c56bfba79044c5 (MD5) / Made available in DSpace on 2018-04-25T16:10:27Z (GMT). No. of bitstreams: 1 Maicon dos Santos_.pdf: 3747706 bytes, checksum: ef8b81f35d6d19fc23c56bfba79044c5 (MD5) Previous issue date: 2018-01-18 / Nenhuma / Engenharia reversa de código desempenha um papel fundamental em várias atividades de Engenharia de Software, tais como geração de modelos a partir de código legado e recuperação de funcionalidades (ou features) de sistemas. No contexto de Linha de Produto de Software (LPS), por exemplo, um produto de software é formado por um conjunto de features que são constantemente alteradas para acomodar mudanças de regras de negócio. Consequentemente, o modelo (por exemplo, diagrama de classes da UML) que representa toda LPS precisa ser modificado para refletir as atualizações realizadas. Neste contexto, várias ferramentas têm sido propostas nas últimas décadas, por exemplo, Astah e ArgoUML. Porém, as ferramentas (e suas técnicas) não dão suporte à engenharia reversa orientada a features, são imprecisas no que se refere à completude dos diagramas gerados, bem como exige um alto esforço para atualização dos modelos pois são manuais ou semiautomáticas. Para mitigar esta problemática, este trabalho propõe a TechREF, uma técnica de engenharia reversa orientada a features. De forma automática, a TechREF captura o fluxo de execução do código associado a uma feature, identifica as informações estruturais e comportamentais do código, e gera diagramas de classes UML, bem como persiste tais diagramas. A TechREF foi avaliada através de um estudo de caso tendo cenários reais de engenharia reversa. Esta avaliação buscou verificar o esforço e a corretude das atividades que serão realizadas no experimento com o uso dos modelos orientados a features. / Reverse code engineering plays a key role in various Software Engineering activities, such as model generation from legacy code and retrieval of system features. In the context of Software Product Line (LPS), for example, a software product is composed of a set features that are constantly changed to accommodate changes in business rules. Consequently, the model (for example, UML class diagram) that represents the entire LPS needs to be modified to reflect the updates made. In this context, several tools have been proposed in the last decades, for example, Astah and ArgoUML. However, the tools (and their techniques) do not support feature-oriented reverse engineering, are imprecise in terms of the completeness of the generated diagrams, as well as requiring a high effort to update the models because they are manual or semiautomatic. To mitigate this problem, this paper proposes TechREF, a reverse engineering technique oriented to features. Automatically, TechREF captures the execution flow of code associated with a feature, identifies the structural and behavioral information of the code, and generates diagrams of UML classes, as well as persists such diagrams. TechREF was evaluated through a case study having real reverse engineering scenarios. This evaluation sought to verify the effort and correctness of the activities that will be carried out in the experiment with the use of the models oriented to features.

Les logiciels s'orientent de plus en plus vers des architectures évolutives, capables de s'adapter facilement aux changements et d'intégrer de nouvelles fonctionnalités. Ceci est important pour plusieurs classes d'applications qui ont besoin d‘évoluer sans que cela implique d'interrompre leur exécution. Des plateformes dynamiques à composants autorisent ce type d'évolution à l'exécution, en permettant aux composants d'être chargés et exécutés sans requérir le redémarrage complet de l'application en service. Toutefois, la flexibilité d'un tel mécanisme introduit de nouveaux défis qui exigent de gérer les possibles erreurs dues à des incohérences dans le processus de mise à jour, ou en raison du comportement défectueux de composants survenant pendant l'exécution de l'application. Des composants tiers dont l'origine ou la qualité sont inconnus peuvent être considérées à priori comme peu fiables, car ils peuvent potentiellement introduire des défauts d'applications lorsqu'il est combiné avec d'autres composants. Nous sommes intéressés à la réduction de l'impact de ces composants considérés comme non fiables et qui sont susceptibles de compromettre la fiabilité de l'application en cours d'exécution. Cette thèse porte sur l'application de techniques pour améliorer la fiabilité des applications dynamiques à composants. Pour cela, nous proposons l'utilisation des frontières d'isolation pouvant fournir du contingentement de fautes. Le composant ainsi isolé ne perturbe pas le reste de l'application quand il est défaillant. Une telle approche peut être vu sous trois perspectives présentées: (i) l'isolement des composants dynamiques, régi par une politique d'exécution reconfigurable, (ii) l'autoréparation de conteneurs d‘isolement, et (iii) l'utilisation des aspects pour séparer les préoccupations de fiabilité à partir du code fonctionnel. / Software is moving towards evolutionary architectures that are able to easily accommodate changes and integrate new functionality. This is important in a wide range of applications, from plugin-based end user applications to critical applications with high availability requirements. Dynamic component-based platforms allow software to evolve at runtime, by allowing components to be loaded, and executed without forcing applications to be restarted. However, the flexibility of such mechanism demands applications to cope with errors due to inconsistencies in the update process, or due to faulty behavior from components introduced during execution. This is mainly true when dealing with third-party components, making it harder to predict the impacts (e.g., runtime incompatibilities, application crashes) and to maintain application dependability when integrating such third-party code into the application. Components whose origin or quality attributes are unknown could be considered as untrustworthy since they can potentially introduce faults to applications when combined with other components, even if unintentionally. The quality of components is harder to evaluate when components are combined together, especially if it happens on-the-fly. We are interested in reducing the impact that can be brought by untrustworthy components deployed at runtime and that would potentially compromise application dependability. This thesis focuses on applying techniques for moving a step forward towards dependable dynamic component-based applications by addressing different dependability attributes namely reliability, maintainability and availability. We propose the utilization of strong component isolation boundaries, by providing a fault-contained environment for separately running untrustworthy components. Our solution combines three approaches: (i) the dynamic isolation of components, governed by a runtime reconfigurable policy; (ii) a self-healing component isolation container; and (iii) the usage of aspects for separating dependability concerns from functional code.

This thesis proposes a privacy protection framework for the controlled distribution and use of personal private data. The framework is based on the idea that privacy policies can be set directly by the data owner and can be automatically enforced against the data user. Data privacy continues to be a very important topic, as our dependency on electronic communication maintains its current growth, and private data is shared between multiple devices, users and locations. The growing amount and the ubiquitous availability of personal private data increases the likelihood of data misuse. Early privacy protection techniques, such as anonymous email and payment systems have focused on data avoidance and anonymous use of services. They did not take into account that data sharing cannot be avoided when people participate in electronic communication scenarios that involve social interactions. This leads to a situation where data is shared widely and uncontrollably and in most cases the data owner has no control over further distribution and use of personal private data. Previous efforts to integrate privacy awareness into data processing workflows have focused on the extension of existing access control frameworks with privacy aware functions or have analysed specific individual problems such as the expressiveness of policy languages. So far, very few implementations of integrated privacy protection mechanisms exist and can be studied to prove their effectiveness for privacy protection. Second level issues that stem from practical application of the implemented mechanisms, such as usability, life-time data management and changes in trustworthiness have received very little attention so far, mainly because they require actual implementations to be studied. Most existing privacy protection schemes silently assume that it is the privilege of the data user to define the contract under which personal private data is released. Such an approach simplifies policy management and policy enforcement for the data user, but leaves the data owner with a binary decision to submit or withhold his or her personal data based on the provided policy. We wanted to empower the data owner to express his or her privacy preferences through privacy policies that follow the so-called Owner-Retained Access Control (ORAC) model. ORAC has been proposed by McCollum, et al. as an alternate access control mechanism that leaves the authority over access decisions by the originator of the data. The data owner is given control over the release policy for his or her personal data, and he or she can set permissions or restrictions according to individually perceived trust values. Such a policy needs to be expressed in a coherent way and must allow the deterministic policy evaluation by different entities. The privacy policy also needs to be communicated from the data owner to the data user, so that it can be enforced. Data and policy are stored together as a Protected Data Object that follows the Sticky Policy paradigm as defined by Mont, et al. and others. We developed a unique policy combination approach that takes usability aspects for the creation and maintenance of policies into consideration. Our privacy policy consists of three parts: A Default Policy provides basic privacy protection if no specific rules have been entered by the data owner. An Owner Policy part allows the customisation of the default policy by the data owner. And a so-called Safety Policy guarantees that the data owner cannot specify disadvantageous policies, which, for example, exclude him or her from further access to the private data. The combined evaluation of these three policy-parts yields the necessary access decision. The automatic enforcement of privacy policies in our protection framework is supported by a reference monitor implementation. We started our work with the development of a client-side protection mechanism that allows the enforcement of data-use restrictions after private data has been released to the data user. The client-side enforcement component for data-use policies is based on a modified Java Security Framework. Privacy policies are translated into corresponding Java permissions that can be automatically enforced by the Java Security Manager. When we later extended our work to implement server-side protection mechanisms, we found several drawbacks for the privacy enforcement through the Java Security Framework. We solved this problem by extending our reference monitor design to use Aspect-Oriented Programming (AOP) and the Java Reflection API to intercept data accesses in existing applications and provide a way to enforce data owner-defined privacy policies for business applications. / Im Rahmen der Dissertation wurde ein Framework für die Durchsetzung von Richtlinien zum Schutz privater Daten geschaffen, welches darauf setzt, dass diese Richtlinien oder Policies direkt von den Eigentümern der Daten erstellt werden und automatisiert durchsetzbar sind. Der Schutz privater Daten ist ein sehr wichtiges Thema im Bereich der elektronischen Kommunikation, welches durch die fortschreitende Gerätevernetzung und die Verfügbarkeit und Nutzung privater Daten in Onlinediensten noch an Bedeutung gewinnt. In der Vergangenheit wurden verschiedene Techniken für den Schutz privater Daten entwickelt: so genannte Privacy Enhancing Technologies. Viele dieser Technologien arbeiten nach dem Prinzip der Datensparsamkeit und der Anonymisierung und stehen damit der modernen Netznutzung in Sozialen Medien entgegen. Das führt zu der Situation, dass private Daten umfassend verteilt und genutzt werden, ohne dass der Datenbesitzer gezielte Kontrolle über die Verteilung und Nutzung seiner privaten Daten ausüben kann. Existierende richtlinienbasiert Datenschutztechniken gehen in der Regel davon aus, dass der Nutzer und nicht der Eigentümer der Daten die Richtlinien für den Umgang mit privaten Daten vorgibt. Dieser Ansatz vereinfacht das Management und die Durchsetzung der Zugriffsbeschränkungen für den Datennutzer, lässt dem Datenbesitzer aber nur die Alternative den Richtlinien des Datennutzers zuzustimmen, oder keine Daten weiterzugeben. Es war daher unser Ansatz die Interessen des Datenbesitzers durch die Möglichkeit der Formulierung eigener Richtlinien zu stärken. Das dabei verwendete Modell zur Zugriffskontrolle wird auch als Owner-Retained Access Control (ORAC) bezeichnet und wurde 1990 von McCollum u.a. formuliert. Das Grundprinzip dieses Modells besteht darin, dass die Autorität über Zugriffsentscheidungen stets beim Urheber der Daten verbleibt. Aus diesem Ansatz ergeben sich zwei Herausforderungen. Zum einen muss der Besitzer der Daten, der Data Owner, in die Lage versetzt werden, aussagekräftige und korrekte Richtlinien für den Umgang mit seinen Daten formulieren zu können. Da es sich dabei um normale Computernutzer handelt, muss davon ausgegangen werden, dass diese Personen auch Fehler bei der Richtlinienerstellung machen. Wir haben dieses Problem dadurch gelöst, dass wir die Datenschutzrichtlinien in drei separate Bereiche mit unterschiedlicher Priorität aufteilen. Der Bereich mit der niedrigsten Priorität definiert grundlegende Schutzeigenschaften. Der Dateneigentümer kann diese Eigenschaften durch eigene Regeln mittlerer Priorität überschrieben. Darüber hinaus sorgt ein Bereich mit Sicherheitsrichtlinien hoher Priorität dafür, dass bestimmte Zugriffsrechte immer gewahrt bleiben. Die zweite Herausforderung besteht in der gezielten Kommunikation der Richtlinien und deren Durchsetzung gegenüber dem Datennutzer (auch als Data User bezeichnet). Um die Richtlinien dem Datennutzer bekannt zu machen, verwenden wir so genannte Sticky Policies. Das bedeutet, dass wir die Richtlinien über eine geeignete Kodierung an die zu schützenden Daten anhängen, so dass jederzeit darauf Bezug genommen werden kann und auch bei der Verteilung der Daten die Datenschutzanforderungen der Besitzer erhalten bleiben. Für die Durchsetzung der Richtlinien auf dem System des Datennutzers haben wir zwei verschiedene Ansätze entwickelt. Wir haben einen so genannten Reference Monitor entwickelt, welcher jeglichen Zugriff auf die privaten Daten kontrolliert und anhand der in der Sticky Policy gespeicherten Regeln entscheidet, ob der Datennutzer den Zugriff auf diese Daten erhält oder nicht. Dieser Reference Monitor wurde zum einen als Client-seitigen Lösung implementiert, die auf dem Sicherheitskonzept der Programmiersprache Java aufsetzt. Zum anderen wurde auch eine Lösung für Server entwickelt, welche mit Hilfe der Aspekt-orientierten Programmierung den Zugriff auf bestimmte Methoden eines Programms kontrollieren kann. In dem Client-seitigen Referenzmonitor werden Privacy Policies in Java Permissions übersetzt und automatisiert durch den Java Security Manager gegenüber beliebigen Applikationen durchgesetzt. Da dieser Ansatz beim Zugriff auf Daten mit anderer Privacy Policy den Neustart der Applikation erfordert, wurde für den Server-seitigen Referenzmonitor ein anderer Ansatz gewählt. Mit Hilfe der Java Reflection API und Methoden der Aspektorientierten Programmierung gelang es Datenzugriffe in existierenden Applikationen abzufangen und erst nach Prüfung der Datenschutzrichtlinie den Zugriff zuzulassen oder zu verbieten. Beide Lösungen wurden auf ihre Leistungsfähigkeit getestet und stellen eine Erweiterung der bisher bekannten Techniken zum Schutz privater Daten dar.

Made available in DSpace on 2014-12-17T15:47:49Z (GMT). No. of bitstreams: 1 IsanioLAS.pdf: 1324306 bytes, checksum: 06b1bb191919f02b1e6524146d71c0d3 (MD5) Previous issue date: 2008-11-10 / Ubiquitous computing systems operate in environments where the available resources significantly change during the system operation, thus requiring adaptive and context aware mechanisms to sense changes in the environment and adapt to new execution contexts. Motivated by this requirement, a framework for developing and executing adaptive context aware applications is proposed. The PACCA framework employs aspect-oriented techniques to modularize the adaptive behavior and to keep apart the application logic from this behavior. PACCA uses abstract aspect concept to provide flexibility by addition of new adaptive concerns that extend the abstract aspect. Furthermore, PACCA has a default aspect model that considers habitual adaptive concerns in ubiquitous applications. It exploits the synergy between aspect-orientation and dynamic composition to achieve context-aware adaptation, guided by predefined policies and aim to allow software modules on demand load making possible better use of mobile devices and yours limited resources. A Development Process for the ubiquitous applications conception is also proposed and presents a set of activities that guide adaptive context-aware developer. Finally, a quantitative study evaluates the approach based on aspects and dynamic composition for the construction of ubiquitous applications based in metrics / Aplica??es para a computa??o ub?qua operam em ambientes onde a disponibilidade de recursos muda significativamente durante a sua opera??o. Tal caracter?stica demanda que aplica??es sejam adaptativas e cientes do seu contexto de execu??o. Visando atender esses requisitos, ? proposto o PACCA (Projeto de Aplica??es Ciente ao Contexto e Adaptativas), um arcabou?o para desenvolvimento e execu??o de aplica??es adaptativas cientes de contexto. O paradigma de orienta??o a aspectos ? usado no PACCA para modularizar o comportamento adaptativo e dissoci?-lo da l?gica da aplica??o. Para prover maior flexibilidade o PACCA utiliza o conceito de aspecto abstrato para permitir a extens?o e adi??o de novos interesses adaptativos, al?m de um modelo de aspectos default que contempla interesses adaptativos comuns a grande parte das aplica??es ub?quas. A orienta??o a aspectos aliada ? composi??o din?mica de software oferece suporte para adapta??o ciente ao contexto, guiada por pol?ticas previamente definidas e tem por objetivo permitir a carga de m?dulos de software sob demanda possibilitando melhor utiliza??o dos recursos limitados de um dispositivo m?vel. Um Processo de Desenvolvimento para a constru??o de aplica??es ub?quas tamb?m ? proposto e visa demonstrar um conjunto de atividades a serem executadas para a concep??o de aplica??es ub?quas. Por fim, ? realizado um estudo quantitativo com o intuito de avaliar com base em m?tricas a abordagem baseada em aspectos e composi??o din?mica para a constru??o de aplica??es ub?quas

Made available in DSpace on 2014-12-17T15:47:52Z (GMT). No. of bitstreams: 1 EvertonTG_DISSERT.pdf: 4234791 bytes, checksum: c40151c48849ad62c0cc34be8c3b56eb (MD5) Previous issue date: 2010-03-04 / Currently there are several aspect-oriented approaches that are related to different stages of software development process. These approaches often lack integration with each other and their models and artifacts are not aligned in a coherent process. The integration of Aspect-Oriented Software development (AOSD) and Model-Driven Development (MDD) enables automatic propagation of models from one phase to another, avoiding loss of important information and decisions established in each. This paper presents a model driven approach, called Marisa-AOCode, which supports the processing of detailed design artifacts to code in different Aspect-Oriented Programming languages. The approach proposed by Maris- AOCode defines transformation rules between aSideML, a modeling language for aspectoriented detailed design, and Metaspin, a generic metamodel for aspect-oriented programming languages. The instantiation of the generic metamodel (Metaspin) provided by the approach of Maris-AOCode is illustrated by the transformation of Metaspin for two languages: AspectLua and CaesarJ. We illustrate the approach with a case study based on the Health Watcher System / Atualmente existem diversas abordagens orientadas a aspectos que est?o relacionadas ?s diferentes fases do processo de desenvolvimento de software. Essas abordagens geralmente n?o possuem integra??o entre si e seus modelos e artefatos n?o est?o alinhados dentro de um processo coerente. A integra??o entre o desenvolvimento de software orientado a aspectos (DSOA) e o desenvolvimento dirigido a modelos (MDD) permite propaga??o autom?tica entre modelos de uma fase para outra, evitando perda de informa??es e decis?es importantes estabelecidas em cada uma delas. Este trabalho apresenta uma abordagem dirigida a modelos, denominada MaRiSA-AOCode, que suporta a transforma??o de artefatos de projeto detalhado em c?digo para diferentes linguagens de Programa??o Orientada a Aspectos. A abordagem proposta por MaRiSA-AOCode define regras de transforma??o entre aSideML, uma linguagem de modelagem para projeto detalhado orientado a aspectos, e Metaspin, um metamodelo gen?rico para linguagens de programa??o orientadas a aspectos. A instancia??o do metamodelo gen?rico (Metaspin) provido pela abordagem de MaRiSA-AOCode ? ilustrada atrav?s da transforma??o do Metaspin para duas linguagens: AspectLua e CaesarJ. Ilustramos a abordagem com um estudo de caso baseado no sistema Health Watcher

Made available in DSpace on 2014-12-17T15:47:58Z (GMT). No. of bitstreams: 1 DanielleGFM_DISSERT.pdf: 2687890 bytes, checksum: b53115296e0be43418332dfb089a931a (MD5) Previous issue date: 2011-05-13 / Coordena??o de Aperfei?oamento de Pessoal de N?vel Superior / The World Wide Web has been consolidated over the last years as a standard platform to provide software systems in the Internet. Nowadays, a great variety of user applications are available on the Web, varying from corporate applications to the banking domain, or from electronic commerce to the governmental domain. Given the quantity of information available and the quantity of users dealing with their services, many Web systems have sought to present recommendations of use as part of their functionalities, in order to let the users to have a better usage of the services available, based on their profile, history navigation and system use. In this context, this dissertation proposes the development of an agent-based framework that offers recommendations for users of Web systems. It involves the conception, design and implementation of an object-oriented framework. The framework agents can be plugged or unplugged in a non-invasive way in existing Web applications using aspect-oriented techniques. The framework is evaluated through its instantiation to three different Web systems / A World Wide Web, ou simplesmente Web, se consolidou ao longo dos ?ltimos anos como uma plataforma padr?o para disponibilizar sistemas de software de diferentes naturezas na Internet. Atualmente, uma grande variedade de aplica??es est? dispon?vel na plataforma Web, variando desde aplica??es corporativas do dom?nio banc?rio, governamental e at? com?rcio eletr?nico. Dada a quantidade de informa??o disponibilizada e de usu?rios usando seus servi?os, muitos sistemas Web tem buscado apresentar recomenda??es como parte de suas funcionalidades, com o objetivo de permitir ao usu?rio um melhor uso dos servi?os dispon?veis, baseado no perfil do usu?rio e no seu hist?rico de navega??o e uso do sistema. Neste contexto, este trabalho de disserta??o prop?e o desenvolvimento de um framework de agentes de usu?rio que ofere?am recomenda??es para usu?rios de sistemas Web. Este trabalho envolve a concep??o, projeto e implementa??o de um framework orientado a objetos que permite o desenvolvimento de agentes de usu?rio de recomenda??o para sistemas Web. Os agentes do framework podem ser plugados ou desplugados de forma n?o invasiva em aplica??es Web existentes, atrav?s de uma implementa??o orientada a aspectos. O framework foi avaliado atrav?s da sua instancia??o para tr?s sistemas Web de naturezas distinta

Made available in DSpace on 2014-12-17T15:48:06Z (GMT). No. of bitstreams: 1 SergioQM.pdf: 363127 bytes, checksum: 7b8fb995a67b3e514e8b774e59124df3 (MD5) Previous issue date: 2006-03-03 / New programming language paradigms have commonly been tested and eventually incorporated into hardware description languages. Recently, aspect-oriented programming (AOP) has shown successful in improving the modularity of object-oriented and structured languages such Java, C++ and C. Thus, one can expect that, using AOP, one can improve the understanding of the hardware systems under design, as well as make its components more reusable and easier to maintain. We apply AOP in applications developed using the SystemC library. Several examples will be presented illustrating how to combine AOP and SystemC. During the presentation of these examples, the benefits of this new approach will also be discussed / Novos paradigmas de linguagens de programa??o v?em sendo comumente testados e geralmente s?o incorporados depois por linguagens de descri??o de hardware. Recentemente, a programa??o orientada a aspectos (POA) provou ser ?til na tentativa de melhorar a modularidade de linguagens estruturadas e orientadas a objeto tais como Java, C++ e C. Diante de tal fato, podemos esperar que o uso de POA pode melhorar o entendimento de sistemas hardware que est?o sendo projetados, bem como tornar seus componentes mais reus?veis e f?ceis de manter. Iremos abordar ent?o o uso de POA em aplica??es desenvolvidas utilizando a biblioteca SystemC. Ser?o apresentados v?rios exemplos que ilustram o uso de POA juntamente com SystemC, mostrando alternativas e discutindo os seus benef?cios

Made available in DSpace on 2016-06-02T19:05:46Z (GMT). No. of bitstreams: 1 3276.pdf: 2803726 bytes, checksum: df932fa4f96049ba4e039732b3b37e42 (MD5) Previous issue date: 2010-09-17 / Universidade Federal de Minas Gerais / GRN (Gestão de Recursos de Negócio Business Resource Management) pattern language provides a set of patterns in analysis level to support the development of applications which deal with rental, purchase, sale and maintenance transactions of a good or service. GRENJ-OO is an object-oriented (OO) application framework built to support the instantiation of Java applications in the GRN domain. GRENJ-OO instantiates applications that include in their architecture all framework variabilities. The units of this framework, which implement each GRN pattern and their variants, are highly coupled between them, because there are concern tangling and concern scattering related to each one of those patterns. So, the aspect-orientation (OA) techniques were used in each pattern to minimize those problems and a new framework version was obtained, called GRENJ-OA. The improvements of separation of concerns, the coupling reduction, the cohesion increasing and the reduction of the number of lines of code of the majority of the patterns implemented in GRENJ-OA was the result reached after performing a quantitative evaluation based on separation of concerns, coupling, cohesion and size metrics. From the approach used to modularize this framework is introduced the Framework Product Line concept, that consists in a product line which their products are frameworks instead of software applications. From the GRENJ-OO modularization was also possible to extract a process that can be applied to modularize frameworks. This process aims to transform a framework in a Framework Product Line. / A linguagem de padrões GRN (Gestão de Recursos de Negócio) fornece um conjunto de padrões em nível de análise que apóiam o desenvolvimento de aplicações que tratam de transações de aluguel, compra, venda e manutenção de um bem ou serviço. GRENJ-OO é um framework de aplicação orientado a objetos (OO) construído para apoiar a instanciação de aplicações no domínio da GRN na linguagem Java. O framework GRENJ-OO instancia aplicações que incluem em sua arquitetura todas as variabilidades do framework. As unidades desse framework, que implementam cada padrão da GRN e suas variantes, estão altamente acopladas entre si, em virtude da existência de entrelaçamento e espalhamento de interesses relacionados a cada um desses padrões. Assim, a orientação a aspectos (OA) foi utilizada em cada um dos padrões a fim de minimizar esses problemas e uma nova versão do framework foi obtida, denominada GRENJ-OA. A melhoria dos níveis de separação de interesses, a redução do acoplamento, o aumento da coesão e redução do número de linhas de código da maioria dos padrões implementados no GRENJ-OA foram os resultados obtidos após a realização de uma avaliação quantitativa com base em métricas de separação de interesses, acoplamento, coesão e tamanho. A partir da abordagem utilizada na modularização desse framework, é introduzido o conceito de Linha de Produtos de Frameworks, que consiste em uma linha de produtos na qual seus produtos são frameworks, ao invés de aplicações de software. Com a modularização do GRENJ-OO também foi possível extrair um processo, que pode ser aplicado na modularização de frameworks. Esse processo tem o objetivo de transformar um framework em uma Linha de Produtos de Frameworks.

Made available in DSpace on 2016-06-02T19:06:20Z (GMT). No. of bitstreams: 1 6500.pdf: 5345644 bytes, checksum: e886844b4ba61e58d704a8babf113721 (MD5) Previous issue date: 2014-10-21 / Maintaining legacy systems is a complex and expensive activity for many companies. A recently proposal to solve this problem is Architecture-Driven Modernization (ADM), proposed by Object Management Group (OMG). The ADM consists of a set of concepts and standard metamodels that support systems modernization using models. The Knowledge Discovery Metamodel (KDM) is the main metamodel of ADM, it can represent many artifacts of a legacy system, such as source code, architecture, user interface, configuration files and business process. In general, legacy systems have crosscutting concerns, it can show source code problems like tangling and scattering, and it raises the maintenance costs. The aspect orientation is an alternative to improve crosscutting concerns modularization. Thus, in this dissertation is presented the term Aspect Oriented Modernization that uses the aspect oriented concepts in the ADM context. This modernization process consists in modularize legacy systems with aspects represented in model level. To achieve this goal, in this work were performed a lightweight and a heavyweight extension in the KDM metamodel, to analyze which one would present a better performance if used by Modernization Engineers. The evaluation of these extensions was performed by a case study that considered the modernization with aspects of a small-sized system. To evaluate the case study in both extensions, a set of comparison criteria were created to support the software engineers in choosing the best extension mechanism, according to their needs. In the context of this dissertation an experimental study were developed that aimed reproducing the scenarios that the modernization engineers had to perform maintenances and developing new refactorings in a aspect oriented KDM model. The experiment data considered the development time of the activities and the found number of errors. Finally, it was noticed that the extension mechanism to be choose will depend on the context that it will be applied, however, considering the approach studied here the best extension mechanism is the heavyweight one. / Manter sistemas legados é uma atividade complexa e onerosa para muitas empresas. Uma proposta recente para esse problema é a Modernização Dirigida à Arquitetura (Architecture-Driven Modernization - ADM), proposta pela OMG (Object Management Group). A ADM consiste em um conjunto de princípios e metamodelos padrões que apoiam a modernização de sistemas utilizando modelos. O Knowledge Discovery Metamodel (KDM) é o principal metamodelo da ADM, podendo representar diversos artefatos de um sistema, como código-fonte, arquitetura, interface de usuário, arquivos de configuração e processos de negócio. Em geral, sistemas legados possuem interesses transversais, apresentando problemas de entrelaçamento e espalhamento de código, o que eleva os custos de manutenção. A orientação a aspectos é uma alternativa para melhorar a modularização de interesses transversais. Mediante isso, neste trabalho é apresentado o termo Modernização Orientada a Aspectos que utiliza os conceitos da orientação a aspectos na ADM. Essa modernização consiste em remodularizar sistemas legados utilizando aspectos representados em nível de modelo. Para atingir esse objetivo, foi realizada uma extensão leve e outra pesada do metamodelo KDM, para analisar em qual das duas o desempenho dos engenheiros de modernização seria melhor. Para fazer a avaliação das extensões, foi realizado um estudo de caso levando em consideração a modernização com aspectos em um sistema de pequeno porte. Com o objetivo de avaliar o estudo de caso usando as duas extensões, foram desenvolvidos critérios de comparação que auxiliassem os engenheiros de software a escolher qual dos dois mecanismos de extensão utilizar em seu projeto. Foi feito também um estudo experimental que buscou reproduzir os cenários em que engenheiros de modernização tivessem que realizar manutenções e desenvolver novas refatorações em um modelo KDM orientado a aspectos. Os dados do experimento foram avaliados em relação ao tempo de desenvolvimento das atividades e quantidade de erros encontrados. Por fim, percebeu-se que o mecanismo de extensão a ser utilizado vai depender do contexto em que ele será aplicado, mas, para o domínio aqui estudado a extensão que melhor atendeu aos requisitos foi a pesada.

Uma abordagem de teste estrutural de integração contextual para programas OO e OA escritos em Java e AspectJ é apresentada. A finalidade dessa abordagem é descobrir defeitos que possam existir nas interfaces entre uma determinada unidade (método ou adendo) e todas as outras que interagem diretamente com ela, bem como descobrir defeitos que possam ocorrer na hierarquia de chamadas dessas unidades. Para programas OO, esse tipo de teste envolve testar a interação entre métodos; já para programas OA, o teste estrutural de integração nível um (como também pode ser chamado) deve considerar as interações método-método, método-adendo, adendo-adendo e adendo-método. Para efetuar o teste estrutural de integração nível um deve-se considerar todo o fluxo de execução (fluxo de controle e de dados) que ocorre entre uma unidade chamadora e as unidades que interagem diretamente com ela. Para isso é definido o grafo Def-Uso IN1P, que é uma abstração formada pela integração dos grafos Def-Uso Orientado a Aspectos (AODU) da unidade chamadora e das unidades que ela chama ou que a afeta. Além disso, são propostos três critérios para derivar os requisitos de teste, dois baseados em fluxo de controle (todos-nós-integrados-N1 e todas-arestas-integradas-N1) e um baseado em fluxo de dados (todos-usos-integrados-N1). A ferramenta JaBUTi/AJ foi estendida para dar apoio à abordagem de teste de integração proposta. Exemplos são apresentados para ilustrar o uso da ferramenta para o teste de profundidade um e também seu uso no contexto de uma abordagem que leva em consideração também o teste de unidades e o teste baseado em conjuntos de junção / A Contextual structural integration testing for OO and OA programs written in Java and AspectJ is presented. The purpose of this approach is to discover faults that may exist in the interfaces between a particular unit (method or advice) and all others that interact directly with it, as well as to discover defects that may occur in the call hierarchy of these units. In OO programs, this type of test involves testing the interaction among methods. For OA programs, the structural integration testing at the depth of one (as it can also be called) should consider the method-method, method-advice, advice-advice and advice-method interactions. To perform structural integration testing at the depth of one level the whole execution flow (control and data flow) that occurs among a caller unit and the units that interact directly with it it must be considered. The IN1P Def-Use graph has been defined as an abstraction formed by the integration of the Aspect-Oriented Def-Use (AODU) graphs of the caller unit and of the units that it calls or affects it. Also, three criteria to derive test requirements are proposed, two of which are based on control flow all-integrated-nodes-N1 and all-integrated-edges-N1 and one is based on data flowall-integrated-uses-N1. The tool JaBUTi/AJ was extended to support the proposed integration testing approach. Examples are presented to illustrate the use of the tool for depth 1 testing as well as its use in the context of an approach that also takes into account unit testing and pointcut-based testing