Precise temporal analysis of source code histories at scale
Analyse précise et à l’échelle des historiques de code source
Résumé
VCS are one of the corner stones of modern software development. By tacking changes across versions, they facilitate developers collaboration, and enable continuous integration and delivery of software artifacts. Over time, developers produce new versions that introduce additional features and code. For example, the Linux kernel now has more than 1M commits, 20K features, and more than 15M lines of code. Making it slow to download, build and analyze. Therefore, it becomes essential to improve the efficiency of systems that manage software source code histories while also improving usability and our understanding of already existing histories.
Continuously delivering robust products and services on massive and complex software systems requires extensive analyses and tests. Therefore, executing every analyses and tests at every change is challenging or downright impractical. Existing build systems and analysis tools already tackle this complexity through incremental approaches, either incrementally mutating a transient state or caching intermediate artifacts. Yet, existing approaches still consider coarse grained artifacts
(often at file level) and text based representation (little access to semantic). In this thesis, we claim that it is possible to significantly improve incremental approaches by considering finer grained elements while adapting existing analyses. This thesis aims to tackle various scientific challenges around the scalability of software approaches and analyzes to large industrial software projects. The initial challenge
I address concerns the temporal analysis of source code histories through finegrained co-evolutions, to help with code understanding and automation. The second challenge concerns the inefficiency of current temporal source code analyzes, which fail to exploit temporal and spatial source code redundancy in software histories. In most software histories, the quantity of changes each commit brings is small compared to the size of the whole code base, e.g., a single line in millions of lines of code.
In particular, this thesis presents a new data structure that allows fine-grained sharing of unchanged code and persistence of intermediate
results, thus making temporal analyses of source code incremental. Next, two analyses are introduced, one spatial, making it possible to retrieve all references to a given declaration, and the other temporal, making it possible to infer changes between two versions.
Les systèmes de contrôle de versions sont l’une des pierres angulaires du développement des logiciels modernes. En intégrant les modifications entre les versions, ils facilitent la collaboration entre les développeurs
et permettent l’intégration et la livraison continues des artefacts logiciels. Au fil du temps, les développeurs produisent de nouvelles versions qui introduisent des fonctionnalités et du code supplémentaires. Par exemple, le noyau Linux compte aujourd’hui plus d’un million de commits, 20 000 fonctionnalités et plus de 15 millions de lignes de code. Ce qui
ralentit le téléchargement, la construction et l’analyse des logiciels. Par conséquent, il devient essentiel d’améliorer l’efficacité des systèmes qui gèrent les historiques des codes sources des logiciels tout en améliorant la facilité d’utilisation et notre compréhension des historiques déjà existants. Fournir en permanence des produits et des services robustes sur des systèmes logiciels massifs et complexes nécessite des analyses et des tests approfondis. Par conséquent, l’exécution de toutes les analyses et de tous les tests à chaque changement constitue un défi, voire est carrément irréalisable. Les systèmes de construction et les outils d’analyse existants s’attaquent déjà à cette complexité par des approches incrémentales, soit en modifiant de manière incrémentale un
état transitoire, soit en mettant en cache des artefacts intermédiaires. Cependant, les approches existantes considèrent toujours des artefacts à gros grain (souvent au niveau du fichier) et une représentation basée sur le texte (peu d’accès à la sémantique). Dans cette thèse, nous démontrons qu’il est possible d’améliorer de manière significative les approches incrémentales en considérant des éléments à grain plus fin tout en adaptant les analyses existantes. Cette thèse vise à relever plusieurs défis
scientifiques concernant l’extensibilité des approches et des analyses logicielles à de grands projets logiciels industriels. Le premier défi que j’aborde concerne l’analyse temporelle de l’historique des codes sources par le biais de coévolutions fines. Le deuxième défi concerne l’inefficacité des analyses temporelles actuelles du code source, qui ne parviennent
pas à exploiter la redondance temporelle et spatiale du code source dans l’historique des logiciels. En effet, dans la plupart des historiques de logiciels, la quantité de changements apportés avant chaque validation
est faible par rapport à la taille de l’ensemble de la base de code, c’est-à-dire quelques lignes de code parmi des millions.
Cette thèse présente notamment une nouvelle structure de données qui permet de partager le code inchangés finement et de persister des résultats intermédiaires pour ainsi rendre incrémentales des analyses temporelles de code source. Ensuite, sont présenté deux analyses, l’une spatial, permettant depuis une déclaration de retrouver ces références,
l’autre temporel, permettant d’inférer les changements entre deux versions.
Origine | Fichiers produits par l'(les) auteur(s) |
---|