The manual transformation of sequential programs into parallel code is not an easy task. It requires very effort and attention of the developer during this process at great risk of introducing errors that can not be perceived by the programmer. One of these problems, strongly connected to shared memory parallel programming is the race condition. This problem occurs because of the simultaneous manipulation performed for more than a thread on a variable shared between them, with the result of this variable dependent of the access order. Exploring this difficulty, this work proposes an approach that helps the programmer during the refactoring of a sequential code for OpenMP parallel code, identifying variables in an automated manner that may have problems of race condition. To this end, we propose a verification algorithm based on access to the variables and made its implementation using the Photran framework tool (a plugin for editing FORTRAN code integrated into the Eclipse IDE). For purposes of empirical evaluation of the algorithm, we present tests with small programs and code examples showing the operation of the tool in the cases provided. In addition, it presents a case study based on a real and complex application, showing the ability of the algorithm to identify all the variables at risk, as well as illustrating some of its known limitations. / A transformação manual de programas sequenciais em código paralelo não é uma tarefa fácil. Ela requer muito esforço e atenção do programador durante esse processo, correndo grande risco de se introduzir erros que podem não ser percebidos pelo programador. Um desses problemas, fortemente ligado à programação paralela em memória compartilhada, é a condição de corrida. Esse problema ocorre em virtude da manipulação concomitante realizada por mais de uma thread sobre uma variável compartilhada entre elas, sendo o resultado desta variável dependente da ordem de acesso. Explorando essa dificuldade, este trabalho propõe uma abordagem que auxilie o programador durante a refatoração de código sequencial para código paralelo OpenMP, identificando de forma automatizada variáveis que podem vir a ter problemas de condição de corrida. Para tanto, é proposto um algoritmo de verificação baseado no acesso às variáveis e feita a sua implementação utilizando-se do framework da ferramenta Photran (um plugin para edição de código Fortran integrado ao IDE Eclipse). Para fins de avaliação empírica do algoritmo, apresentam-se testes realizados com pequenos programas e exemplos de código, mostrando o funcionamento da ferramenta nos casos previstos. Além disso, apresenta-se um estudo de caso baseado em uma aplicação real e complexa, mostrando a habilidade do algoritmo em identificar as variáveis em risco, bem como ilustrando algumas de suas limitações conhecidas.

A falta de modularização é um dos principais problemas encontrados em sistemas de software. Diversos estudos abordam esse problema apresentando soluções que visam aumentar a qualidade da modularização. Contudo, ainda não existe uma solução definitiva que possa ser aplicada em qualquer situação na qual esse problema ocorre. Uma situação específica diz respeito à falta de coesão entre os métodos de uma classe em sistemas orientados a objetos. Para essa situação, uma solução apropriada seria aplicar a refatoração de classes. O processo de refatoração de classes tem como objetivo melhorar a modularização de um sistema sem altear suas funcionalidades. Contudo, esse processo pode ser extremamente complexo e difícil de ser executado, pois existem efeitos colaterais que podem ser provocados por alterações indevidas. Nesse contexto, ainda existe uma lacuna por melhores sistemas de apoio à refatoração visando o aumento de coesão entre métodos das classes e uma melhor modularização do sistema. Assim, este trabalho tem como objetivo propor uma abordagem para fornecer informações de apoio à refatoração. Tais informações foram obtidas a partir de uma análise dos impactos gerados pelas refatorações aplicadas em 8 sistemas desenvolvidos na linguagem Java. O impacto dessas refatorações foram identificados e medidos através da análise da evolução das métricas de coesão. Foi realizada uma análise qualitativa sobre as refatorações identificadas com o objetivo de determinar qual tipo de estratégia foi adotada em cada situação. A partir dessa análise foi possível propor guias de refatoração que foram apresentadas aos desenvolvedores dos 8 sistemas através de um survey. O estudo obteve resultados positivos onde a partir de discussões realizadas com os desenvolvedores foram observadas situações nas quais as guias propostas claramente ajudariam no processo de refatoração. Também foram constatadas situações nas quais as recomendações podem ser adotadas como novas práticas com o objetivo de evitar perdas de modularização. / The lack of modularization is one of the main problems encountered in software systems. Several studies address this problem by presenting solutions that aim to increase the modularization quality. However, there is still no definitive solution that can be applied in any situation in which this problem occurs. A specific situation concerns the lack of cohesion among methods of a class in object-oriented systems. In this situation, an appropriate solution would be to apply a class refactoring. The class refactoring process aims at improving the modularization of a system without changing its functionalities. However, this process can be complex and difficult to execute because of the side effects that can be caused by improper changes. In this context, better systems for supporting refactoring are still lacking, so the cohesion between class methods and a better modularization of the system could be achieved. This work proposes an approach to provide information to support of refactoring. This information was obtained from an analysis of the impacts generated by the refactorings applied in 8 systems developed in Java language. The impact of these refactorings was identified and measured by analyzing the evolution of cohesion metrics. A qualitative analysis was performed on the refactorings identified with the objective of determining what type of strategy was adopted in each situation. From this analysis it was possible to propose refactoring guides that were presented to the developers of the 8 systems through a survey. The study found positive results in which discussions with the developers led to situations in which the proposed guidelines would clearly help the refactoring process. It was also observed situations in which the recommendations can be adopted as new practices in order to avoid losses of modularization. / Dissertação (Mestrado)

