Software Engineering & Evolution

The concept of “modernity” has been a topic of discussion in many fields, including philosophy, sociology and technology. In the software engineering context, modernity can be defined as the extent to which the source code of a software system utilises new features and capabilities of the programming language it is written in. In software evolution, we define modernity as a scale of measuring the age of a codebase, expressed as language levels/versions. For instance, your Python code can have a modernity of 3.11, if it runs fine with Python 3.11 but fails with an error with Python 3.10.

To investigate it in more detail, we introduce modernity signatures as vectors of values, each representing one language version: the higher the corresponding value, the more of language features from that version are used in the code. This has previously been done for PHP, Python, Rust, JavaScript, as well as for Java (technically, the project for Java only computed weighted abstract syntax trees, but converting them to modernity signatures is just a matter of traversal). A long internationally peer-reviewed paper was published about this at a highly ranked scientific journal recently: https://doi.org/10.1016/j.jss.2024.111973

There are two ways to take this project:

• using existing implementations as inspiration, apply the method to another language and observe the differences (there were some differences between PHP and Python, so most probably if you take a completely different language like Kotlin, Rascal, Haskell or CSS, the differences will be substantial and interesting to investigate and explain);
• consider existing implementations, generalising their design choices, and propose conceptual improvements on visualisation, interpretation, summarisation, pattern detection, etc; then run experiments to show what the effect is (if any) of choosing one way or the other.

As an example of the first way, you can read the Chris Bleeker's thesis; as an example of the second way, Cris Zubcu's.

Get in touch with your potential future supervisors to discuss details!

Supervisors: Milan Lopuhaä - Zwakenberg, Ömer Sayilir

In SW engineering, code metrics tell something about the complexity of a program. Various metrics exist, ranging form simple ones like the number of lines of code, to advanced ones like cyclomatic complexity.

Code metrics can tell something about the code quality. This is extremely important: good code is easy to maintain, refactor, and port. Bad code costs time and money and frustration.
However, for software models, few of such metrics exist, even though such metrics could be equally useful for models as for code. Thus, the idea of this project is to come up with model metrics and evaluate if they make sense.

Note that various models could be studied: finite state automata, UML models, fault trees, etc.
Even though no company is involved, this is relevant for industry; we can involve companies later.

Tasks:

• Study the state of the art
• Define model metrics
• Evaluate on relevant case studies or examples: do these metrics really tell us what we want?

Supervisor: Fernando Castor

Generative AI and coding assistants are revolutionizing software development, but their energy demands are rapidly escalating. At the same time, concerns about data privacy have driven many developers and organizations to consider deploying their own local AI assistants. The widespread adoption of large language models (LLMs) presents a critical trade-off: balancing energy consumption with task accuracy.

This study aims to investigate the impact of hyperparameter adjustments such as temperature, top-p and max_output_tokens on energy consumption and accuracy in two common software development tasks: code generation and bug fixing. By evaluating a diverse set of language models on an AI-specific GPU to replicate real-world scenarios. We aim to provide actionable insights that guide developers in optimizing the deployment of LLMs for efficiency and performance.