Test-case-based call graph construction in dynamically typed programming languages

Detalhes bibliográficos
Ano de defesa: 2015
Autor(a) principal: Pereira, Gabriel Maier Fernandes Vidueiro
Orientador(a): Pimenta, Marcelo Soares
Banca de defesa: Não Informado pela instituição
Tipo de documento: Dissertação
Tipo de acesso: Acesso aberto
Idioma: eng
Instituição de defesa: Não Informado pela instituição
Programa de Pós-Graduação: Não Informado pela instituição
Departamento: Não Informado pela instituição
País: Não Informado pela instituição
Palavras-chave em Português:
Grafos
Linguagens : Programacao
Palavras-chave em Inglês:
Dynamic languages
Source code analysis
Call graphs
Ruby
Link de acesso: http://hdl.handle.net/10183/134355
Resumo: Evolução de software é uma das atividades mais desafiadoras do processo de desenvolvimento de software. Uma importante questão associada à essa atividade é a correta compreensão do código fonte e outros artefatos que necessitam ser mantidos e evoluídos. Visando auxiliar desenvolvedores na manutenção de código, Integrated Development Environments (IDE’s) proporcionam ferramentas que informam desenvolvedores sobre as dependências e as particularidades do código a ser modificado. No entanto, linguagens dinamicamente tipadas não definem tipos explicitamente no código fonte, o que dificulta a análise estática do código e consequentemente a contrução dessas ferramentas. Como exemplo, a construção de call graphs (grafos de chamadas), utilizados pelas IDE’s para criar ferramentas de navegação de código, é prejudicada pela ausência da definição de tipos. Para abordar o problema da criação de call graphs para linguagens dinamicamente tipadas, propomos uma técnica dividida em passos para a construção de um call graph baseado em informações extraídas da execução de testes. A técnica é dividida em 3 passos, o Passo #1 cria um call graph conservativo e estático que resolve chamadas de métodos baseado apenas em nomes dos métodos, ainda no primeiro passo, testes são executados e seu traço de execução é armazenado para posterior análise. O Passo #2 combina a informação armazenada da execução dos testes e o call graph construído no primeiro passo, o Passo #2 também é responsável pela criação de um conjunto de regras de associação que servirão para guiar desenvolvedores durante a criação de novas partes do código. Nossa avaliação em uma aplicação real de porte grande mostrou que a técnica melhora a precisão do call graph criado removendo arestas desnecessárias (70%), e mostrou-se apta a auxiliar desenvolvedores definindo pontos de navegação no código baseada na análise de regras de associação extraídas do test-case-based call graph.
id URGS_bd0665503d34a4268e76b3706b5e840c
oai_identifier_str oai:www.lume.ufrgs.br:10183/134355
network_acronym_str URGS
network_name_str Biblioteca Digital de Teses e Dissertações da UFRGS
repository_id_str
spelling Pereira, Gabriel Maier Fernandes VidueiroPimenta, Marcelo SoaresNunes, Ingrid Oliveira de2016-03-29T02:06:45Z2015http://hdl.handle.net/10183/134355000988394Evolução de software é uma das atividades mais desafiadoras do processo de desenvolvimento de software. Uma importante questão associada à essa atividade é a correta compreensão do código fonte e outros artefatos que necessitam ser mantidos e evoluídos. Visando auxiliar desenvolvedores na manutenção de código, Integrated Development Environments (IDE’s) proporcionam ferramentas que informam desenvolvedores sobre as dependências e as particularidades do código a ser modificado. No entanto, linguagens dinamicamente tipadas não definem tipos explicitamente no código fonte, o que dificulta a análise estática do código e consequentemente a contrução dessas ferramentas. Como exemplo, a construção de call graphs (grafos de chamadas), utilizados pelas IDE’s para criar ferramentas de navegação de código, é prejudicada pela ausência da definição de tipos. Para abordar o problema da criação de call graphs para linguagens dinamicamente tipadas, propomos uma técnica dividida em passos para a construção de um call graph baseado em informações extraídas da execução de testes. A técnica é dividida em 3 passos, o Passo #1 cria um call graph conservativo e estático que resolve chamadas de métodos baseado apenas em nomes dos métodos, ainda no primeiro passo, testes são executados e seu traço de execução é armazenado para posterior análise. O Passo #2 combina a informação armazenada da execução dos testes e o call graph construído no primeiro passo, o Passo #2 também é responsável pela criação de um conjunto de regras de associação que servirão para guiar desenvolvedores durante a criação de novas partes do código. Nossa avaliação em uma aplicação real de porte grande mostrou que a técnica melhora a precisão do call graph criado removendo arestas desnecessárias (70%), e mostrou-se apta a auxiliar desenvolvedores definindo pontos de navegação no código baseada na análise de regras de associação extraídas do test-case-based call graph.Evolving enterprise software systems is one of the most challenging activities of the software development process. An important issue associated with this activity is to properly comprehend the source code and other software assets that must be evolved. To assist developers on these evolution tasks, Integrated Development Environments (IDEs) build tools that provides information about the source code and its dependencies. However, dynamically typed languages do not define types explicitly in the source code, which difficult source code analysis and therefore the construction of these tools. As an example, the call graph construction, used by IDE’s to build source code navigation tools, is hampered by the absence of type definition. To address the problem of constructing call graphs for dynamic languages, we propose a technique based on steps to build a call graph based on test runtime information, called test-case-based call graph. The technique is divided in three steps; Step #1 creates a conservative and static call graph that decides target nodes based on method names, and the first step also run tests profiling its execution; Step #2 combines the test runtime information and the conservative call graph built in the first step to create the test-case-based call graph, it also creates a set of association rules to guide developers in the maintenance while creating new pieces of code; Finally, Step #3 uses the test-case-based call graph and the association rules to assist developers in source code navigation tasks. Our evaluation on a large-size real-world software shows that the technique increases call graph precision removing several unnecessary conservative edges ( %70), and assist developers filtering target nodes of method calls based on association rules extracted from the call graph.application/pdfengGrafosLinguagens : ProgramacaoDynamic languagesSource code analysisCall graphsRubyTest-case-based call graph construction in dynamically typed programming languagesinfo:eu-repo/semantics/publishedVersioninfo:eu-repo/semantics/masterThesisUniversidade Federal do Rio Grande do SulInstituto de InformáticaPrograma de Pós-Graduação em ComputaçãoPorto Alegre, BR-RS2015mestradoinfo:eu-repo/semantics/openAccessreponame:Biblioteca Digital de Teses e Dissertações da UFRGSinstname:Universidade Federal do Rio Grande do Sul (UFRGS)instacron:UFRGSORIGINAL000988394.pdf000988394.pdfTexto completo (inglês)application/pdf1820806http://www.lume.ufrgs.br/bitstream/10183/134355/1/000988394.pdf0386abc80fb81a3a4560472a261e7250MD51TEXT000988394.pdf.txt000988394.pdf.txtExtracted Texttext/plain93332http://www.lume.ufrgs.br/bitstream/10183/134355/2/000988394.pdf.txtaf72639dc3fc6d37bada4da76b61bc28MD52THUMBNAIL000988394.pdf.jpg000988394.pdf.jpgGenerated Thumbnailimage/jpeg1116http://www.lume.ufrgs.br/bitstream/10183/134355/3/000988394.pdf.jpga8d15621a76cc2b6037ff6de68d53aa1MD5310183/1343552021-05-26 04:36:39.33942oai:www.lume.ufrgs.br:10183/134355Biblioteca Digital de Teses e Dissertaçõeshttps://lume.ufrgs.br/handle/10183/2PUBhttps://lume.ufrgs.br/oai/requestlume@ufrgs.br||lume@ufrgs.bropendoar:18532021-05-26T07:36:39Biblioteca Digital de Teses e Dissertações da UFRGS - Universidade Federal do Rio Grande do Sul (UFRGS)false
dc.title.pt_BR.fl_str_mv Test-case-based call graph construction in dynamically typed programming languages
title Test-case-based call graph construction in dynamically typed programming languages
spellingShingle Test-case-based call graph construction in dynamically typed programming languages
Pereira, Gabriel Maier Fernandes Vidueiro
Grafos
Linguagens : Programacao
Dynamic languages
Source code analysis
Call graphs
Ruby
title_short Test-case-based call graph construction in dynamically typed programming languages
title_full Test-case-based call graph construction in dynamically typed programming languages
title_fullStr Test-case-based call graph construction in dynamically typed programming languages
title_full_unstemmed Test-case-based call graph construction in dynamically typed programming languages
title_sort Test-case-based call graph construction in dynamically typed programming languages
author Pereira, Gabriel Maier Fernandes Vidueiro
author_facet Pereira, Gabriel Maier Fernandes Vidueiro
author_role author
dc.contributor.author.fl_str_mv Pereira, Gabriel Maier Fernandes Vidueiro
dc.contributor.advisor1.fl_str_mv Pimenta, Marcelo Soares
dc.contributor.advisor-co1.fl_str_mv Nunes, Ingrid Oliveira de
contributor_str_mv Pimenta, Marcelo Soares
Nunes, Ingrid Oliveira de
dc.subject.por.fl_str_mv Grafos
Linguagens : Programacao
topic Grafos
Linguagens : Programacao
Dynamic languages
Source code analysis
Call graphs
Ruby
dc.subject.eng.fl_str_mv Dynamic languages
Source code analysis
Call graphs
Ruby
description Evolução de software é uma das atividades mais desafiadoras do processo de desenvolvimento de software. Uma importante questão associada à essa atividade é a correta compreensão do código fonte e outros artefatos que necessitam ser mantidos e evoluídos. Visando auxiliar desenvolvedores na manutenção de código, Integrated Development Environments (IDE’s) proporcionam ferramentas que informam desenvolvedores sobre as dependências e as particularidades do código a ser modificado. No entanto, linguagens dinamicamente tipadas não definem tipos explicitamente no código fonte, o que dificulta a análise estática do código e consequentemente a contrução dessas ferramentas. Como exemplo, a construção de call graphs (grafos de chamadas), utilizados pelas IDE’s para criar ferramentas de navegação de código, é prejudicada pela ausência da definição de tipos. Para abordar o problema da criação de call graphs para linguagens dinamicamente tipadas, propomos uma técnica dividida em passos para a construção de um call graph baseado em informações extraídas da execução de testes. A técnica é dividida em 3 passos, o Passo #1 cria um call graph conservativo e estático que resolve chamadas de métodos baseado apenas em nomes dos métodos, ainda no primeiro passo, testes são executados e seu traço de execução é armazenado para posterior análise. O Passo #2 combina a informação armazenada da execução dos testes e o call graph construído no primeiro passo, o Passo #2 também é responsável pela criação de um conjunto de regras de associação que servirão para guiar desenvolvedores durante a criação de novas partes do código. Nossa avaliação em uma aplicação real de porte grande mostrou que a técnica melhora a precisão do call graph criado removendo arestas desnecessárias (70%), e mostrou-se apta a auxiliar desenvolvedores definindo pontos de navegação no código baseada na análise de regras de associação extraídas do test-case-based call graph.
publishDate 2015
dc.date.issued.fl_str_mv 2015
dc.date.accessioned.fl_str_mv 2016-03-29T02:06:45Z
dc.type.status.fl_str_mv info:eu-repo/semantics/publishedVersion
dc.type.driver.fl_str_mv info:eu-repo/semantics/masterThesis
format masterThesis
status_str publishedVersion
dc.identifier.uri.fl_str_mv http://hdl.handle.net/10183/134355
dc.identifier.nrb.pt_BR.fl_str_mv 000988394
url http://hdl.handle.net/10183/134355
identifier_str_mv 000988394
dc.language.iso.fl_str_mv eng
language eng
dc.rights.driver.fl_str_mv info:eu-repo/semantics/openAccess
eu_rights_str_mv openAccess
dc.format.none.fl_str_mv application/pdf
dc.source.none.fl_str_mv reponame:Biblioteca Digital de Teses e Dissertações da UFRGS
instname:Universidade Federal do Rio Grande do Sul (UFRGS)
instacron:UFRGS
instname_str Universidade Federal do Rio Grande do Sul (UFRGS)
instacron_str UFRGS
institution UFRGS
reponame_str Biblioteca Digital de Teses e Dissertações da UFRGS
collection Biblioteca Digital de Teses e Dissertações da UFRGS
bitstream.url.fl_str_mv http://www.lume.ufrgs.br/bitstream/10183/134355/1/000988394.pdf
http://www.lume.ufrgs.br/bitstream/10183/134355/2/000988394.pdf.txt
http://www.lume.ufrgs.br/bitstream/10183/134355/3/000988394.pdf.jpg
bitstream.checksum.fl_str_mv 0386abc80fb81a3a4560472a261e7250
af72639dc3fc6d37bada4da76b61bc28
a8d15621a76cc2b6037ff6de68d53aa1
bitstream.checksumAlgorithm.fl_str_mv MD5
MD5
MD5
repository.name.fl_str_mv Biblioteca Digital de Teses e Dissertações da UFRGS - Universidade Federal do Rio Grande do Sul (UFRGS)
repository.mail.fl_str_mv lume@ufrgs.br||lume@ufrgs.br
_version_ 1831315986632933376

Registros relacionados