É rara a preocupação com a qualidade de implementação de software. Pode-se observar que as estruturas internas dos softwares são freqüentemente complexas e desorganizadas, especialmente no caso dos softwares que são ditos orientados a objetos. Essa complexidade afeta diretamente a manutenibilidade e a susceptibilidade a erros, dificultando a alteração e a adição de novas funcionalidades aos softwares. As próprias alterações, inerentes aos softwares, os tornam mais complexos, o que agrava o problema. Neste contexto, acredita-se que o controle da complexidade pode levar a produtos de software de melhor qualidade. Assim, trata-se neste trabalho da manutenção preventiva, implementada por meio de inspeções, refatorações e análise de métricas. São estudadas falhas de manutenibilidade em uma amostra de programas orientados a objetos e, a partir dos resultados, são propostos artefatos de apoio para um processo de inspeção de software e modelos para os produtos de trabalho gerados nesse processo. Propõe-se o uso da técnica de leitura PBR (Leitura Baseada em Perspectivas) como uma maneira de se melhorar a detecção de falhas de manutenibilidade. Finalmente, a proposta deste trabalho foi validada por meio de um estudo de caso / The commitment with the quality of software implemetation is rare. It\'s possible to observe that the software internal structures are frequently complex and disorganized, especially when talking about software that is said to be object-oriented. This complexity directly affects maintainability and error proneness, making it difficult to change and to add new functionalities to software. Changes themselves, that are inherent in software, make it more complex, and that makes the problem more serious. In this context, it\'s believed that the control of complexity can lead to better quality software products. Thus, the subject of this work is the preventive maintenance, implemented by means of inspections, refactoring and metric analysis. Maintenance flaws were studied in a sample of object-oriented programs and, based on the results, support artifacts for an inspection process were proposed, along with models of work products for this process. The use of PBR (Perspective-Based Reading) technique is proposed as a means of improving the detection of maintenance flaws. Finally, the proposal of this work is validated through a case study

