Theses/Jobs
Bei Fragen zu den hier angebotenen Themen wenden Sie sich bitte an die jeweiligen Betreuer. Weitere Themen können in der Regel direkt bei den Mitarbeitern der Arbeitsgruppe erfragt werden. Eigene Themenvorschläge können an unsere Mail-Verteiler geschickt werden (je nach Vorhaben bitte an Projekt, Abschlussarbeit, oder Praktikum). Abschlussarbeiten können wahlweise auf englisch oder deutsch verfasst werden.
Themen für Abschlussarbeiten
Die folgenden offenen Themen bieten wir derzeit für Bachelor- und Masterarbeiten an.
Database Topics
- Elf: An efficient index structure for multi-column selection predicates
Supervisor: | David Broneske |
Abstract: | With analytical queries getting more and more complex, the number of evaluated selection predicates per query rises as well, which also involves several different columns. Our idea is to address this new requirement with Elf, a multi-dimensional index structure and storage structure. Elf is able to exploit the relation between data of several columns to accelerate multi-column selection predicate evaluation. Elf features cache sensitivity, an optimized storage layout, fixed search paths, and slight data compression. However, there are still many points that have to be researched. These include, but are not limited to: efficient insert/update/delete algorithms, a merging mechanism of two Elfs, Furthermore, we are interested in how far SIMD can be used to accelerate the multi-column predicate evaluation in Elf. |
Goals and results: |
|
- Cybersecurity in the Cloud at ADASTRA
Supervisor: | Dr. Michael Simora, Dr. David Broneske |
Topics: | See PDF! |
- SQL Translator at ADASTRA
Supervisor: | Dr. Michael Simora, Dr. David Broneske |
Topics: | See PDF! |
- Data Visualization of Data Storage and Data Structure at ADASTRA
Supervisor: | Dr. Michael Simora, Dr. David Broneske |
Topics: | See PDF! |
- Container-based Applications at ADASTRA
Supervisor: | Dr. Michael Simora, Dr. David Broneske |
Topics: | See PDF! |
- Data Engineering Framework in the Cloud at ADASTRA
Supervisor: | Dr. Michael Simora, Dr. David Broneske |
Topics: | See PDF! |
- Analytical report on primitives-based execution of TPC-H queries
Supervisor: | Bala Gurumurthy |
Abstract: | TPC-H provides compute intensive queries as benchmark for comparing different data processing mechanisms. In this topic, we explore the diiferent aspects of primitives to be tuned for efficient processing of all these queries and provide a extensive analytical report on the impact of the tuing opportunities on these queries |
Goals and results: |
|
Notes or Requirement: |
|
Software Engineering Topics
- Semi-automatic approaches to support systematic literature reviews (Master)
Supervisor: | Yusra Shakeel |
Abstract: | Systematic Literature Review (SLR) is a methodology of research which aims to gather and evaluate all the available evidence regarding a specific research topic. The process is composed of three phases: Planning, Conducting and Reporting. Although SLRs gained immense popularity among evidence-based researchers, to conduct the entire process manually can be very time consuming. Hence, software engineering researchers are currently involved in proposing semi-automatic approaches to support different phases of an SLR. In this thesis, you analyze the current state of research related to reporting phase of the SLR process. Based on the findings, develop an approach to support researchers with the steps involved for reporting results of an SLR. |
Goals and results: |
|
- Automate quality assessment of studies to support literature analysis (Bachelor/Master)
Supervisor: | Yusra Shakeel |
Abstract: | The number of empirical studies reported in software engineering have significantly increased over the past years. However, there are some problems associated with them, for example, the approach used to conduct the study is not clear or the conclusions are incomplete. Thus, making it difficult for evidence-based researchers to conduct an effective and valid literature analysis. To overcome this problem, a methodology to assess the quality and validity of empirical studies is important. Manually performing quality assessment of empirical studies is quite challenging hence, we propose a semi-automatic approach. In this thesis, you improve the already existing prototype for assessing quality of articles. The aim is to provide the most promising studies relevant to answer a research question. |
Goals and results: |
|
- Cleaning Feature Models (Bachelor)
Supervisor: | |
Keywords: | Software Product Lines, Feature Modeling |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). The variability of an SPL is made explicit in a feature model, which is typically visualized as a tree-like feature diagram. The tree structure of this diagram makes it hard to express complex dependencies between features, which are therefore expressed as additional propositional formulas (called cross-tree constraints). Such complex feature dependencies may cause inconsistencies in a feature model like dead features, which cannot be selected in any configuration. |
Abstract: | A feature model of a configurable system can contain several inconsistencies (besides dead features, also false-optional features or redundant cross-tree constraints). There are analyses for detecting these kinds of inconsistencies; however, there is user action required to actually fix them. The aim of this thesis is to investigate how and to what degree this process can be automatized; that is, whether feature models can be “cleaned” with a simple and intuitive procedure. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Configuring Attributed Feature Models (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Highly-Configurable Software, Constraint Programming |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). The variability of an SPL is made explicit in a feature model, which is typically visualized as a tree-like feature diagram. This feature model is then used to create concrete configurations, a process that is typically supported within an advanced configuration editor. Such editors use state-of-the-art analysis techniques that are based on constraint programming with SAT/CSP solvers. |
Abstract: | Attributed feature models extend common feature models with attributes for certain features like costs, memory consumption, or performance impact. In state-of-the-art tooling, such attributes cannot be used in configurations, which is however one of the main reasons to use attributes in the first place (for example, to set a maximum cost allowance). The aim of this thesis is to extend the configuration editor of FeatureIDE (a tool for developing SPLs) such that it allows to limit the value range of attributes during configuration. Additionally common analyses for configurations (such as checking validity, auto-completion, or decision propagation) should also be considered. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Cross-Tree Constraints for Attributed Feature Models (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Feature Modeling, Constraint Programming |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). The variability of an SPL is made explicit in a feature model, which is typically visualized as a tree-like feature diagram. The tree structure of this diagram makes it hard to express complex dependencies between features, which are therefore expressed as additional propositional formulas (called cross-tree constraints). Such complex feature dependencies may cause inconsistencies in a feature model like dead features, which cannot be selected in any configuration. To avoid these inconsistencies, state-of-the-art tooling uses analysis techniques that are based on constraint programming with SAT/CSP solvers. |
Abstract: | Attributed feature models extend common feature models with attributes for certain features like costs, memory consumption, or performance impact. In state-of-the-art tooling, such attributes cannot be used in cross-tree constraints, which is however one of the main reasons to use attributes in the first place (for example, to set ranges for integer attributes). The aim of this thesis is to extend the feature model editor of FeatureIDE (a tool for developing SPLs) to allow for cross-tree constraints over attributes. Additionally common feature model analyses (such as checking the validity of a feature model, finding dead/core features, or finding redundant constraints) should also be considered. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Efficient Detection of Indeterminate Hidden Features in Feature Models (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Feature Modeling, Propositional Logic |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). The variability of an SPL is made explicit in a feature model, which is typically visualized as a tree-like feature diagram. This feature model is then used to create concrete configurations, a process that is typically supported within an advanced configuration editor. To support the feature modeling and configuration processes, state-of-the-art tooling uses analysis techniques that are based on SAT solver technology. |
Abstract: | Hidden features can be used to mark features that are not configurable by end users, but are automatically (de-)selected by the configuration editor according to additional constraints in the feature model. A hidden feature is called indeterminate if there is at least one configuration in which all regular features are defined but a value for the hidden feature cannot be deduced. Indeterminate hidden features can cause problems during configuration and should therefore be detected beforehand, which is a time-consuming task. The aim of the thesis is to optimize the current analysis in FeatureIDE (a tool for developing SPLs) for finding indeterminate hidden features to improve its performance and therefore applicability in the field. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Efficiently Counting Feature Model Configurations (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Feature Modeling, Propositional Logic |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). The variability of an SPL is made explicit in a feature model, which is typically visualized as a tree-like feature diagram. This feature model is then used to create concrete configurations, a process that is typically supported within an advanced configuration editor. To support the feature modeling and configuration processes, state-of-the-art tooling uses analysis techniques that are based on SAT solver technology. |
Abstract: | Counting how many configurations a feature model comprises can be a time-consuming task — however, sometimes it is sufficient to know an estimation of the number of configurations. There are already algorithms for precisely and approximately counting the number of configurations that a feature model represents. The aim of this thesis is to create a systematic overview of all available methods for exact and approximate configuration counting. The overview should contain a comparison of the differences between the researched methods in efficiency and accuracy. At least one approximate counting approach should be implemented in FeatureIDE and evaluated against contemporary SAT and #SAT approaches. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Evolution-Aware Configuration Sampling for Software Product Lines (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Software Testing, Evolution |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). A key challenge in managing SPLs is the potentially large (exponential) number of products, which makes it hard to test all products in an SPL — for example, there are easily more variants of the Linux kernel than there are atoms in the universe. In practice, this means that testing an SPL often amounts to testing some number of configurations and hoping that such a configuration sample covers most potential faults in the SPL. One class of faults in SPLs are so-called feature interactions, which are bugs that only occur for very specific combinations of selected features. For example, two device drivers in the Linux kernel may work fine on their own, but be incompatible with each other, which causes crashes when both drivers are loaded at the same time. |
Abstract: | A contemporary technique for testing SPLs is to generate a representative set of configurations (i.e., a configuration sample) and run tests for every configuration in the sample. However, generating such samples can be time-intensive, and if the SPL is changed, samples become invalid and must be generated completely from scratch. The aim of this thesis is to find an efficient technique to update an existing sample such that it can accommodate changes to the SPL. Thus, after changes to the feature model (which expresses the valid configurations of an SPL) have been made, parts of an existing sample should be reused to avoid complete re-calculation. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
- Identifying Feature Interactions in Software Product Lines (Bachelor/Master)
Supervisor: | |
Keywords: | Software Product Lines, Software Testing |
Context: | Software product lines (SPLs) are collections of many software products (called configurations) that share certain characteristics (called features). Thus, SPLs can be used to develop and maintain variant-rich, highly-customizable software systems (e.g., the Linux kernel). A key challenge in managing SPLs is the potentially large (exponential) number of products, which makes it hard to test all products in an SPL — for example, there are easily more variants of the Linux kernel than there are atoms in the universe. In practice, this means that testing an SPL often amounts to testing some number of configurations and hoping that such a configuration sample covers most potential faults in the SPL. One class of faults in SPLs are so-called feature interactions, which are bugs that only occur for very specific combinations of selected features. For example, two device drivers in the Linux kernel may work fine on their own, but be incompatible with each other, which causes crashes when both drivers are loaded at the same time. |
Abstract: | A contemporary technique for testing SPLs is to generate a representative set of configurations (i.e., a configuration sample) and run tests for every configuration in the sample. In case one configuration fails some tests, the developers have to fix the corresponding fault in the SPL. The aim of this thesis is to detect the feature interaction(s) responsible for such a fault. That is, given a configuration sample for an SPL and some configuration(s) in the sample that fail a test, your technique should find the smallest set of selected features that is necessary to fail the test. This set then indicates the feature interaction to the developer, who can use this information to fix the corresponding bug. |
Goals: |
|
Requirements: | Completion of ISP is recommended, but not necessary, as we can provide you with introductory material. |
Studentische Mitarbeit und offene Stellen
Aktuelle sind keine offene Stellen zu vergeben.
Wissenschaftliche Teamprojekte
Für wissenschaftliche Teamprojekten bieten wir eine eigene Veranstaltung an:
Zu Beginn dieser Veranstaltung werden verschiedene Themen vorgestellt, die innerhalb des Semesters bearbeitet werden können.
Softwareprojekte
Es stehen derzeit folgende Themen für ein Softwareprojekt zur Verfügung.
- Verbesserungen für SQLValidator (Bachelor)
Ansprechpartner: | David Broneske |
Beschreibung: |
Im Rahmen dieses Softwareprojekts soll das bestehende Tool SQLValidator um weitere Funktionalität erweitert werden. Die zu implementierende Funktionalität ist dabei zusammen mit dem Betreuer abzustimmen und kann beliebig erweitert oder eingeschränkt werden. Mögliche Aufgaben sind:
|
Ziele und Ergebnisse: |
|
- Datenquälität im Datacenter: das nächste Level ist greifbar (Bachelor)
Ansprechpartner: | David Broneske, Marcus Pöhls |
Beschreibung: | Implementierung einer Applikation zur Verbesserung der Datenqualität von CPU-Daten eines Rechenzentrums. Zuerst wird die Datenqualität analysiert und anschließend mit Hilfe der APIs von Intel und AMD verbessert. Die Daten der Hardware-Infrastruktur stelle ich für das Projekt bereit. Konkretes Beispiel: für eine Maschine bei der keine Angabe der CPU-Cores vorhanden ist, kann über das Prozessor-Modell (bspw. Intel Xeon Processor E5-2650 v3) die Core-Lücke geschlossen werden. Das SW-Projekt beinhaltet auch die Duplikaterkennung. D.h. für Maschinen die im Datensatz mehrfach und sogar mit unterschiedlichen CPU-Daten vorhanden sind, wird der "beste" (plausibelste) Datenstand genutzt. |
Ziele und Ergebnisse: |
|
- Carbon2Json: Improve Conversion Time from CARBON to JSON
About | Profile current implementation to find bottleneck in multi-step conversion routine, design and implementation new concepts, improve existing ones. |
Topic type | Team Project |
Supervisor | Marcus Pinnecke |
Fundamentals | See guest lecture A Gentle Introduction to Document Stores and Querying with the SQL/JSON Path Language in Advanced Topics of Database Systems |
Context | See our open source project Protobase/libcarbon on GitHub in which you will add and evaluate the required functionality. You may read a brief introduction to the system first: Pinnecke et al. Protobase: It's About Time for Backend/Database Co-Design. BTW 2019 |
Requirements |
In addition to formal requirements for a thesis (e.g., number of credit points), you match the following profile. You have had courses on practical application of computer science concepts including programming languages, and knowledge of data structures along with their implementation. Moreover, you have good abstraction skills, and the drive to work with a non-trivial code base (35k lines of C code). Finally, you have the following focus during your studies:
|
Does it fit? | Before starting working on the topic, we typically have a first meeting to check whether the topic and requirements fit to your profile. As a preparation, you may have a look at the following programming task: Optimizing Memory Pooling for In-Memory Database Systems. |
- Quality: Testing of Several Components in Libcarbon, Protobase and NG5
About | Design and implement unit and integration tests for several components in the library. |
Topic type | Software Project |
Supervisor | Marcus Pinnecke |
Fundamentals | See guest lecture A Gentle Introduction to Document Stores and Querying with the SQL/JSON Path Language in Advanced Topics of Database Systems |
Context | See our open source project Protobase/libcarbon on GitHub in which you will add and evaluate the required functionality. You may read a brief introduction to the system first: Pinnecke et al. Protobase: It's About Time for Backend/Database Co-Design. BTW 2019 |
Requirements |
In addition to formal requirements for a thesis (e.g., number of credit points), you match the following profile. You have had courses on practical application of computer science concepts including programming languages, and knowledge of data structures along with their implementation. Moreover, you have good abstraction skills, and the drive to work with a non-trivial code base (35k lines of C code). Finally, you have the following focus during your studies:
|
Does it fit? | Before starting working on the topic, we typically have a first meeting to check whether the topic and requirements fit to your profile. As a preparation, you may have a look at the following programming task: Optimizing Memory Pooling for In-Memory Database Systems. |
- Split&Merge: Efficient Splitting and Merging of CARBON Archives
About | Currently, CARBON archives are constructed from a user-empowered JSON collection and read-only afterwards. In preparation of physical optimizations (such as undo archiving) and defragmentation, archives must be splittable and mergabele. This thesis is about this actions. |
Topic type | Software Project |
Supervisor | Marcus Pinnecke |
Fundamentals | See guest lecture A Gentle Introduction to Document Stores and Querying with the SQL/JSON Path Language in Advanced Topics of Database Systems |
Context | See our open source project Protobase/libcarbon on GitHub in which you will add and evaluate the required functionality. You may read a brief introduction to the system first: Pinnecke et al. Protobase: It's About Time for Backend/Database Co-Design. BTW 2019 |
Requirements |
In addition to formal requirements for a thesis (e.g., number of credit points), you match the following profile. You have had courses on practical application of computer science concepts including programming languages, and knowledge of data structures along with their implementation. Moreover, you have good abstraction skills, and the drive to work with a non-trivial code base (35k lines of C code). Finally, you have the following focus during your studies:
|
Does it fit? | Before starting working on the topic, we typically have a first meeting to check whether the topic and requirements fit to your profile. As a preparation, you may have a look at the following programming task: Optimizing Memory Pooling for In-Memory Database Systems. |
- StringIdRewrite: Embedding of String ID Resolution w/o Indexes in CARBON
About | In the current form, resolving a fixed-length string reference in a CARBON archives - in case of a cache miss - requires to resolve the reference (string id) to the offset inside the string table on disk. This thesis is about rewriting archives by replacing string ids by their offset. |
Topic type | Software Project |
Supervisor | Marcus Pinnecke |
Fundamentals | See guest lecture A Gentle Introduction to Document Stores and Querying with the SQL/JSON Path Language in Advanced Topics of Database Systems |
Context | See our open source project Protobase/libcarbon on GitHub in which you will add and evaluate the required functionality. You may read a brief introduction to the system first: Pinnecke et al. Protobase: It's About Time for Backend/Database Co-Design. BTW 2019 |
Requirements |
In addition to formal requirements for a thesis (e.g., number of credit points), you match the following profile. You have had courses on practical application of computer science concepts including programming languages, and knowledge of data structures along with their implementation. Moreover, you have good abstraction skills, and the drive to work with a non-trivial code base (35k lines of C code). Finally, you have the following focus during your studies:
|
Does it fit? | Before starting working on the topic, we typically have a first meeting to check whether the topic and requirements fit to your profile. As a preparation, you may have a look at the following programming task: Optimizing Memory Pooling for In-Memory Database Systems. |
- JSON Check Tool as Separate Tool
About | Currently, in the CARBON Tool (carbon-tool) there is a sub module to check whether a particular JSON file is parsable and satisfies the criteria for conversion into CARBON archives (checkjs). Since this logic is shared with the BISON Tool (bison-tool), the task is to move the module in carbon-tool to a dedicated new tool called checkjs. |
Topic type | Software Project |
Supervisor | Marcus Pinnecke |
Fundamentals | See guest lecture A Gentle Introduction to Document Stores and Querying with the SQL/JSON Path Language in Advanced Topics of Database Systems |
Context | See our open source project Protobase/libcarbon on GitHub in which you will add and evaluate the required functionality. You may read a brief introduction to the system first: Pinnecke et al. Protobase: It's About Time for Backend/Database Co-Design. BTW 2019 |
Requirements |
In addition to formal requirements for a thesis (e.g., number of credit points), you match the following profile. You have had courses on practical application of computer science concepts including programming languages, and knowledge of data structures along with their implementation. Moreover, you have good abstraction skills, and the drive to work with a non-trivial code base (35k lines of C code). Finally, you have the following focus during your studies:
|
Does it fit? | Before starting working on the topic, we typically have a first meeting to check whether the topic and requirements fit to your profile. As a preparation, you may have a look at the following programming task: Optimizing Memory Pooling for In-Memory Database Systems. |
Vorlagen
Abschlussarbeiten
- LaTeX-Vorlagen für deutsche und englische Arbeiten
- Microsoft Word-Vorlage: DOT
Präsentationen
- LaTeX-Vorlagen für Vorträge
- Microsoft PowerPoint-Vorlage: PPT