Predicting Program Properties from ‘Big Code’: Um

Resumo Crítico
Carlos Eduardo Morais Vieira

Programa de Pós-graduação em Engenharia de Software (PPgSW)

Universidade Federal do Rio Grande do Norte (UFRN)
Natal, RN - Brasil

1 Introdução
Este documento é um relatório desenvolvido como parte da disciplina
MPES0022 – Fundamento de Linguagens de Programação, ministrada no
semestre de 2019.2 pelo Prof. Dr. Sérgio Queiroz de Medeiros, dentro do
Programa de Pós-graduação em Engenharia de Software (PPgSW) na Uni-
versidade Federal do Rio Grande do Norte (UFRN). Ele resume e faz uma
analise crítica do artigo “Predicting Program Properties from ‘Big Code” ’,
de Veselin Raychev, Martin Vechev, and Andreas Krause, publicado em 2015
no ACM SIGPLAN-SIGACT Symposium on Principles of Programming Lan-
guages.

2 Resumo
O artigo apresenta uma abordagem probabilística para predição de pro-
priedades de programas usando bases de código extensas ("Big Code"). Essa
abordagem consiste principalmente de treinar um modelo probabilístico a
partir de "Big Code" e usar esse modelo para prever propriedades de pro-
gramas novos, que não fazem parte do conjunto de programas usados para
treinamento.
A idéia chave usada para isso, e o que parece ser a contribuição principal
do artigo, é a transformação do programa de entrada (tanto na etapa de
treinamento quanto na de predição) em uma representação – chamada rede
de dependência – que permite que o problema de predição de propriedades
de um programa seja formulado como um problema de predição estrutu-
rada com Conditional Random Fields (CRFs). Essa rede de dependência
captura em sua estrutura os relacionamentos entre elementos de programa
cujas propriedades devem ser preditas com elementos cujas propriedades são
conhecidas.

1
 Como um exemplo dessa abordagem, um sistema é apresentado, chamado
JSNice, que busca realizar dois tipos de previsão em programas escritos em
JavaScript: o primeiro tipo, sintático, é o de prever nomes de identificadores
(para variáveis, funções, etc.); e o segundo tipo, semântico, é o de prever ano-
tações de tipo para variáveis (comentários especiais usados em JSDoc). Os
autores afirmam que tais predições têm aplicações em engenharia de software,
análise de programas, e segurança.
Além disso, afirmam que JavaScript em particular foi escolhida para esse
sistema por dois motivos. Primeiramente, que inferência de tipos tradicio-
nal, usada por recentes extensões de JavaScript (como TypeScript e o Google
Closure Compiler), não escala para programas realísticos que fazem uso de
avaliação dinâmica e bibliotecas complexas (como jQuery). E, além disso,
que muito código JavaScript encontrado na web é ofuscado, dificultando com-
preensão do código. As predições de anotações de tipos e de novos nomes de
identificadores então ajudariam a mitigar esses dois respectivos problemas.
JSNice aparentemente veio a se tornar uma ferramenta frequentemente
usada: no período de um ano, a plataforma chegou a “desofuscar” mais de
9GB (87.7 milhões de linhas de código) de programas JavaScript únicos.
Além disso, um histograma mostrando a distribuição do tamanho de progra-
mas desofuscados indica que programas fornecidos por usuários são em geral
relativamente grandes, com um tamanho médio de 91.7KB.
A abordagem de predição proposta foi avaliada usando o exemplo dessa
plataforma, com um conjunto de treino obtido a partir de 10517 projetos de
JavaScript no GitHub, e um conjunto de avaliação consistindo dos 50 projetos
no BitBucket com o maior número de commits. Buscas foram realizadas
para verificar que esses dois conjuntos de programas são disjuntos, e um
verificador automático foi implementado para filtrar programas “minificados”
(um processo automático que encurta nomes de identificadores). Após esse
processo de filtragem, são usados no total 324501 arquivos para treino e 2710
para avaliação.
Um framework para criação de aplicações similares a JSNice, chamada
Nice2Predict, também foi brevemente mencionado. Esse framework contém
todos os componentes de treinamento e predição usados nesse trabalho. Para
usá-lo, o usuário precisa somente definir sua aplicação em termos de um mo-
delo CRF, o que é feito através da definição de funções de atributos apropri-
adas. Tais funções de atributos são usadas para avaliar possíveis atribuições
de propriedades de programa.