A Modernização Dirigida a Arquitetura (do inglês - Architecture-Driven Modernization (ADM)) é uma iniciativa do Object Management Group (OMG) no sentido de padronizar os tradicionais processos de reengenharia de software utilizando metamodelos. O metamodelo mais importante da ADM é o Knowledge Discovery Metamodel (KDM), cujo objetivo é representar todos artefatos de um determinado sistema, de forma independente de linguagem e plataforma. Um passo primordial durante processos de modernização de software é a aplicação de refatorações. No entanto, até o presente momento, há carência de abordagens que tratam das questões referentes a refatorações no contexto da ADM, desde a criação até a aplicação das mesmas. Além disso, atualmente, não existe uma forma sistemática e controlada de facilitar o reúso de refatorações que são específicas do KDM. Diante disso, são apresentados uma abordagem para criação e disponibilização de refatorações para o metamodelo KDM e um apoio ferramental que permite aplicá-las em diagramas de classe da UML. A abordagem possui dois passos: (i) o primeiro envolve passos que apoiam o engenheiro de modernização durante a criação de refatorações para o KDM; (ii) o segundo resume-se na especificação das refatorações por meio da criação de instâncias do metamodelo Structured Refactoring Metamodel (SRM) e posterior disponibilização delas em um repositório. O apoio ferramental, denominado KDM-RE, é composto por três plug-ins do Eclipse: (i) o primeiro consiste em um conjunto de Wizards que apoia o engenheiro de software na aplicação das refatorações em diagramas de classe UML; (ii) o segundo consiste em um módulo de propagação de mudanças, permitindo manter modelos internos do KDM sincronizados; (iii) o terceiro fornece apoio à importação e reúso de refatorações disponíveis no repositório. Além disso, o terceiro módulo também contém uma linguagem específica de domínio, a qual é utilizada para auxiliar o engenheiro de software a instanciar o metamodelo SRM. Foi realizado um experimento, buscando reproduzir os cenários em que engenheiros de software realizam refatorações em instâncias do metamodelo KDM. Os resultados mostraram que a abordagem, bem como o apoio ferramental podem trazer benefícios para o engenheiro de software durante a atividade de aplicação de refatorações em sistemas, representados pelo metamodelo KDM. / Architecture Driven Modernization (ADM) is an initiative of the Object Management Group (OMG) whose main purpose is to provide standard metamodels that enable the conduction of modernization activities as reverse engineering and software transformation. In this context, the most important metamodel is the Knowledge Discovery Metamodel (KDM), whose objective is to represent software artifacts in a language- and platform-agnostic fashion. A fundamental step during software modernization is refactoring. However, there is a lack of approaches that address how refactoring can be applied in conjunction with ADM. In addition, few efforts have investigated how refactorings can be reused and systematically applied within the context of KDM representations. We propose an approach for creating and cataloging refactorings tailored to KDM. Our approach is twofold: (i) the first part comprises steps that help the software modernization engineer create KDM-compliant refactorings; (ii) the second part has to do with turning these refactoring descriptions into Structured Refactoring Metamodel (SRM) and making them available to be reused. To automate these activities, we developed a tool that makes it possible to apply refactorings to Unified Modeling Language (UML) class diagrams. Our tool, named KDM-RE, comprises three Eclipse plug-ins, which can be briefly described as follows: (i) a set of Wizards aimed at supporting the software modernization engineer during refactoring activities; (ii) a change propagation module that keeps the internal metamodels synchronized; and (iii) a plug-in that supports the selection and reuse of the refactorings available in the repository. Moreover, we developed a domain specific language to minimize the effort required to instantiate SRMs. We carried out an evaluation that simulates how software modernization engineers would go about refactoring KDM instances. Our results would seem to suggest that our approach, when automated by our tool, provides several advantages to software modernization engineers refactoring systems represented by KDMs.

