Spelling suggestions: "subject:"refactoring""
1 |
Structured representation of composite software changesChabra, Aarti 13 December 2011 (has links)
In a software development cycle, programs go through many iterations. Identifying and
understanding program changes is a tedious but necessary task for programmers, especially when
software is developed in a collaborative environment. Existing tools used by the programmers
either lack in finding the structural differences, or report the differences as atomic changes, such as
updates of individual syntax tree nodes.
Programmers frequently use program restructuring techniques, such as refactorings that are
composed of several individual atomic changes. Current version differencing tools omit these
high-level changes, reporting just the set of individual atomic changes. When a large number of
refactorings are performed, the number of reported atomic changes is very large. As a result, it will
be very difficult to understand the program differences.
This problem can be addressed by reporting the program differences as composite changes, thereby
saving programmers the effort of navigating through the individual atomic changes. This thesis
proposes a methodology to explore the atomic changes reported by existing version differencing
tools to infer composite changes. First, we will illustrate the different approaches that can be used
for representing object language program differences using a variation representation. Next we will
present the process of composite change inference from the structured representation of atomic
changes. This process describes patterns that specify the expected structure of an expression
corresponding to each composite change that has to be inferred. The information in patterns is then
used to design the change inference algorithm. The composite changes inferred from a given
expression are annotated in the expression, allowing the changes to be reported as desired. / Graduation date: 2012
|
2 |
Specification, implementation and verification of refactoringsSchaefer, Max January 2010 (has links)
Refactoring is the process of reorganising or restructuring code by means of behaviour-preserving program transformations, themselves called refactorings. Most modern development environments come with built-in support for refactoring in the form of automated refactorings that the user can perform at the push of a button. Implementing refactorings is notoriously complex, however, and even state-of-the-art implementations have very low standards of correctness and can introduce subtle changes of behaviour into refactored programs. In this thesis, we develop concepts and techniques that make it possible to give concise, modular specifications of refactorings. These specifications are precise enough to cover all details of the object language, and thus give rise to full featured, high-quality refactoring implementations. Their modularity, on the other hand, makes them amenable to formal proof, and hence opens the door to the rigorous verification of refactorings. We discuss a disciplined approach to maintaining name bindings and avoiding name capture by treating the binding from a name to the declaration it refers to as a dependency that the refactoring has to preserve. This approach readily generalises to other types of dependencies for capturing control flow, data flow and synchronisation behaviour. To implement complex refactorings, it is often helpful for the refactoring to internally work on a richer language with language extensions that make the transformation easier to express. We show how this allows the decomposition of refactorings into small microrefactorings that can be specified, implemented and verified in isolation. We evaluate our approach by giving specifications and implementations of many commonly used refactorings that are concise, yet match the implementations in the popular Java development environment Eclipse in terms of features, and outperform them in terms of correctness. We give detailed informal correctness proofs for some of our specifications, which are greatly aided by their modular structure. Finally, we discuss a rigorous formalisation of the central name binding framework used by most of our specifications in the theorem prover Coq, and show how its correctness can be established mechanically.
|
3 |
AIRDoc-An approach to improve the quality of requirements documents: dealing with use case modelsRAMOS, Ricardo Argenton 31 January 2009 (has links)
Made available in DSpace on 2014-06-12T15:52:27Z (GMT). No. of bitstreams: 2
arquivo3299_1.pdf: 8413271 bytes, checksum: f7e2f7602fa26d4744d748c1d3ff2002 (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2009 / Conselho Nacional de Desenvolvimento Científico e Tecnológico / Documentos de requisitos tendem a ser inundados por requisitos tais como: descrições
sem semântica, desnecessariamente longas e confusas, informações duplicadas, entre
outros problemas. Estes problemas sintáticos diminuem a facilidade de entendimento de
todo o documento de requisitos e podem prejudicar outras fases do processo de
desenvolvimento do software. Avaliações de qualidade não ajudam muito se somente
são baseadas em listas com qualidades desejadas. Elas devem também incorporar
diretrizes para auxiliar na avaliação e melhoria dos documentos de requisitos. O
processo AIRDoc surge como uma solução para avaliar e melhorar documentos de
requisitos que foram descritos usando casos de uso. O processo proposto é baseado na
definição de objetivos e questões que devem ser avaliadas por métricas. A qualidade dos
modelos de casos de uso é melhorada com a utilização de refatorações
|
4 |
Dynamic Software Update for Production and Live Programming Environments / Mise à jour Dynamique pour Environnemts de Production et Programmation InteractiveTesone, Pablo 17 December 2018 (has links)
Mettre à jour des applications durant leur exécution est utilisé aussi bien en production pour réduire les temps d’arrêt des applications que dans des environnements de développement interactifs (IDE pour live programming). Toutefois, ces deux scénarios présentent des défis différents qui font que les solutions de mise à jour dynamique (DSU pour Dynamic Software Updating) existantes sont souvent spécifiques à l’un des deux. Par exemple, les DSUs pour la programmation interactives ne supportent généralement pas la détection automatique de points sûrs de mise à jour ni la migration d’instances, alors que les DSUs pour la production nécessitent une génération manuelle de l’ensemble des modifications et manquent d’intégration avec l’IDE. Les solutions existantes ont également une capacité limitées à se mettre à jour elles-mêmes ou à mettre à jour les bibliothèques de base du langage ; et certaines d’entre elles introduisent mêmle une dégradation des performances d’exécution en dehors du processus de mise à jour.Dans cette thèse, nous proposons un DSU (nommé gDSU) unifié qui fonctionne à la fois pour la programmation interactive et les environnements de production. gDSU permet la détection automatique des points sûrs de mise à jour en analysant et manipulant la pile d’exécution, et offre un mécanisme réutilisable de migration d’instances afin de minimiser les interventions manuelles lors de l’application d’une migration. gDSU supporte également la mise à jour des bibliothèques du noyau du langage et du mécanisme de mise à jour lui-même. Ceci est réalisé par une copie incrémentale des objets à modifier et une application atomique de ces modifications.gDSU n’affecte pas les performances globales de l’application et ne présente qu’une pénalité d’exécution lors processus de mise à jour. Par exemple, gDSU est capable d’appliquer une mise à jour sur 100 000 instances en 1 seconde. Durant cette seconde, l’application ne répond pas pendant 250 milli-secondes seulement. Le reste du temps, l’application s’exécute normalement pendant que gDSU recherche un point sûr de mise à jour qui consiste alors uniquement à copier les éléments modifiés.Nous présentons également deux extensions de gDSU permettant un meilleur support du développement interactif dans les IDEs : la programmation interactive transactionnelle et l’application atomique de reusinages (refactorings). / Updating applications during their execution is used both in production to minimize application downtine and in integrated development environments to provide live programming support. Nevertheless, these two scenarios present different challenges making Dynamic Software Update (DSU) solutions to be specifically designed for only one of these use cases. For example, DSUs for live programming typically do not implement safe point detection or insistance migration, while production DSUs require manual generation of patches and lack IDE integration. These sollutions also have a limited ability to update themselves or the language core libraries and some of them present execution penalties outside the update window.In this PhD, we propose a unified DSU named gDSU for both live programming and production environments. gDSU provides safe update point detection using call stack manipulation and a reusable instance migration mechanism to minimize manual intervention in patch generation. It also supports updating the core language libraries as well as the update mechanism itself thanks to its incremental copy of the modified objects and its atomic commit operation.gDSU does not affect the global performance of the application and it presents only a run-time penalty during the window. For example, gDSU is able to apply an update impacting 100,000 instances in 1 second making the application not responsive for only 250 milliseconds. The rest of the time the applications runs normally while gDSU is looking for a safe update point during which modified elements will be copied.We also present extensions of gDSU to support transactional live programming and atomic automactic refactorings which increase the usability of live programming environments.
|
5 |
Recuperação de modelos de classes orientados a aspectos a partir de sistemas orientados a objetos usando refatorações de modelos.Parreira Júnior, Paulo Afonso 27 May 2011 (has links)
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.
|
6 |
[en] ALIGNING DEVELOPER QUALITY CONCERNS, REFACTORING APPLICATIONS, AND THEIR EFFECTS / [pt] ALINHANDO PREOCUPAÇÕES DE QUALIDADE DE DESENVOLVEDORES A APLICAÇÕES DE REFATORAÇÕES E SEUS EFEITOSVINICIUS PASSOS DE OLIVEIRA SOARES 25 November 2021 (has links)
[pt] Mesmo com o processo de refatoração sendo investigado cada vez mais
nos últimos anos, muitas de suas características se mantém pouco compreendidas.
Refatoração de software é o processo de melhorar a manutenibilidade
de um sistema por meio de mudanças estruturais que não alteram seu comportamento.
Estudos recentes revelaram que projetos de software frequentemente
recebem refatorações compostas. Em tais refatorações, desenvolvedores aplicam
uma série de transformações únicas em conjunção e em um único commit,
e se espera que estas refatorações tenham um efeito maior e mais positivo do
que refatorações singulares. Porém, refatorações frequentemente causam mudanças
que ou mantém a qualidade do software da mesma forma, ou causam
a piora do mesmo, levando trabalhos recentes a procurar causas em potencial
para este comportamento. Porém, o porquê da complexidade destas mudanças
compostas frequentemente afetarem seus resultados de alguma forma positiva
ou (inesperadamente) negativa continua não investigado. O mesmo ocorre com
o potencial efeito das preocupações dos desenvolvedores durante a aplicação
de refatorações. Sobre estas preocupações, alguns trabalhos anteriores foram
desenvolvidos em torno da caracterização e detecção de discussões de desenvolvedores
relacionadas a refatorações. Porém, não se sabe se e como estas
preocupações de desenvolvedores com refatorações, tornando-se explícitas em
tais discussões, podem influenciar os efeitos de refatorações em um sistema.
Portanto, este trabalho apresenta dois estudos com o objetivo de preencher a
lacuna no conhecimento de que causas levam aos efeitos não-positivos frequentemente
encontrados em refatorações, procurando entender: (i) se refatorações
mais complexas realmente são mais efetivas do que refatorações simples, como
esperado; (ii) em que situações desenvolvedores tendem a explicitar suas preocupações
com refatoração do código; e (iii) qual é o impacto de tais preocupações
na efetividade de uma refatoração em melhorar a qualidade estrutural
do código. Nós analisamos estas características e atingimos os seguintes
resultados: Primeiro, conforme a complexidade das refatorações aumenta, a
efetividade das mesmas aumenta conjuntamente. Segundo, há uma relação entre
a efetividade de refatorações e preocupações explícitas com refatorações,
onde a possibilidade de efeitos negativos é menor quando desenvolvedores estão
explicitamente preocupados com refatoração. Finalmente, desenvolvedores
tendem a explicitar mais frequentemente suas preocupações com o processo de
refatoração quando deparados com tarefas de refatoração mais complexas. / [en] Even though the refactoring process has been increasingly investigated
in the last years, many of its characteristics remain poorly understood. Software
refactoring is the process of improving the maintainability of a system
through structural changes that do not alter its behaviour. Recent studies revealed
that software projects frequently have to undergo composite refactorings.
In such refactorings, developers perform a series of single transformations in
conjunction and in a single commit, which are expected to have a larger and
more positive impact than single refactorings. However, refactorings frequently
cause changes that either keep the software quality the same, or cause it
to worsen, which lead recent works to look for potential causes of this behavior.
However, the complexity of these composite changes often affecting their
outcomes in some positive or (unexpectedly) negative way remains not investigated,
much like the developers concerns while performing refactoring. For
the latter, some previous work was performed around characterizing and detecting
refactoring-related developer discussions. However, it is unknown whether
and how developers refactoring concerns made explicit in such discussions can
influence the refactorings effects on a system. Thus, this work reports two
studies aimed at bridging some of those gaps in knowledge in which causes
lead to the non-positive effects frequently found in refactoring, by understanding:
(i) if more complex refactorings are indeed more effective than simple
refactorings, as one would expect; (ii) in which situations developers tend to
have explicit concerns while refactoring the code; and (iii) what is the impact
of such concerns on the effectiveness of a refactoring to improve structural
quality. We analyze these characteristics and reach the following results: First,
as refactoring complexity increases, the effectiveness of such refactorings increases
as well. Second, there is a relationship between refactoring effectiveness
and explicit refactoring concerns, in which the possibility of negative effects
is lower when developers are explicitly concerned about refactoring. Finally,
developers tend to be more explicit about their concerns on the refactoring
process when they are faced with more complex refactoring tasks.
|
7 |
Impacts and Detection of Design SmellsMaiga, Abdou 08 1900 (has links)
Les changements sont faits de façon continue dans le code source des logiciels pour prendre en compte les besoins des clients et corriger les fautes. Les changements continus peuvent conduire aux défauts de code et de conception. Les défauts de conception sont des mauvaises solutions à des problèmes récurrents de conception ou d’implémentation, généralement dans le développement orienté objet. Au cours des activités de compréhension et de changement et en raison du temps d’accès au marché, du manque de compréhension, et de leur expérience, les développeurs ne peuvent pas toujours suivre les normes de conception et les techniques de codage comme les patrons de conception. Par conséquent, ils introduisent des défauts de conception dans leurs systèmes. Dans la littérature, plusieurs auteurs ont fait valoir que les défauts de conception rendent les systèmes orientés objet plus difficile à comprendre, plus sujets aux fautes, et plus difficiles à changer que les systèmes sans les défauts de conception. Pourtant, seulement quelques-uns de ces auteurs ont fait une étude empirique sur l’impact des défauts de conception sur la compréhension et aucun d’entre eux n’a étudié l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes.
Dans cette thèse, nous proposons trois principales contributions. La première contribution est une étude empirique pour apporter des preuves de l’impact des défauts de conception sur la compréhension et le changement. Nous concevons et effectuons deux expériences avec 59 sujets, afin d’évaluer l’impact de la composition de deux occurrences de Blob ou deux occurrences de spaghetti code sur la performance des développeurs effectuant des tâches de compréhension et de changement. Nous mesurons la performance des développeurs en utilisant: (1) l’indice de charge de travail de la NASA pour leurs efforts, (2) le temps qu’ils ont passé dans l’accomplissement de leurs tâches, et (3) les pourcentages de bonnes réponses. Les résultats des deux expériences ont montré que deux occurrences de Blob ou de spaghetti code sont un obstacle significatif pour la performance des développeurs lors de tâches de compréhension et de changement. Les résultats obtenus justifient les recherches antérieures sur la spécification et la détection des défauts de conception. Les équipes de développement de logiciels doivent mettre en garde les développeurs contre le nombre élevé d’occurrences de défauts de conception et recommander des refactorisations à chaque étape du processus de développement pour supprimer ces défauts de conception quand c’est possible.
Dans la deuxième contribution, nous étudions la relation entre les défauts de conception et les fautes. Nous étudions l’impact de la présence des défauts de conception sur l’effort nécessaire pour corriger les fautes. Nous mesurons l’effort pour corriger les fautes à l’aide de trois indicateurs: (1) la durée de la période de correction, (2) le nombre de champs et méthodes touchés par la correction des fautes et (3) l’entropie des corrections de fautes dans le code-source. Nous menons une étude empirique avec 12 défauts de conception détectés dans 54 versions de quatre systèmes: ArgoUML, Eclipse, Mylyn, et Rhino. Nos résultats ont montré que la durée de la période de correction est plus longue pour les fautes impliquant des classes avec des défauts de conception. En outre, la correction des fautes dans les classes avec des défauts de conception fait changer plus de fichiers, plus les champs et des méthodes. Nous avons également observé que, après la correction d’une faute, le nombre d’occurrences de défauts de conception dans les classes impliquées dans la correction de la faute diminue. Comprendre l’impact des défauts de conception sur l’effort des développeurs pour corriger les fautes est important afin d’aider les équipes de développement pour mieux évaluer et prévoir l’impact de leurs décisions de conception et donc canaliser leurs efforts pour améliorer la qualité de leurs systèmes. Les équipes de développement doivent contrôler et supprimer les défauts de conception de leurs systèmes car ils sont susceptibles d’augmenter les efforts de changement.
La troisième contribution concerne la détection des défauts de conception. Pendant les activités de maintenance, il est important de disposer d’un outil capable de détecter les défauts de conception de façon incrémentale et itérative. Ce processus de détection incrémentale et itérative pourrait réduire les coûts, les efforts et les ressources en permettant aux praticiens d’identifier et de prendre en compte les occurrences de défauts de conception comme ils les trouvent lors de la compréhension et des changements. Les chercheurs ont proposé des approches pour détecter les occurrences de défauts de conception, mais ces approches ont actuellement quatre limites: (1) elles nécessitent une connaissance approfondie des défauts de conception, (2) elles ont une précision et un rappel limités, (3) elles ne sont pas itératives et incrémentales et (4) elles ne peuvent pas être appliquées sur des sous-ensembles de systèmes. Pour surmonter ces limitations, nous introduisons SMURF, une nouvelle approche pour détecter les défauts de conception, basé sur une technique d’apprentissage automatique — machines à vecteur de support — et prenant en compte les retours des praticiens. Grâce à une étude empirique portant sur trois systèmes et quatre défauts de conception, nous avons montré que la précision et le rappel de SMURF sont supérieurs à ceux de DETEX et BDTEX lors de la détection des occurrences de défauts de conception. Nous avons également montré que SMURF peut être appliqué à la fois dans les configurations intra-système et inter-système. Enfin, nous avons montré que la précision et le rappel de SMURF sont améliorés quand on prend en compte les retours des praticiens. / Changes are continuously made in the source code to take into account the needs of the customers and fix the faults. Continuous change can lead to antipatterns and code smells, collectively called “design smells” to occur in the source code. Design smells are poor solutions to recurring design or implementation problems, typically in object-oriented development. During comprehension and changes activities and due to the time-to-market, lack of understanding, and the developers’ experience, developers cannot always follow standard designing and coding techniques, i.e., design patterns. Consequently, they introduce design smells in their systems. In the literature, several authors claimed that design smells make object-oriented software systems more difficult to understand, more fault-prone, and harder to change than systems without such design smells. Yet, few of these authors empirically investigate the impact of design smells on software understandability and none of them authors studied the impact of design smells on developers’ effort.
In this thesis, we propose three principal contributions. The first contribution is an empirical study to bring evidence of the impact of design smells on comprehension and change. We design and conduct two experiments with 59 subjects, to assess the impact of the composition of two Blob or two Spaghetti Code on the performance of developers performing comprehension and change tasks. We measure developers’ performance using: (1) the NASA task load index for their effort; (2) the time that they spent performing their tasks; and, (3) their percentages of correct answers. The results of the two experiments showed that two occurrences of Blob or Spaghetti Code design smells impedes significantly developers performance during comprehension and change tasks. The obtained results justify a posteriori previous researches on the specification and detection of design smells. Software development teams should warn developers against high number of occurrences of design smells and recommend refactorings at each step of the development to remove them when possible.
In the second contribution, we investigate the relation between design smells and faults in classes from the point of view of developers who must fix faults. We study the impact of the presence of design smells on the effort required to fix faults, which we measure using three metrics: (1) the duration of the fixing period; (2) the number of fields and methods impacted by fault-fixes; and, (3) the entropy of the fault-fixes in the source code. We conduct an empirical study with 12 design smells detected in 54 releases of four systems: ArgoUML, Eclipse, Mylyn, and Rhino. Our results showed that the duration of the fixing period is longer for faults involving classes with design smells. Also, fixing faults in classes with design smells impacts more files, more fields, and more methods. We also observed that after a fault is fixed, the number of occurrences of design smells in the classes involved in the fault decreases. Understanding the impact of design smells on development effort is important to help development teams better assess and forecast the impact of their design decisions and therefore lead their effort to improve the quality of their software systems. Development teams should monitor and remove design smells from their software systems because they are likely to increase the change efforts.
The third contribution concerns design smells detection. During maintenance and evolution tasks, it is important to have a tool able to detect design smells incrementally and iteratively. This incremental and iterative detection process could reduce costs, effort, and resources by allowing practitioners to identify and take into account occurrences of design smells as they find them during comprehension and change. Researchers have proposed approaches to detect occurrences of design smells but these approaches have currently four limitations: (1) they require extensive knowledge of design smells; (2) they have limited precision and recall; (3) they are not incremental; and (4) they cannot be applied on subsets of systems. To overcome these limitations, we introduce SMURF, a novel approach to detect design smells, based on a machine learning technique—support vector machines—and taking into account practitioners’ feedback. Through an empirical study involving three systems and four design smells, we showed that the accuracy of SMURF is greater than that of DETEX and BDTEX when detecting design smells occurrences. We also showed that SMURF can be applied in both intra-system and inter-system configurations. Finally, we reported that SMURF accuracy improves when using practitioners’ feedback.
|
8 |
Impacts and Detection of Design SmellsMaiga, Abdou 08 1900 (has links)
No description available.
|
Page generated in 0.1042 seconds