Spelling suggestions: "subject:"8oftware - aintenance"" "subject:"8oftware - emaintenance""
151 |
An automated approach to assign software change requestsCAVALCANTI, Yguaratã Cerqueira 31 January 2014 (has links)
Submitted by Nayara Passos (nayara.passos@ufpe.br) on 2015-03-13T13:04:40Z
No. of bitstreams: 2
TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5)
license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) / Made available in DSpace on 2015-03-13T13:04:40Z (GMT). No. of bitstreams: 2
TESE Yaguaratã Cerqueira Cavalcanti.pdf: 2989671 bytes, checksum: cdde3d6cea6de1cabb90748865421b78 (MD5)
license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5)
Previous issue date: 2014 / The efficient management of Change Requests (CRs) is fundamental for successful
software maintenance; however the assignment of CRs to developers is an expensive aspect
in this regard, due to the time and expertise demanded. To overcome this, researchers have
proposed automated approaches for CR assignment. Although these proposals present advances
to this topic, they do not consider many factors inherent to the assignments, such as: developers’
workload, CRs severity, interpersonal relationships, and developers know-how. Actually, as
we demonstrate in this work, CR assignment is a complex activity and automated approaches
cannot rely on simplistic solutions. Ideally, it is necessary to consider and reason over contextual
information in order to provide an effective automation.
In this regarding, this work proposes, implements, and validates a context-aware architecture
to automate CR assignment. The architecture emphasizes the need for considering the
different information available at the organization to provide a more context-aware solution to
automated CR assignment. The development of such architecture is supported by evidence synthesized
from two empirical studies: a survey with practitioners and a systematic mapping study.
The survey provided us with a set of requirements that automated approaches should satisfy. In
the mapping study, in turn, we figured out how state-of-the-art approaches are implemented in
regarding to these requirements, concluding that many of them are not satisfied. In addition, new
requirements were identified in this mapping study.
For the implementation of the proposed architecture, we developed a strategy to automate
CR assignments which is based on two main components: a Rule-Based Expert System (RBES)
and an Information Retrieval (IR) model. The strategy coordinately applies these two components
in different steps to find the potential developer to a CR. The RBES takes care of the simple
and complex rules necessary to consider contextual information in the assignments, e.g., to
prevent assigning a CR to a busy or unavailable developer. Since these rules vary from one
organization/project to another, the RBES facilitates their modification for different contexts.
On the other hand, the IR model is useful to make use of the historical information of CR
assignments to match CRs and developers.
Results from the validation study showed that our solution is promising. It is, by
comparing the solution with an approach that uses only a machine learning algorithm, such as
the Support Vector Machine (SVM), we could improve the accuracy of assignments by almost
50%. The analysis of the solution’s payoff also pointed that such an accuracy is able to pay for
the efforts necessary to deploy the solution.-------------------------------------O gerenciamento eficiente de solicitações de mudança (SM) é fundamental para o
sucesso das atividades de manutenção e evolução de software. Entretanto, a atribuição de
SMs a desenvolvedores é um aspecto custoso desse gerenciamento, pois demanda tempo e
conhecimento apropriado do projeto de software. Várias pesquisas já propuseram métodos de
atribuição automática de SMs. Embora representem avanços na área, existem fatores inerentes a
atribuição de SMs que não são considerados nessas pesquisas e são essenciais para a automação.
Como demonstrado nesse trabalho, a atribuição automática deve, por exemplo, considerar
a carga de trabalho, a experiência e o conhecimento dos desenvolvedores, a prioridade e a
severidade das SMs, a afinidade dos desenvolvedores com os problemas descritos nas SMs, e até
mesmo os relacionamentos interpessoais. Para tornar esse cenário ainda mais complexo, esses
fatos podem variar de acordo com o projeto de software que está sendo desenvolvido. Assim,
uma solução para o problema de atribuição de SMs depende de informações contextuais.
Assim, esse trabalho propõe, implementa e valida uma solução arquitetural sensível ao
contexto para atribuição automática de SMs. Dado o aspecto contextual da solução, a arquitetura
considera diversas fontes de informações presentes na organização, assim como a necessidade de
se desenvolver algorítimos que implementem diferentes estratégias de atribuição. Nossa proposta
de solução é embasada em resultados de duas pesquisas quantitativas: um estudo de mapeamento
sistemático da literatura, e uma pesquisa de questionário com desenvolvedores de software. Esse
último forneceu um conjunto de requisitos que a solução automatizada deve satisfazer para que
as estratégias de atribuição sejam atendidas, enquanto o mapeamento da literatura identificou
técnicas, algoritmos, e outros requisitos necessários a automação.
A implementação da arquitetura segue uma estratégia de automação, definida nesse
trabalho, que possui dois componentes principais: um sistema especialista baseado em regras
(SEBR); e um modelo de recuperação de informação (MRI) com técnicas de aprendizagem. Em
nossa estratégia, esses dois componentes são executados alternadamente em momentos diferentes
a fim de atribuir uma SM automaticamente. O SEBR processa regras, considerando informações
contextuais do projeto de software e da organização que o desenvolve. O MRI é utilizado para
fazer o casamento entre SMs e desenvolvedores de acordo com o histórico de atribuições.
Os resultados do estudo de validação apontaram que a solução é promissora. Isto
é, ao compararmos nossa solução com uma abordagem que utiliza apenas um algoritmo de
aprendizado de máquina, como o Support Vector Machine (SVM), pudemos melhorar em quase
50% a acurácia de atribuição. Já a análise de custo de implantação apontou que a acurácia
atingida pela solução possui um bom custo benefício.
|
152 |
Giveme effort: um framework para apoiar estimativa de esforço em atividades de manutenção e compreensão de softwareMiguel, Marcos Alexandre 01 September 2016 (has links)
Submitted by Renata Lopes (renatasil82@gmail.com) on 2017-01-16T13:41:31Z
No. of bitstreams: 1
marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5) / Approved for entry into archive by Diamantino Mayra (mayra.diamantino@ufjf.edu.br) on 2017-01-31T10:34:46Z (GMT) No. of bitstreams: 1
marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5) / Made available in DSpace on 2017-01-31T10:34:46Z (GMT). No. of bitstreams: 1
marcosalexandremiguel.pdf: 10203756 bytes, checksum: 35844967ee919f58955320a1c591c5dc (MD5)
Previous issue date: 2016-09-01 / Muitas organizações encontram problemas na tentativa de estimar esforço em atividades de manutenção de software. Quando a estimativa de esforço não está bem definida ou é imprecisa, os resultados obtidos podem refletir diretamente na entrega do software, causando insatisfação do cliente ou diminuição da qualidade do produto. O sucesso ou fracasso de projetos depende da precisão do esforço e do cronograma das atividades envolvidas. O surgimento de métodos ágeis no campo de desenvolvimento de software tem apresentado muitas oportunidades e desafios para pesquisadores e profissionais da área. Um dos principais desafios é a estimativa de esforço para as atividades de manutenção no desenvolvimento ágil de software. Nesse contexto, este trabalho apresenta um framework, nomeado GiveMe Effort, o qual objetiva apoiar as atividades de estimativa de esforço na manutenção de software usando dados históricos e informações de compreensão de software. / Many organizations encounter problems when estimating effort for software maintenance activities. When estimating effort is not well defined or are inaccurate, the results may reflect directly into the software delivery, causing customer dissatisfaction or decreased product quality. The success or failure of projects depends on the accuracy of the effort and the schedule of involved activities. The rise of agile methods in software development has presented many opportunities and challenges for researchers and professionals. In this context, a key challenge is the effort estimate for maintenance activities in the agile software development context. This work presents a framework, called GiveMe Effort, to support the effort estimation activities in software maintenance. It is based on historical data and software comprehension information.
|
153 |
A framework for test case prioritization in the continuous software engineeringCampos Junior, Heleno de Souza 19 September 2018 (has links)
Submitted by Geandra Rodrigues (geandrar@gmail.com) on 2018-10-30T13:39:57Z
No. of bitstreams: 1
helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5) / Approved for entry into archive by Adriana Oliveira (adriana.oliveira@ufjf.edu.br) on 2018-11-23T12:26:30Z (GMT) No. of bitstreams: 1
helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5) / Made available in DSpace on 2018-11-23T12:26:30Z (GMT). No. of bitstreams: 1
helenodesouzacamposjunior.pdf: 1434985 bytes, checksum: 4307be9bfd2ca9825bcd2ce10bfc824e (MD5)
Previous issue date: 2018-09-19 / CAPES - Coordenação de Aperfeiçoamento de Pessoal de Nível Superior / Testes de regressão são executados após cada mudança no software. Em ambientes de desenvolvimento de software que adotam práticas da Engenharia de Software Contínua, como a Integração contínua, por exemplo, software é modificado, e testado diversas vezes em curtos prazos. Cada execução dos testes pode levar horas para terminar, gerando atraso em relação à descoberta de falhas no projeto. Para prevenir esse atraso, técnicas de otimização são utilizadas. Uma delas é a priorização de casos de testes (TCP). Nessa técnica, a execução dos testes é reordenada de acordo com um objetivo, que normalmente é a detecção de falhas. Dessa forma, testes que têm maior probabilidade de falhas são executados primeiro. Um problema com essa abordagem é que existem diversas técnicas na literatura, mas pouca evidência em relação ao seu uso. Além disso, quase não existe infra estrutura para apoiar a adoção dessas técnicas no contexto industrial. O objetivo deste trabalho é planejar e implementar um framework que permita o uso, experimentação e implementação de técnicas de TCP. Esperamos que isso ajude praticantes a adotar essas técnicas no contexto industrial, principalmente da engenharia de software continua. Esperamos também que a criação dessa infra estrutura ajude pesquisadores a executar mais estudos experimentais sobre a eficiência do uso dessas técnicas. Para mostrar a viabilidade do framework proposto, é executado um estudo experimental com 16 técnicas de priorização diferentes, executadas em um total de 22 versões de 2 projetos open source. Os resultados coletados sugerem que o uso das técnicas de priorização resultam em retornos mais rápidos em relação à existência de falhas nos projetos, possivelmente resultando em ciclos mais rápidos de desenvolvimento. / Regression tests are executed after every change in software. In a software development environment that adopts Continuous Software Engineering practices such as Continuous Integration, software is changed, built and tested many times in a short period. Each execution can take hours to finish, delaying feedback about failures to the developer. To prevent this, regression test optimization techniques are used. One such technique is test case prioritization (TCP), which reorder the execution of the test cases according to some goal. The most common goal is fault detection, in which test cases are ordered so that those that have higher probability of detecting faults are executed first. One problem with this approach is that there are lots of different available techniques in the literature, but the amount of evidence of its use is low. Furthermore, there is almost no infrastructure support to adopt those techniques at the industry context. The goal of this work is to design and implement a framework that allows the use, experimentation and implementation of TCP techniques. We hope that this will help practitioners on adopting these techniques at the industry context, more specifically, in the continuous software engineering environment. We also hope that creating this infrastructure will encourage researchers on performing more empirical studies regarding test case prioritization techniques effectiveness. In order to show the feasibility of the proposed framework, we perform an empirical study with 16 different TCP techniques executed on a total of 22 versions of 2 different open source
projects. Results suggest that using those TCP techniques result in faster feedback about the existence of failures in the projects, possibly resulting in shorter development cycles.
|
154 |
Evolução de arquiteturas de linhas de produtos baseadas em componentes e aspectos / Evolution of component and aspect-based product line architecturesTizzei, Leonardo Pondian, 1980- 07 June 2012 (has links)
Orientador: Cecília Mary Fischer Rubira / Tese (doutorado) ¿ Universidade Estadual de Campinas, Instituto de Computação / Made available in DSpace on 2018-08-21T03:56:22Z (GMT). No. of bitstreams: 1
Tizzei_LeonardoPondian_D.pdf: 4801081 bytes, checksum: 4be6c243f0c9f62c50e330561161fcdd (MD5)
Previous issue date: 2012 / Resumo: Arquiteturas de linhas de produtos são essenciais para facilitar a evolução das linhas, pois ajudam a lidar com sua complexidade, abstraindo seus detalhes de implementação. A variabilidade arquitetural difere arquiteturas de linhas de produtos de arquiteturas de sistemas únicos. Ela reflete a existência de alternativas de projeto arquitetural e é expressa por meio de um conjunto de pontos de variação e variantes arquiteturais. A variabilidade arquitetural pode dificultar a evolução de arquiteturas de linhas produtos, pois a implementação da variabilidade software pode aumentar a complexidade da arquitetura com a possível adição de elementos e dependências extras. A variabilidade de linhas de produtos é usualmente capturada modelo de características e implementado pela arquitetura de linha de produtos. Entretanto, a implementação de características, pontos de variação e variantes podem estar espalhados por diversos elementos arquiteturais, o que dificulta a sua evolução. Em geral, cenários de evolução de linhas de produto envolvem adição e/ou remoção de características, mudança de uma característica obrigatória para opcional, entre outros. Quando cenários de evolução afetam características cujas implementações estão espalhadas na arquitetura, eles podem causar impacto de mudança em vários elementos arquiteturais. Estudos recentes exploram o uso de aspectos para modularizar a implementação de características em arquiteturas de linhas de produtos. Aspectos são usados para modularizar interesses transversais que, no contexto de linhas de produtos, são interesses que afetam diversas características. Contudo, esses estudos não consideram (i) arquiteturas componentizadas com interfaces explícitas e (ii) o uso integrado de componentes e aspectos para modularizar a implementação da variabilidade arquitetural. Idealmente aspectos devem ser modelados o mais cedo possível, de preferência, junto com o modelo de características para possibilitar a criação de arquiteturas bem estruturadas com aspectos. Todavia, não existem modelos que integrem o modelo de características e aspectos, nem métodos que consideram aspectos para gerar arquiteturas de linhas produtos a partir do modelo de características. A solução proposta nesta tese envolve inicialmente um estudo comparativo para mostrar a facilidade de evolução de arquiteturas de linhas de produtos propiciada pelo uso integrado de componentes e aspectos. Em seguida, é proposta uma visão estendida do modelo de características que permite representar características transversais. Essa visão, chamada de visão de características orientada a aspectos, é usada para criar arquiteturas de linhas de produtos orientadas a aspectos. Além disso, um modelo arquitetural de componentes é estendido para integrar aspectos para modularizar a variabilidade arquitetural. Por fim, o método FArM, que provê o mapeamento de modelo de características para modelos de arquitetura de linha de produtos, é estendido para considerar características transversais. Foram conduzidos dois estudos empíricos: um para avaliar se o uso integrado de componentes e aspectos facilita ou não a evolução de arquiteturas de linhas de produtos. O outro estudo empírico avalia a modelagem de características transversais e a extensão do método FArM propostos para projetar arquiteturas de linhas de produtos que sejam fáceis de evoluir. Os dois estudos apresentaram resultados promissores indicando que a solução proposta nesta tese facilita a evolução de arquiteturas de linhas de produtos / Abstract: Product line architectures are essential to facilitate the evolution of product lines, as they handle their complexity by abstracting implementation details. Architectural variability is what differs product line architectures from single system architectures. It reflects the existence of alternative design options and it is expressed by a set of architectural variation points and variants. Architectural variability can hinder product line architecture evolution because the implementation of software variability can increase architecture complexity by possibly adding extra elements and dependencies. Product line variability is usually captured in the feature model and it is implemented by product line architectures. However, the implementation of features, variation points, and variants may be scattered over architectural elements, which can hinder its evolution. In general, product line evolution scenarios involve feature addition/removal, changing a mandatory feature to an optional feature, and so forth. When evolution scenarios affect features whose implementations are scattered over architecture, they can cause a great change impact on several architectural elements. Recent studies have explored the use of aspects to modularize feature implementation in product line architectures. Aspects can modularize crosscutting concerns, which, in the context of product lines, are concerns that affect several features. Nevertheless, these studies do not consider (i) componentized architectures with explicit interfaces, and (ii) the integration of aspects and components to modularize the implementation of architectural variability. Ideally, aspects should be modeled as soon as possible, preferably, together with the feature model in order to enable the design of well structured product line architectures with aspects. However, there are neither models which integrate features and aspects, nor methods that considers aspects to design product line architectures from the feature model. The solution proposed in this thesis involves a comparative study that presents the support for product line architecture evolution provided by the integration of components and aspects. Then, it is proposed an extended view of the feature model which enables to represent crosscutting features. This view, called aspect-oriented feature view, is used to design product line architectures with aspects. Lastly, the FArM method, which provides guidelines to map from the feature model to the product line architecture model, is extended to consider crosscutting features. Two empirical studies were conducted: one to assess whether the integration of components and aspects facilitates product line architecture evolution. The other empirical study evaluates whether the crosscutting feature modeling and the FArM method extension proposed supports the design of evolvable product line architectures. Both studies presented promising results which indicate that the solution proposed in this thesis facilitates product line architecture evolution / Doutorado / Ciência da Computação / Doutor em Ciência da Computação
|
155 |
Adaptive Grid Meta Scheduling - A QoS PerspectiveNainwal, Kalash Chandra 05 1900 (has links) (PDF)
No description available.
|
156 |
Towards using fluctuations in internal quality metrics to find design intentsSchweizer, Thomas 01 1900 (has links)
Le contrôle de version est la pierre angulaire des processus de développement de logiciels modernes. Tout en
construisant des logiciels de plus en plus complexes, les développeurs doivent comprendre des sous-systèmes de code
source qui leur sont peu familier. Alors que la compréhension de la logique d'un code étranger est relativement simple,
la compréhension de sa conception et de sa genèse est plus compliquée. Elle n'est souvent possible que par les
descriptions des révisions et de la documentation du projet qui sont dispersées et peu fiables -- quand elles existent.
Ainsi, les développeurs ont besoin d'une base de référence fiable et pertinente pour comprendre l'historique des projets
logiciels. Dans cette thèse, nous faisons les premiers pas vers la compréhension des motifs de changement dans les
historiques de révision. Nous étudions les changements prenant place dans les métriques logicielles durant l'évolution
d'un projet.
Au travers de multiples études exploratoires, nous réalisons des expériences quantitatives et qualitatives sur plusieurs
jeux de données extraits à partir d'un ensemble de 13 projets. Nous extrayons les changements dans les métriques
logicielles de chaque commit et construisons un jeu de donnée annoté manuellement comme vérité de base.
Nous avons identifié plusieurs catégories en analysant ces changements. Un motif en particulier nommé "compromis", dans
lequel certaines métriques peuvent s'améliorer au détriment d'autres, s'est avéré être un indicateur prometteur de
changements liés à la conception -- dans certains cas, il laisse également entrevoir une intention de conception
consciente de la part des auteurs des changements. Pour démontrer les observations de nos études exploratoires, nous
construisons un modèle général pour identifier l'application d'un ensemble bien connu de principes de conception dans de
nouveaux projets.
Nos résultats suggèrent que les fluctuations de métriques ont le potentiel d'être des indicateurs pertinents pour gagner
des aperçus macroscopiques sur l'évolution de la conception dans l'historique de développement d'un projet. / Version control is the backbone of the modern software development workflow. While building more and more complex
systems, developers have to understand unfamiliar subsystems of source code. Understanding the logic of unfamiliar code
is relatively straightforward. However, understanding its design and its genesis is often only possible through
scattered and unreliable commit messages and project documentation -- when they exist.
Thus, developers need a reliable and relevant baseline to understand the history of software projects. In this thesis,
we take the first steps towards understanding change patterns in commit histories. We study the changes in software
metrics through the evolution of projects.
Through multiple exploratory studies, we conduct quantitative and qualitative experiments on several datasets extracted
from a pool of 13 projects. We mine the changes in software metrics for each commit of the respective projects and
manually build oracles to represent ground truth.
We identified several categories by analyzing these changes. One pattern, in particular, dubbed "tradeoffs", where some
metrics may improve at the expense of others, proved to be a promising indicator of design-related changes -- in some
cases, also hinting at a conscious design intent from the authors of the changes. Demonstrating the findings of our
exploratory studies, we build a general model to identify the application of a well-known set of design principles in
new projects.
Our overall results suggest that metric fluctuations have the potential to be relevant indicators for valuable
macroscopic insights about the design evolution in a project's development history.
|
157 |
[pt] COMPLETUDE DE REFATORAÇÕES COMPOSTAS DE CÓDIGO-FONTE PARA A REMOÇÃO BENÉFICA DE ANOMALIAS DE CÓDIGO / [en] ON THE COMPLETENESS OF COMPOSITE CODE REFACTORINGS FOR BENEFICIAL SMELL REMOVAANA CARLA GOMES BIBIANO 22 June 2023 (has links)
[pt] A refatoração de código é uma transformação de código que visa aprimorar
a estrutura interna do código. Uma refatoração isolada raramente é
suficiente para remover completamente uma estrutura de código ruim, como
uma anomalia de código. Os desenvolvedores então aplicam refatorações
compostas para remover totalmente uma anomalia de código. Uma refatoração
composta consiste em duas ou mais refatorações inter-relacionadas. Um
refatoração composta é considerada completa quando elimina totalmente
a anomalia de código alvo. Estudos relatam que os desenvolvedores geralmente
falham em remover completamente as anomalias de código alvo por
meio de refatorações compostas. Refatorações compostas concluídas podem
não ser totalmente benéficas para a estrutura do código. Pois, estas podem
induzir efeitos colaterais, como a introdução de anomalias de código ou a
propagação de anomalias existentes. Há uma compreensão limitada sobre
a completude das refatorações compostas e seus possíveis efeitos colaterais.
Esta tese investiga como as refatorações compostas removem totalmente
as anomalias de código sem induzir efeitos colaterais. Descobrimos que 64 por cento
das refatorações compostas completas são formadas por tipos de refatoração
não recomendados anteriormente. Dessa forma, derivamos um catálogo de
recomendações para apoiar os desenvolvedores na aplicação de refatorações
compostas. Na avaliação do catálogo, 85 por cento de 21 desenvolvedores relataram
que usariam as recomendações do catálogo e que suas próprias soluções
de refatoração teriam induzido efeitos colaterais. Também avaliamos qualitativamente
três abordagens existentes para recomendar automaticamente
refatorações compostas. Nesse estudo, a maioria (80 por cento) dos 10 desenvolvedores
relatou que as abordagens existentes frequentemente induzem efeitos
colaterais. No geral, as descobertas e o catálogo proposto podem ajudar os
desenvolvedores a realizar refatorações compostas completas. / [en] Code refactoring is a code transformation that aims to enhance the
internal code structure. A single refactoring is rarely sufficient to achieve the
full removal of a poor code structure, such as a code smell. Developers then
apply composite refactorings to fully remove a code smell. A composite
refactoring (or, simply, composite) consists of two or more interrelated
single refactorings. A composite is considered complete when it fully
eliminates the target smell. However, studies report that developers often
fail in completely removing target code smells through composites. Even
when composite refactorings are complete they may still not be entirely
beneficial to the code structure. They may induce side effects, such as the
introduction of new smells or the propagation of existing ones. There is a
limited understanding of the completeness of composite refactorings and
their possible effects on structural quality. This thesis investigates whether
and how composite refactorings fully remove smells without inducing side
effects. We found that 64 per cent of complete composites in several software
projects are formed of refactoring types not previously recommended in the
literature. Based on this study, we derived a catalog of recommendations
for supporting developers in applying composite refactorings. Out of twenty
one developers evaluating our catalog, 85 per cent reported that they would use
the catalog recommendations and that their own refactoring solutions
would have induced side effects. We also qualitatively evaluated three
existing approaches to automatically recommend composite refactorings.
In our study with ten developers, most (80 per cent) developers reported that
existing approaches frequently induce side effects. Overall, the findings and
the proposed catalog can help developers to perform complete composite
refactorings with better awareness of possible side effects.
|
158 |
Analysis Techniques for Software MaintenancePérez Rubio, Sergio 05 May 2023 (has links)
[ES] Vivimos en una sociedad donde la digitalización está presente en nuestro día a día. Nos despertamos con la alarma de nuestro teléfono móvil, apuntamos nuestras reuniones en nuestro calendario digital, guardamos nuestros archivos en el almacenamiento en la nube, y entramos a las redes sociales prácticamente a diario. Cada una de estas acciones se ejecuta sobre un sistema software que asegura su correcto funcionamiento. Esta digitalización masiva ha hecho que el desarrollo de software se dispare en los últimos años. Durante el ciclo de vida de un sistema software, la etapa de mantenimiento supone un gasto de billones de dólares anuales. La razón detrás de este gasto es la aparición de bugs o errores que no fueron detectados durante la fase de producción del software, y que se traducen en un mal funcionamiento del sistema. Por este motivo, las técnicas de detección y localización de errores como el testeo, la verificación o la depuración son un factor clave para asegurar la calidad del software.
Aunque son muchas las técnicas que se utilizan para la depuración, testeo y verificación de sistemas software, esta tesis se centra solo en algunas de ellas. En concreto, esta tesis presenta mejoras en la técnica de fragmentación de programas (depuración), una nueva metodología para hacer testeo de regresión (testeo) y una nueva implementación del modelo de verificación de diseño-por-contrato para el lenguaje de programación Erlang (verificación).
Las mejoras propuestas para la técnica de fragmentación de programas incluyen diversas propuestas aplicables a diferentes escenarios: (i) mejoras en la representación y fragmentación de programas orientados a objetos, (ii) mejoras en la representación y fragmentación de estructuras de datos complejas (objetos, vectores, listas, tuplas, registros, etc.), (iii) un nuevo modelo de grafo basado en una representación más detallada de programas, aumentando la expresividad del grafo y generando fragmentos de código más precisos como resultado, y (iv) una nueva técnica para calcular fragmentos mínimos de un programa dado un conjunto específico de posibles valores de entrada.
Por otro lado, la nueva metodología para hacer testeo de regresión se denomina testeo de punto de interés, e introduce la posibilidad de comparar automáticamente el comportamiento de un punto cualquiera del código dadas dos versiones del mismo sistema software.
Por último, la tesis contiene la nueva implementación del modelo de verificación de programas diseño-por-contrato para el lenguaje de programación Erlang, donde se explican en detalle los nuevos tipos de contratos diseñados para las partes secuencial y concurrente de Erlang.
Todos los análisis presentados en esta tesis han sido formalmente definidos y su corrección ha sido probada, asegurando de esta manera que los resultados tendrán el grado de fiabilidad necesario para ser aplicados a sistemas reales.
Otra contribución de esta tesis es la implementación de dos herramientas de fragmentación de programas para dos lenguajes de programación diferentes (Java y Erlang), una herramienta para realizar testeo de punto de interés para el lenguaje de programación Erlang y un sistema para ejecutar verificación de diseño-por-contrato en Erlang. Es de destacar que todas las herramientas implementadas a lo largo del desarrollo de esta tesis son herramientas de código abierto y públicamente accesibles, de manera que pueden ser usadas o extendidas por cualquier investigador interesado en este area. / [CA] Vivim en una societat on la digitalització està present al nostre dia a dia. Ens alcem amb l'alarma del nostre telèfon mòbil, apuntem les nostres reunions al nostre calendari digital, guardem els nostres arxius al emmagatzematge al núvol, i entrem a las xarxes socials pràcticament a diari. Cadascuna d'aquestes accions s'executa sobre un sistema programari que assegura el seu correcte funcionament. Aquesta digitalizació massiva ha fet que el desenvolupament de programari es dispare en els últims anys. Durant el cicle de vida de un sistema programari, l'etapa de manteniment suposa una despesa de bilions de dòlars anuals. La raó darrere d'aquesta despesa és l'aparició de bugs o errors que no van ser detectats durant la fase de producció del programari, i que es traduïxen en un mal funcionament del sistema Per este motiu, les tècniques de detecció i localització d'errors com el testeig, la verificació o la depuració són un factor clau per a assegurar la qualitat del programari.
Encara que són moltes les tècniques utilitzades per a la depuració, testeig i verificació de sistemes programari, esta tesi es centra només en algunes d'elles. En concret, esta tesi presenta millores en la tècnica de fragmentació de programes (depuració), una nova metodologia per a fer testeig de regressió (testeig) i una nova implementació del model de verificació de disseny-per-contracte per al llenguatge de programació Erlang (verificació).
Les millores proposades per a la tècnica de fragmentació de programes inclouen diverses propostes aplicables a diferents escenaris: (i) millores en la representació i fragmentació de programes orientats a objectes, (ii) millores en la representació i fragmentació d'estructures de dades complexes (objectes, vectors, llistes, tuples, registres, etc.), (iii) un nou model de graf basat en una representació més detallada de programes, augmentant l'expressivitat del graf i generant fragments de codi més precisos com a resultat, i (iv) una nova tècnica per a calcular fragments mínims d'un programa donat un conjunt específic de possibles valors d'entrada.
D'altra banda, la nova metodologia per a fer testeig de regressió es denomina testeig de punt d'interés, i introduïx la possibilitat de comparar automàticament el comportament d'un punt qualsevol del codi donades dos versions del mateix sistema programari.
Finalment, la tesi conté la nova implementació del model de verificació de programes disseny-per-contracte per al llenguatge de programació Erlang, on s'expliquen en detall els nous tipus de contractes dissenyats per a les parts seqüencial i concurrent d'Erlang.
Totes les anàlisis presentades en aquesta tesi han sigut formalment definides i la seua correcció ha sigut provada, assegurant d'aquesta manera que els resultats tindran el grau de fiabilitat necessari per a ser aplicats a sistemes reals.
Una altra contribució d'aquesta tesi és la implementació de dos ferramentes de fragmentació de programes per a dos llenguatges de programació diferents (Java i Erlang), una ferramenta per a realitzar testeig the punt d'interés per al llenguatge de programació Erlang i un sistema per a executar verificació de disseny-per-contracte a Erlang. Cal destacar que totes les ferramentes implementades al llarg del desenvolupament d'aquesta tesi són ferramentes de codi obert i públicament accessibles, de manera que poden ser usades o esteses per qualsevol investigador interessat en el tema. / [EN] We live in a society where digitalisation is present in our everyday life. We wake up with the alarm of our mobile phone, book our meetings in our digital calendar, save all our media in the cloud storage, and spend time in social networks almost daily. Every one of these tasks is run over a software system that ensures its correct functionality. This massive digitalisation has made software development to shoot up in the last years. During the lifetime of software systems, the maintenance process entails a waste of billions of dollars every year. The cause of this waste is the occurrence of bugs or errors undetected during the software production, which result in a malfunction of the system. For this reason, error detection and localisation techniques, such as testing, verification, or debugging, are a key factor to ensure software quality.
Although many different techniques are used for the debugging, testing, and verification of software systems, this thesis focus on only some of them. In particular, this thesis presents improvements in the program slicing technique (debugging field), a new approach for regression testing (testing field), and a new implementation of the design-by-contract verification model for the Erlang programming language (verification field).
The improvements proposed for the program slicing technique include several enhancements applicable to different scenarios: (i) improvements in the representation and slicing of object-oriented programs, (ii) enhancements in the representation and slicing of (possibly recursive) complex data structures (objects, arrays, lists, tuples, records, etc.), (iii) a new graph model based on a fine-grained representation of programs that augments the expressivity of the graph and provides more accurate slicing results, and (iv) a new technique to compute minimal slices for a program given a set of specific program inputs.
On the other side, the new approach for regression testing is called point of interest testing, and it introduces the possibility of automatically comparing the behaviour of any arbitrary point in the code given two versions of the same software system.
Finally, the thesis presents a new implementation of the design-by-contract verification model for the Erlang programming language, where new types of contracts are explained in detail for both the sequential and concurrent parts of Erlang.
All the analyses presented here have been formally defined and their correctness have been proved, ensuring that the results will have the reliability degree needed for real-life systems. Another contribution of this thesis is the implementation of two program slicers for two different programming languages (Java and Erlang), a tool to perform point of interest testing for the Erlang programming language, and a system to run design-by-contract verification in Erlang. It is worth mentioning that all the tools implemented in this thesis are open source and publicly available, so they can be used or extended by any interested researcher. / Pérez Rubio, S. (2023). Analysis Techniques for Software Maintenance [Tesis doctoral]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/193146
|
159 |
Supporting Source Code Comprehension During Software Evolution and MaintenanceAlhindawi, Nouh Talal 30 July 2013 (has links)
No description available.
|
160 |
Part-of-Speech Tagging of Source Code Identifiers using Programming Language Context Versus Natural Language ContextAlSuhaibani, Reem Saleh 03 December 2015 (has links)
No description available.
|
Page generated in 0.0791 seconds