Submitted by Luiz Felipe Barbosa (luiz.fbabreu2@ufpe.br) on 2015-03-09T13:43:25Z No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) DISSERTAÇÃO Francisco Miranda Soares da Silva Neto.pdf: 1968720 bytes, checksum: 60383d7751d95b545cae9a16a83f611c (MD5) / Made available in DSpace on 2015-03-09T13:43:26Z (GMT). No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) DISSERTAÇÃO Francisco Miranda Soares da Silva Neto.pdf: 1968720 bytes, checksum: 60383d7751d95b545cae9a16a83f611c (MD5) Previous issue date: 2014-02-27 / In recent years, the diminishing rate with which we can increase the amount of transistors in a processor core has slowed down the increase of computers’ power. Moore’s Law appears to be drawing to an end. With it, the assumption that software written today will be more efficiently executed in the future simply due to processors’ evolution is being challenged. On the other hand, parallel applications can still be made more efficient by distributing work among different processors to be executed at the same time, thus reducing overall execution time. To enable parallelization, we must have multiple processor cores. This has led to the popularization of multicore architectures. However, writing parallel applications is not trivial. A program must be either written from the start to be executed in parallel, or later adapted for parallel execution. The programmer has the error-prone task of parallelizing the application through use of concurrency and parallelism constructs. Locking, the most common concurrency option, presents risks for inexperienced programmers, such as the famous Deadlock and Livelock problems. As we move from single core architectures to multicore, our programming languages need to make it easier for the programmers to use concurrency. Many researchers have pointed at Software Transactional Memory (STM) as an answer to that issue, as it is a lock-free, abstract way to guarantee isolated access to shared resources. But adapting for STM a program that uses lock is not simple. Besides being an error-prone task, technical details of the language might require special attention to preserve the program’s behavior. In this dissertation, we propose a set of program transformations for concurrency constructs in Haskell, a purely functional programming language. They may be used to refactor a program’s existing locks into transactional constructs from Haskell’s STM implementation. This allows a programmer to gain the benefits of working on STM even for programs which were already developed using locks. Each transformation is accompanied by execution examples and a discussion on its ability to preserve program behavior. We also present a supporting study, in which a controlled experiment was used to evaluate the benefits of locks or STM for the development of Haskell programs. Although subjects’ opinions tended to favor lock-based concurrency, those which used STM overall committed significantly fewer mistakes and required on average 12% less time to finish their assignments. / Recentemente, a queda na taxa de crescimento da quantidade de transístores integráveis em processadores tem desacelerado o crescimento de poder computacional. A lei de Moore parece aproximar-se de seu fim. Com isso, é desafiada a premissa de que software escrito hoje terá melhor desempenho no futuro simplesmente devido à evolução dos processadores. Ainda assim, aplicações paralelas ainda podem se tornar mais eficientes ao se distribuir trabalho entre diferentes processadores para execução simultânea. Para permitir a paralelização, são necessários múltiplos núcleos de processamento, o que tem levado à popularização de arquiteturas multinúcleo. Entretanto, a escrita de aplicações paralelas não é trivial. Deve-se escrever um programa para execução paralela desde sua concepção, ou adaptá-lo posteriormente para execução paralela. O programador tem a difícil tarefa de paralelização da aplicação através do uso de construções de concorrência e paralelismo. Travas, a mais comum opção para concorrência, apresentam riscos para programadores inexperientes, tais quais os famosos problemas de Deadlock e Livelock. Ao adaptarem-se de arquiteturas de um único núcleo para as de multinúcleo, as linguagens de programação precisam facilitar o uso de concorrência para os programadores. Muitos pesquisadores têm indicado Memória Transacional em Software (STM, do inglês Software Transactional Memory) como a resposta para esse problema, por ser uma forma abstrata e não bloqueante para garantia de acesso isolado a recursos compartilhados. Mas adaptar para STM programas que usam travas não é simples. Além de ser uma atividade propensa a erros, detalhes técnicos da linguagem podem requerer cuidados para se preservar o comportamento do programa. Nesta dissertação, é proposto um conjunto de transformações de programas para construções de concorrência em Haskell, uma linguagem de programação puramente funcional. Elas podem ser usadas para refatorar travas de um programa para uso de construções transacionais da implementação de STM em Haskell. Isso permite ao programador aproveitar os benefícios do trabalho com STM mesmo para programas já desenvolvidos com uso de travas. Cada transformação é acompanhada de exemplos de execução e uma discussão sobre sua capacidade de preservar o comportamento do programa. Também é apresentado um estudo de apoio, no qual um experimento controlado foi usado para avaliar os benefícios do uso de travas ou STM no desenvolvimento de programas em Haskell. Apesar das opiniões dos participantes terem favorecido o uso de travas, aqueles que usaram STM cometeram em geral menos erros e em média precisaram de 12% a menos de tempo para terminar suas tarefas.

