English Intern
    Lehrstuhl für Informatik I - Algorithmen, Komplexität und wissensbasierte Systeme

    Abschlussarbeiten und Praktikumsthemen

    Auf dieser Seite sind Themen für mögliche Abschlussarbeiten, Projekte und Masterpraktika aufgelistet. Nicht alle Themen eignen sich für alle Veranstaltungsformen - das richtet sich aber auch nach den Vorkenntnissen und kann bei Interesse am besten im persönlichen Gespräch ausgelotet werden.

    Gerne übernehme ich nach Absprache auch die Betreuung von Arbeiten mit eigenen Themenideen aus unseren Interessensbereichen.

    OpenRuleBench Revised

    OpenRuleBench is a suite of benchmarks for analysing the performance and scalability of different rule engines. The original benchmarks were run first in 2009, an updated report was published in 2011. Since then, the benchmarks have not been re-run. In this work, we want to create an experimental setup to validate the original results, and re-run tests with modern rule engines. This could result in a public test server to compare existing and new logic programming systems and their strengths.

    XPCE Compatibility for SWISH

    XPCE was the way to go for graphical user interfaces with SWI-Prolog. But recently with SWISH, SWI-Prolog moved to the browser as the most important GUI, leaving XPCE unsupported and almost deprecated. We want to examine typical XPCE applications and provide mechanisms to convert them to SWISH applications.

    Distributed Logic Programming on Raspberry Pi's

    The declarative properties of logic programming languages like Prolog and Datalog allow the distribution of knowledge bases and calculations across multiple devices. As part of this topic we want to create an experimental setup of a distributed system using Raspberry Pi's and implement a first prototype of a multi-process logic programming system.

    Alexa, talk Prolog to me!

    Amazon's Alexa provides great opportunities to interact with people. The development toolkit provided by Amazon is exceptional good at speech recognition, however, the way to combine the identified sentences with knowledge bases could be improved. We want to connect Alexa with Prolog and build a first prototype, e.g., a decision support system.

    XPath and XQuery in SWI-Prolog

    In the last year's practical course we implemented an XML Schema validator. To support schema features like the specification of keys, unique fields, assertions and conditional types, there is the need for an XPath and XQuery library in SWI-Prolog, which should be realised as part of this work.

    Benchmarking CHR Systems

    Constraint Handling Rules (CHR) is a very simple but powerful rule-based language. Besides its most popular implementation as a library for SWI-Prolog, there exist CHR systems in C, Haskell, and JavaScript. More than 25 years after the creation of CHR, the existing implementations should be compared regarding supported features and performance.

    Remember your Faults - An Extension to Prolog's Tabling

    Tabling is a powerful mechanism to avoid re-evaluation of Prolog predicates memoizing the answers. It also avoids left recursion in logic programs that are sound in their logical reading but not under normal SLD resolution. However, existing Tabling implementations only handle positive knowledge but ignore anything that could not be deduced. As part of this work we want to extend these approaches to further increase Prolog's performance.

    Testing different Prolog Systems using JPGateway

    JPGateway and its related Portable Prolog Gateway (PPG) have been originally created as a uniform interface to talk to Prolog from Java as part of the CAPJa project. They can be used separately, so it is possible to integrate them in a toolchain to test user-defined Prolog programs on different Prolog systems like SWI-Prolog, XSB, and YAP.

    Bisecting Debugger for SWI-Prolog

    Although it is hard to admit - most of the time we are actually not writing code but instead debug existing. Due to its good backtracking and tracing abilities, debugging in Prolog could benefit from a bisecting debugger as described by Michael Hendricks at Strange Loop 2014. In this work we want to enhance SWI-Prolog's built-in debugger with this functionality.

    Interactive SLD Tree Exploration with Leaflet

    Leaflet is the leading JavaScript library for interactive maps. Despite its usage in classical map applications, it has been used to visualise 3D models, the galaxy, the tree of life, and virtual microscopes. Similarly, this type of visualisation can be used to present the trace of a Prolog program, omitting details when zooming out, etc.

    Operator Introspection for Prolog Programs

    Prolog is known to be a good host language for bootstrapping domain-specific languages. Using self-defined operators and term expansion it is possible to extend the Prolog parser so that a text looking like prosa is a valid Prolog program. But where are the limits of this approach? Is it even possible to, e.g., define regular expressions (regex) directly as a Prolog subset? In this work we want to investigate the limits and implement a prototype to automatically derive operator definitions from given texts.

    Prolog Saved States for Process Duplication

    SWI-Prolog comes with a powerful mechanism to pre-compile Prolog programs: Using saved states it is possible to bundle all machine-independent compiled resources. This technique is currently used to improve the startup time of a program. Since the saved state can be created dynamically, it could also be used to duplicate the running process, as described by Michael Hendricks at Strange Loop 2014. We want to examine and implement this technique for parallel Prolog computations.

    Prolog/node.js Bridge with node-gyp

    Ever wondered what node.js and Prolog have in common? Both provide excellent interfaces to native C! Using node-gyp and SWI-Prolog's Foreign Language Interface it is possible to build a bridge between both environments. As part of this work we want to use Prolog from within node.js or vice-versa.

    Optimising Definite Clause Grammars

    Definite Clause Grammars (DCG) can be easily written by hand and are therefore a good alternative to parser implementations based on LL(k), LF or PEG. Nevertheless such hand-written grammars tend to be not optimal: Several parts of the parse tree have to be evaluated several times for the same expression because of its backtracking nature. Using source-to-source transformation the DCG can be rewritten into an optimal version, which should be done in Prolog as part of this work.

    Prolog Interpreter for JavaScript

    In 2014, a blog post about a Prolog interpreter written in JavaScript gained a lot of attention. It describes a Prolog interpreter of just 160 LOC. In this work, we want to improve this first approach by using language features which were added very recently in ES 2015, like generators and Promises, together with aspects like immutable data structures.

    Integrating Bloom into Prolog or JavaScript

    Bloom is the name of a high-level declarative language created at the BOOM project. This acronym stands for Berkely Orders Of Magnitude, which underlines the target to speed up computations by providing a disordered programming language explicitly designed for distributed and parallel systems. Currently there is only one implementation in Ruby. We want to examine the realization as a domain-specific language (DSL) in either Prolog or JavaScript.

    Weitere Themen?

    Weitere Themen und Ideen können gerne im persönlichen Gespräch angesprochen werden.

    Kontakt

    Lehrstuhl für Informatik I (Effiziente Algorithmen und wissensbasierte Systeme)
    Am Hubland
    97074 Würzburg

    Tel.: +49 931 31-85054
    E-Mail

    Suche Ansprechpartner

    Hubland Süd, Geb. Z8 Hubland Süd, Geb. M2