2
3 Análise Crítica
Primeiramente, os autores introduzem o artigo de forma clara, se não
concisa. Suas principais contribuições são delineadas e questões mais gerais
são desde já levantadas e respondidas, como a razão por trás do método
de predição escolhido, e das escolhas da linguagem a ser considerada e das
propriedades a serem preditas no exemplo proposto.
Porém, nem todas essas justificativas são completamente satisfatórias.
Por exemplo, ao justificar a escolha de linguagens, os autores mencionam
“much of JavaScript code found on the Web is obfuscated, making it difficult
to understand what the program is doing”. Mas por qual motivo código em
JavaScript na web seria mais ofuscado do que código em qualquer outra
linguagem? Note também o pequeno erro em que três razões para o foco em
JavaScript seriam dadas, mas somente duas foram mencionadas.
Os autores afirmam que sua abordagem pode recuperar nomes de iden-
tificadores “prováveis”, fazendo muito deste código JavaScript encontrado na
Web mais legível. Nas suas próprias palavras, “this is enabled by a large and
well-annotated corpus of JavaScript programs available in open source repo-
sitories such as GitHub”, trecho que faz referência ao que mais tarde será
definido como o conjunto de treino da plataforma JSNice.
Podemos então desde já questionar se esse programas JavaScript encon-
trados em repositórios open source no GitHub são de alguma forma (e por
qual motivo) menos ofuscados que código JavaScript geralmente encontrados
na web, aparentemente tão difícil de entender. Isso poderia ser justificado por
algum processo de filtragem do código usado para treinamento que eliminasse
qualquer tipo de código ofuscado.
Infelizmente, o processo de filtragem que é de fato usado, e que aparente-
mente elimina código minificado ou de outra forma ofuscado, não é explicado
ou detalhado de qualquer forma. Sem conhecimento desse processo, devemos
considerar os programas usados para treinamento como representantes de
práticas comuns em repositórios de JavaScript open source, não de código
JavaScript particularmente claro ou desofuscado. E práticas comuns não são
necessariamente melhores práticas.
Apesar disso, o modelo obtido parece ter bons resultados ao menos quanto
a reversão do processo de minificação (realizado nesse caso por UglifyJS)
e quanto a recuperação de anotações de tipo. Essa última utilidade em
particular parece apresentar resultados interessantes.
Isso se dá não tanto nas avaliações de precisão e revocação (recall – tam-

3
bém chamada de sensibilidade) da recuperação de anotações: os autores re-
conhecem que uma melhor avaliação com essas métricas não necessariamente
refletem um bom modelo, já que nem todas as anotações originais estavam
corretas. O potencial dessa abordagem é melhor evidenciado quando o có-
digo produzido por JSNice é mostrado como tendo um maior número de
anotações, e um menor número de erros de tipo após avaliação.
Além desses aspectos, os autores apresentaram sua nova abordagem (e o
contexto teórico necessário) de forma simples e direta, fazendo bom uso do
exemplo em questão (JSNice) para explicar os passos envolvidos em aplicar
essa abordagem em uma aplicação real. A menção do framework de predição
Nice2Predict, por outro lado, tirou um pouco o foco do artigo, ao mesmo
tempo que deixou algumas questões em aberto, sendo apenas mencionado na
introdução.
Em geral, os autores foram bem sucedidos em apresentar sua nova aborda-
gem para predição de propriedade de programas. Enquanto algumas decisões
de configuração experimental são questionáveis, os resultados ainda podem
ser considerados promissores. Em particular, esta abordagem faz tangível a
possibilidade de que métodos alternativos de inferência de tipos como este
podem vir a complementar métodos mais tradicionais no futuro, em contex-
tos similares. Além disso, o potencial de aprendizado a partir de “Big Code”,
de forma mais geral, como um campo de pesquisa, foi bem exemplificado
neste artigo.