Neste trabalho foi realizado um grande levantamento de técnicas de esparsidade relacionadas a sistemas estáticos de energia elétrica. Tais técnicas visam, do ponto de vista computacional, ao aumento da eficiência na solução de rede elétrica objetivando, além da resolução em si, a redução dos requisitos de memória, armazenamento e tempo de processamento. Para tanto, uma extensa revisão bibliográfica foi compilada, apresentando um posicionamento histórico e uma ampla visão do desenvolvimento teórico. Os testes comparativos realizados para sistemas de 14, 30, 57 e 118 barras, sobre a implantação de três das técnicas mais empregadas, apontou a Bi-fatoração como tendo o melhor desempenho médio. Para sistemas pequenos, a Eliminação Esparsa e Sintética de Gauss apresentou melhores resultados. Este trabalho fornecerá subsídios conceituais e metodológicos a técnicos e pesquisadores da área. / In this work a great survey of sparsity techniques related to static systems of electric power was accomplished. Such techniques seek, for of the computational point of view, the increase of the efficiency in the solution of the electric net aiming, besides the resolution of itself, the reduction of memory requirements, the storage and time processing. For that, an extensive bibliographic review was compiled providing a historic positioning and a broad view of theoretic development. The comparative tests accomplished for systems of 14,30, 57 and 118 buses, on the implementation of three of the most employed techniques, it pointed out an bi-factorisation as best medium performance. For small systems, the sparse symmetric Gaussian elimination showed the best results. This work will supply conceptual and methodological subsidies to technicians and researchers of the area.

Submitted by Johnny Rodrigues (johnnyrodrigues@ufcg.edu.br) on 2018-08-31T23:09:48Z No. of bitstreams: 1 GUSTAVO WAGNER DINIZ MENDES - DISSERTAÇÃO PPGCC 2014..pdf: 7175302 bytes, checksum: c99a663c85f93c308e26cc6d963f5d2e (MD5) / Made available in DSpace on 2018-08-31T23:09:48Z (GMT). No. of bitstreams: 1 GUSTAVO WAGNER DINIZ MENDES - DISSERTAÇÃO PPGCC 2014..pdf: 7175302 bytes, checksum: c99a663c85f93c308e26cc6d963f5d2e (MD5) Previous issue date: 2014-03-13 / Refatorar um programa é o ato de mudar sua estrutura visando melhorar algum aspecto arquitetural, sem que se mude seu comportamento observável. Desenvolvedores utilizam ferramentas como Eclipse e NetBeans para auxiliá-los no refatoramento de seus programas. Essas ferramentas implementam um conjunto de condições para garantir que as transformações realizadas não mudem o comportamento observável do programa. Porém, não é trivial identificar todas as condições necessárias para que um refatoramento seja correto devido à complexidade da semântica das linguagens e por não haver uma definição formal das linguagens e consequentemente dos refatoramentos. Os desenvolvedores de ferramentas de refatoramento costumam, por não haver uma definição formal, implementar os refatoramentos de acordo com seus conhecimentos da linguagem de programação. Na prática, desenvolvedores utilizam coleções de testes para avaliar a corretude de suas implementações. Entretanto, não existem evidências que os desenvolvedores utilizem um processo sistemático na definição dessas coleções. Neste trabalho, propomos uma técnica para testar implementações de refatoramentos de programas C. Ela consiste em cinco fases. Primeiramente, geramos automaticamente diversos programas C para serem refatorados a partir do CDOLLY, que foi proposto baseado em uma especificação em Alloy. Depois, geramos automaticamente uma coleção de testes de unidade dos programas via o CATESTER. Em seguida, aplicamos o refatoramento através do CREXECUTOR nos programas gerados utilizando a ferramenta a ser testada. Após isso, executamos a coleção de testes nos programas refatorados e, por fim, classificamos os erros de compilação e mudanças comportamentais identificados em bugs. Avaliamos a nossa técnica na implementação de oito refatoramentos do Eclipse CDT. Estes refatoramentos não só modificam a estrutura do programa, como também o corpo das funções, como o refatoramento Extract Function. Detectamos 41 bugs, que introduzem erros de compilação no programa resultante, e seis bugs relacionados a mudanças comportamentais. Replicamos manualmente os bugs encontrados em implementações de refatoramentos do NetBeans CND, Xrefactory e OpenRefactory e detectamos 29 bugs nessas ferramentas. / Refactoring a program is the act of changing its structure in order to improve any architectural aspect, without changing its observable behavior. Developers use tools like Eclipse and NetBeans to help refactoring their programs. These tools implement a set of conditions to ensure that the transformations performed do not change the observable behavior of the program. However, it is not easy to identify ali the necessary conditions for a refactoring to be correct due to the semantic complexity of the languages, mainly because the languages are not formally proved and neither the refactorings. In practice, developers often use collections of tests to assess the correctness of their implementations. However, there is no evidence of having systematic process in the definition of this collection. In this work, we propose a technique to test refactoring implementations of C programs. It consists of five phases. First, we generate automatically several C programs to be refactored from CDOLLY, which has been proposed based on a specification in Alloy. Then, we generate automatically a collection of unit tests of the programs via CATESTER. We then apply the refactoring through CREXECUTOR on the generated programs using the tool to be tested. After this, we execute the test collection in the refactored programs and finally we classify the compilation errors and behavioral changes in bugs. We evaluated our technique in the implementation of eight refactorings of Eclipse CDT. These refactorings not only modify the program structure, but also the body functions, such as the refactoring Extract Function. We detected 41 bugs, which introduce compilation errors in the resulting program, and six bugs related to behavioral changes. We analyzed manually these bugs in refactoring implementations of NetBeans, Xrefactory and OpenRefactory and identified 29 bugs in these tools.

