Software Engineering and Architecture Group (SEARCH) > CS > JBI > FWN > RUG

Tooling for analysis of software quality

Software is a major asset that has to be managed in IT. Therefore, it is imperative to constantly measure, analyze, monitor and improve quality of software of an organization, which can and should be done at architectural, design and implementation levels. For that, there are several metrics and analysis approaches that have been proposed, as well as multiple tools capable of collecting metrics and performing analysis, which should be, ideally, reused as often as possible.

However, integrating the existing tooling in order to perform more complex and robust quality analysis is a challenging task. Aiming at supporting research on software engineering, the tool SEAgle has been developed. SEAgle is an online platform for Software Repository Mining, and evolution analysis of Java projects. It facilitates the collection of project related data, organizes relevant information into comprehensible reports and provides a useful tool for empirical research.

Objective and Tasks
In this context, this project aims at expanding SEAgle's features. For that, we are adding new capabilities and integrating 3rd party software to it. Each feature is described in the following, with the minimum requirements to be fulfilled.

The available projects consist of working on the new features. A student project comprises the implementation of two features. The requirements might be adjusted depending on the student's progress and the faced challenges.

  • Implement automatic building (compilation)
    • Implement automatic building of projects
    • Only well configured (e.g., no missing dependencies) projects are built
    • Build systems are: Maven, Ant, and Gradle
    • The minimum requirements are:
      • verify if the project is compilable by any known build system
      • verify if the required building system is available
      • try to compile the project
      • if successful, provide SEAgle with class files
      • if unsuccessful, inform the reason to SEAgle
  • Integrate FindBugs
    • Verify FindBugs availability
    • Run FindBugs for all versions of a designated project
    • Parse FindBugs output and provide SEAgle with the following information for each class of each version:
      • Number of new vulnerabilities for each class of each version
      • Number of removed vulnerabilities for each class
      • Total number of vulnerabilities for each class
  • Integrate the Design-pattern detection (DPD) tool
    • Verify DPD availability
    • Run DPD for all versions of a designated project
    • Parse DPD output and provide SEAgle with the following information for each version:
      • Detected pattern instances
      • Classes that participate in each pattern instance
      • Properties of the instance (e.g., important methods)
  • Integrate Percerons
    • Verify Percerons availability
    • Run Percerons for all versions of a designated project
    • Parse Percerons output and provide SEAgle with all calculated metrics for each class of each version.

Expected challenges
The students will face the following challenges during the projects' execution:

  • Learn code: the existing source code is already comprehensive and you will have the read and understand the most important concepts in order to develop your own code. Even with good practices and documentation, there is a learning curve to get used to the code. Thus, dedication is important.
  • Extend SEAgle: incorporating a new capability or integrating a tool means that you have to edit and add new code to SEAgle. Although most of your code will be isolated, you will have to understand and use SEAgle's infrastructure. For example, features are enable via "Activators" and communication between components is done via "Listeners", which are necessary to receive requests to process a new project, to save results in the database, and to send notifications to other components.
  • Team work: all developers will face similar problems or have the questions regarding SEAgle; therefore, communication is important and will save time. For example, at some point you might be working on the same component as someone else (e.g., registering new metrics to SEAgle's database).

Key characteristics of candidates are:

  • have experience with Java (remember you will be learning and reusing code);
  • be organized with source-code and aware of coding best practices;
  • be comfortable with working in groups;
  • have basic knowledge of Git;
  • want to acquire knowledge and experience with source code analysis

If you are interested in this project or have any questions, please do not hesitate to contact:

    - Daniel Feitosa ( or 
    - Paris Avgeriou (