Made available in DSpace on 2016-06-02T19:05:51Z (GMT). No. of bitstreams: 1 3771.pdf: 2012363 bytes, checksum: beac2e75d3e67d4b8d96a9b1c3ce98ef (MD5) Previous issue date: 2011-05-27 / Universidade Federal de Sao Carlos / Aspect-Oriented Programming allows encapsulating the so-called "Crosscutting Concerns (CCC) - software requirements whose implementation is tangled and scattered throughout the functional modules - into new abstractions, such as Aspects, Pointcuts, Advices and Inter-type Declarations. The reengineering of an OO software to an AO is not an easy task due to the existence of different abstractions in these technologies. We develop a set of nine refactorings of annotated OO class models to AO class models. In the context of this work, "annotated class models" are UML class diagrams whose elements (classes, interfaces, attributes and methods) are annotated with stereotypes representing the existing CCC in the application source code. The set of refactorings developed is divided into: i) generic refactorings; and ii) specific refactorings. Three generic refactorings and six specific refactorings to the persistence (which is divided into management and connections, transaction and synchronization) and logging concerns and to the Singleton and Observer design patterns were created. The generic refactorings are responsible for transforming an annotated OO model with indications of CCC into a partial AO model. This model is called partial because it is usually not fully modularized, i.e., there are remaining software elements stereotyped with indications of particular concerns. These refactorings are applicable to any kind of CCC; this is possible, because what is taken into consideration is the scenario in which these concerns appear in the class model. The specific refactorings are responsible for transforming partial AO models into final ones, whose CCC have been fully modularized in aspects. For that, each refactoring has a set of specific steps for modularization of a particular kind of concern. An Eclipse plug-in, called MoBRe was developed to assist the software engineer in the tasks of refactoring application. As a major contribution, the refactorings proposed in this paper allow obtaining well designed AO models. This is so because: i) they provide a step-by-step guide to the modularization of certain CCC and can avoid that software engineers choose inappropriate strategies for modularization of these CCC; and ii) they were prepared based on good design practices recommended by the scientific community. Thus, besides, the models the use of refactorings can lead to generation of better-quality code, for example, free of bad smells. A case study was conducted to assess the applicability of the proposed refactorings in order to compare an AO model generated by them with an AO model obtained from the literature. / Orientação a Aspectos (OA) permite encapsular Interesses Transversais (ITs) - requisitos de software cuja implementação encontra-se entrelaçada e espalhada pelos módulos funcionais - em novas abstrações, tais como, Aspectos, Conjuntos de Junção, Adendos e Declarações Inter-tipo. A reengenharia de um software OO para um OA não é uma atividade trivial em consequência da existência de abstrações diferentes entre as tecnologias envolvidas. Neste trabalho é proposto um conjunto de refatorações que pode ser aplicado sobre modelos de classes OO anotados com indícios de ITs para obtenção de modelos de classes OA. Modelos de classes anotados são diagramas de classes da UML cujos elementos (classes, interfaces, atributos e métodos) são anotados com estereótipos referentes aos ITs existentes no software. O conjunto de refatorações desenvolvido é subdivido em: i) refatorações genéricas; e ii) refatorações específicas. As refatorações genéricas são responsáveis por transformar um modelo OO anotado com indícios de ITs em um modelo OA parcial - modelo cujos ITs existentes não são completamente modularizados. Essas refatorações são aplicáveis a qualquer tipo de IT existente no software, considerando o cenário que esses interesses apresentam no modelo de classes. As refatorações específicas são responsáveis por transformar modelos de classes OA parciais em modelos de classes OA finais - modelos nos quais os ITs foram completamente modularizados em aspectos. Para que isso aconteça, cada refatoração possui um conjunto de passos específicos para modularização de um determinado tipo de interesse. Três refatorações genéricas e seis refatorações específicas foram elaboradas para os interesses de persistência (subdividido em: gerenciamento de conexões, de transações e sincronização), de logging e para os padrões de projeto Singleton e Observer. Um plug-in Eclipse, denominado MoBRe, foi desenvolvido para auxiliar o Engenheiro de Software na tarefa de aplicação das refatorações. Como principal contribuição, a utilização das refatorações propostas neste trabalho pode permitir a obtenção de modelos OA que representam bons projetos arquiteturais, pois: i) fornecem um guia para modularização de determinados ITs, podendo evitar que Engenheiros de Software escolham estratégias inadequadas para modularização; e ii) foram elaboradas com base em boas práticas de projeto OA preconizadas pela comunidade científica. Assim, além dos modelos a utilização das refatorações pode levar à geração de códigos de melhor qualidade, por exemplo, livre da presença de bad smells. Um estudo de caso foi conduzido para verificar a aplicabilidade das refatorações propostas e os modelos OA resultantes foram equivalentes aos modelos obtidos na literatura.

Neste trabalho foi realizado um grande levantamento de técnicas de esparsidade relacionadas a sistemas estáticos de energia elétrica. Tais técnicas visam, do ponto de vista computacional, ao aumento da eficiência na solução de rede elétrica objetivando, além da resolução em si, a redução dos requisitos de memória, armazenamento e tempo de processamento. Para tanto, uma extensa revisão bibliográfica foi compilada, apresentando um posicionamento histórico e uma ampla visão do desenvolvimento teórico. Os testes comparativos realizados para sistemas de 14, 30, 57 e 118 barras, sobre a implantação de três das técnicas mais empregadas, apontou a Bi-fatoração como tendo o melhor desempenho médio. Para sistemas pequenos, a Eliminação Esparsa e Sintética de Gauss apresentou melhores resultados. Este trabalho fornecerá subsídios conceituais e metodológicos a técnicos e pesquisadores da área. / In this work a great survey of sparsity techniques related to static systems of electric power was accomplished. Such techniques seek, for of the computational point of view, the increase of the efficiency in the solution of the electric net aiming, besides the resolution of itself, the reduction of memory requirements, the storage and time processing. For that, an extensive bibliographic review was compiled providing a historic positioning and a broad view of theoretic development. The comparative tests accomplished for systems of 14,30, 57 and 118 buses, on the implementation of three of the most employed techniques, it pointed out an bi-factorisation as best medium performance. For small systems, the sparse symmetric Gaussian elimination showed the best results. This work will supply conceptual and methodological subsidies to technicians and researchers of the area.

Submitted by Irene Nascimento (irene.kessia@ufpe.br) on 2016-08-30T17:54:00Z No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Dissertação_Karina_CIN.pdf: 1045991 bytes, checksum: ab1e6ae77770903f6c88d33b95b07d99 (MD5) / Made available in DSpace on 2016-08-30T17:54:00Z (GMT). No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Dissertação_Karina_CIN.pdf: 1045991 bytes, checksum: ab1e6ae77770903f6c88d33b95b07d99 (MD5) Previous issue date: 2015-07-27 / Os Web Services são componentes de software que se utilizam de tecnologias e protocolos abertos: XML, SOAP, WSDL e UDDI, para fornecer seus serviços. Atualmente, os Web Services surgem como alternativa para melhorar a comunicação entre os sistemas. Esta dissertação apresenta uma reestruturação arquitetural de Web Service - em funcionamento há quatro anos, cuja finalidade do seu serviço visa possibilitar que operações DML sejam realizadas em diferentes bases de dados de forma transparente para os usuários - fazendo uso de refatoração e padrões de projetos, garantindo que os fatores de qualidade: manutenibilidade, confiabilidade, eficiência e portabilidade, sejam mantidos. Os objetivos propostos podem ser sintetizados no entendimento e caracterização das funcionalidades e das tecnologias que envolvem os Web Services; estudos e pesquisas para descobrir quais padrões de projetos e refatoração podem ser utilizados na implementação do Web Services, possibilitando desta forma que boas práticas de desenvolvimento sejam adotadas; definir quais fatores de qualidade podem ser utilizados no processo de validação, além de, realizar avaliações e testes de Web Service fazendo uso de ferramentas Open Source; e finalmente, analisar se os resultados obtidos após o uso destes padrões na implementação do Web Service são satisfatórios. Para alcançar os objetivos propostos foi realizada uma análise da arquitetura do Web Service, por meio da engenharia reversa e análise de código. Após esta análise, refatorações e padrões de projetos foram definidos e utilizados na nova arquitetura para a implementação do novo Web Service, com o intuito de prover e garantir os fatores de qualidade: manutenibilidade, confiabilidade, eficiência e portabilidade. E por fim, testes de desempenho, carga/stress e funcional foram realizados com auxílio de ferramentas Open Source, JMeter e SoapUI, nos dois Web Services, para posteriormente seus resultados serem analisados. Os resultados obtidos, após a realização de teste e avaliação comparativa entre os dois Web Services, demonstraram uma melhora na qualidade dos serviços fornecidos pelo Web Service reestruturado, além de proporcionar redução de custo de manutenção. Assim sendo, este estudo constatou que refatoração e padrões de projetos podem ser utilizados na implementação de Web Service. / Web Services are software components that use open technologies and protocols like XML, SOAP, WSDL and UDDI, to provide its services. Currently, Web Services are an alternative to improve communication between the systems. This dissertation presents a Web Service architectural restructuring – in operation for four years, for the purpose of its service aims to enable DML operations are performed on different databases transparently to users – making use of refactoring and design patterns, ensuring that the factors of quality: maintainability, reliability, efficiency and portability are kept. The objectives proposed can be synthesized in the understanding and characterization of the features and technologies involving Web Services; study and research to find out which design patterns and refactoring can be used in the implementation of the Web Service, enabling this way that good development practices are adopted. We also identify quality factors that can be used in the validation process, as well as we carry out evaluations and testing of Web Service using Open Source tools. Finally, we analyze the results obtained after the use of these standards in the implementation of Web Service are satisfactory. To achieve the proposed was conducted an analysis of the architecture of the Web Service, by means of reverse engineering and code analysis. After this step, design patterns and refactoring have been defined and used in the new architecture for the implementation of the new Web Service, in order to provide and ensure the factors of quality: maintainability, reliability, efficiency and portability. Finally, performance testing, load/stress and functional were performed with the help of Open Source tools, JMeter and SoapUI Web Services, two for later results are analyzed. The results, after testing and benchmarking between the two Web Services, showed and improvement in the quality of services provided by the Web Service restructured, in addition to providing maintenance cost reduction. Therefore, this study found that refactorings and design patterns can be used in implementing the Web Service.