Nogatz, Falco

Falco Nogatz, M.Sc.

Lehrveranstaltungen

Übungen zu Deduktive Datenbanken:
SS18 | SS17 | SS16
Übungen zu Logikprogrammierung:
WS18
Übungen zu Datenbanken:
WS17 | WS16
Übungen zu Logik für Informatiker:
WS18 | WS17 | WS16 | WS15
Praktikum Datenbanken und Regelbasierte Systeme:
WS18 | WS17 | WS16
Seminar Advanced Database and Logic Programming Concepts:
SS19 | SS18 | SS17 | SS16

Betreuung studentischer Arbeiten

Betreute Abschlussarbeiten:

Ina Goeßmann, Zulassungsarbeit: Entwurf und Diskussion eines Style Linters für Prolog. (2019)
Olga Frost, Bachelorarbeit: A Knowledge-based Software System for Time and Human Resource Management in Prolog. (2019)
Julia Kübert, Bachelorarbeit: Attempto Controlled English für Amazon Alexa. (2018)
Sandra Lederer, Masterarbeit: Analyse und Optimierung verschiedener Algorithmen zur Synchronisation von SQL-Datenbanken. (2018)
Jona Kalkus, Masterarbeit: An Interactive Visualisation for Definite Clause Grammars. (2017)
Thomas Handwerker, Masterarbeit: Testing Source Code with the Logic Programming Language Prolog. (2016)

Betreute Masterpraktika:

Simon Hümmer: CHR as a Library with Delimited Control. (2019)
Jonathan Vogell: Distributed Logic Programming on Raspberry Pi's. (2019)
Lucas Kinne: XPath and XQuery in SWI-Prolog. (2019)
Kevin Jonscher: XML Schema Validation using Code Generation. (2019)
Lukas Leppich: Implementation of the Language Server Protocol for SWI-Prolog. (2017)
Jona Kalkus: XML Schema Validation with Prolog. (2017)
Daniel Haumann: A Style Linter for Prolog. (2017)
Sven Rausch: Evaluation of MySQL Cluster Architectures for Big Data. (2016)

Betreute Seminararbeiten:

Achieve Logical Purity with Attributed Variables. (2019)
OpenRuleBench Revised. (2019)
An Introduction to Attempto Controlled English. (2018, 2019)
LogicBlox - A Prolog Success-Story. (2018)
Attributed Variables in Prolog. (2018)
An Introduction to Constraint Handling Rules. (2018)
From GROUP BY to MapReduce - Database Aggregations using the example of MongoDB. (2017)
Delimited Continuations in Prolog. (2017)
Make Prolog Logical Again - Tabled Execution in SWI-Prolog. (2017)
Ask only once: PostgreSQL's Window Functions. (2016)
MySQL Cluster Architecture Overview. (2016)

Werdegang

Juni 2019:
Best Paper award at the 8th Symposium on Languages, Applications, Technologies (SLATE). For »Definite Clause Grammars with Parse Trees: Extension for Prolog« (Nogatz, Seipel, Abreu).
September 2018:
RuleML+RR Full Student Grant, Luxembourg
Juli 2018:
FLoC Student Grant, Oxford, UK
Juni 2018:
Auszeichnung mit dem Goldenen Binärbaum für gute Lehre durch das Institut für Informatik, Universität Würzburg
Dezember 2016:
Publikumspreis beim DB Hackathon, Projekt "Preisvorsprung"
seit Oktober 2015:
Wissenschaftlicher Mitarbeiter am Lehrstuhl für Informatik I, Universität Würzburg
2010 – 2015:
Studium der Informatik an der Universität Ulm

Veröffentlichungen

[ 2019 ]
[ 2018 ]
[ 2017 ]
[ 2016 ]
[ 2015 ]
[ 2014 ]
[ 2013 ]

2019[ to top ]

Nogatz, F., Körner, P., Krings, S.: Prolog Coding Guidelines: Status and Tool Support In: Technical Communications of the 35th International Conference on Logic Programming (ICLP) (2019).

(to appear)
- [ Abstract ]
- [ BibTeX ]
The importance of coding guidelines is generally accepted throughout developers of every programming language. Naturally, Prolog makes no exception. However, establishing coding guidelines is fraught with obstacles: Finding common ground on kind and selection of rules is matter of debate; once found, adhering to or enforcing rules is complicated as well, not least because of Prolog’s flexible syntax without keywords. In this paper, we evaluate the status of coding guidelines in the Prolog community and discuss to what extent they can be automatically verified. We implemented a linter for Prolog and applied it to several packages to get a hold on the current state of the community.

@inproceedings{nogatz2019prolog, abstract = {The importance of coding guidelines is generally accepted throughout developers of every programming language. Naturally, Prolog makes no exception. However, establishing coding guidelines is fraught with obstacles: Finding common ground on kind and selection of rules is matter of debate; once found, adhering to or enforcing rules is complicated as well, not least because of Prolog’s flexible syntax without keywords. In this paper, we evaluate the status of coding guidelines in the Prolog community and discuss to what extent they can be automatically verified. We implemented a linter for Prolog and applied it to several packages to get a hold on the current state of the community.}, author = {Nogatz, Falco and Körner, Philipp and Krings, Sebastian}, booktitle = {Technical Communications of the 35th International Conference on Logic Programming (ICLP)}, keywords = {myown}, note = {(to appear)}, title = {Prolog Coding Guidelines: Status and Tool Support}, year = 2019 }
Nogatz, F., Kübert, J., Seipel, D., Abreu, S.: Alexa, How Can I Reason with Prolog? In: Proceedings of 8th Symposium on Languages, Applications, Technologies (SLATE). pp. 17:1–17:9 (2019).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
- [ DOI ]
As with Amazon’s Echo and its conversational agent Alexa, smart voice-controlled devices become ever more present in daily life, and many different applications can be integrated into this platform. In this paper, we present a framework that eases the development of skills in Prolog. As Prolog has a long history in natural language processing, we may integrate well-established techniques, such as reasoning about knowledge with Attempto Controlled English, instead of depending on example phrases and pre-defined slots.

@inproceedings{nogatz2019alexa, abstract = {As with Amazon’s Echo and its conversational agent Alexa, smart voice-controlled devices become ever more present in daily life, and many different applications can be integrated into this platform. In this paper, we present a framework that eases the development of skills in Prolog. As Prolog has a long history in natural language processing, we may integrate well-established techniques, such as reasoning about knowledge with Attempto Controlled English, instead of depending on example phrases and pre-defined slots.}, author = {Nogatz, Falco and Kübert, Julia and Seipel, Dietmar and Abreu, Salvador}, booktitle = {Proceedings of 8th Symposium on Languages, Applications, Technologies (SLATE)}, keywords = {myown}, pages = {17:1-17:9}, series = {OpenAccess Series in Informatics (OASIcs)}, title = {Alexa, How Can I Reason with Prolog?}, volume = 74, year = 2019 }
Nogatz, F., Seipel, D., Abreu, S.: Definite Clause Grammars with Parse Trees: Extension for Prolog In: Proceedings of 8th Symposium on Languages, Applications, Technologies (SLATE). pp. 7:1–7:14 (2019).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
- [ DOI ]
Definite Clause Grammars (DCGs) are a convenient way to specify possibly non-context-free grammars for natural and formal languages. They can be used to progressively build a parse tree as grammar rules are applied by providing an extra argument in the DCG rule’s head. In the simplest way, this is a structure that contains the name of the used nonterminal. This extension of a DCG has been proposed for natural language processing in the past and can be done automatically in Prolog using term expansion. We extend this approach by a meta-nonterminal to specify optional and sequences of nonterminals, as these structures are common in grammars for formal, domain-specific languages. We specify a term expansion that represents these sequences as lists while preserving the grammar’s ability to be used both for parsing and serialising, i.e. to create a parse tree by a given source code and vice-versa. We show that this mechanism can be used to lift grammars specified in extended Backus–Naur form (EBNF) to generate parse trees. As a case study, we present a parser for the Prolog programming language itself based only on the grammars given in the ISO Prolog standard which produces corresponding parse trees.

@inproceedings{nogatz2019dcg4pt, abstract = {Definite Clause Grammars (DCGs) are a convenient way to specify possibly non-context-free grammars for natural and formal languages. They can be used to progressively build a parse tree as grammar rules are applied by providing an extra argument in the DCG rule’s head. In the simplest way, this is a structure that contains the name of the used nonterminal. This extension of a DCG has been proposed for natural language processing in the past and can be done automatically in Prolog using term expansion. We extend this approach by a meta-nonterminal to specify optional and sequences of nonterminals, as these structures are common in grammars for formal, domain-specific languages. We specify a term expansion that represents these sequences as lists while preserving the grammar’s ability to be used both for parsing and serialising, i.e. to create a parse tree by a given source code and vice-versa. We show that this mechanism can be used to lift grammars specified in extended Backus–Naur form (EBNF) to generate parse trees. As a case study, we present a parser for the Prolog programming language itself based only on the grammars given in the ISO Prolog standard which produces corresponding parse trees.}, author = {Nogatz, Falco and Seipel, Dietmar and Abreu, Salvador}, booktitle = {Proceedings of 8th Symposium on Languages, Applications, Technologies (SLATE)}, keywords = {myown}, pages = {7:1-7:14}, series = {OpenAccess Series in Informatics (OASIcs)}, title = {Definite Clause Grammars with Parse Trees: Extension for Prolog}, volume = 74, year = 2019 }

2018[ to top ]

Nogatz, F., Kalkus, J., Seipel, D.: Web-based Visualisation for Definite Clause Grammars using Prolog Meta-Interpreters: System Description In: Proceedings of the 20th International Symposium on Principles and Practice of Declarative Programming (2018).
- [ Abstract ]
- [ BibTeX ]
- [ DOI ]
Definite Clause Grammars (DCGs) are a convenient way to describe lists in Prolog. They are a common mean to specify grammars for natural language processing and to parse formal languages. Despite its long history, tools dedicated to the development and debugging of DCGs are rare. In this paper, we present an interactive, web-based tool to visualise the execution of a DCG. To collect the required information from SWI-Prolog, we discuss several techniques, including meta-interpreters, trace interceptors, and term expansions.

@inproceedings{nogatz2018dcgmetainterpreter, abstract = {Definite Clause Grammars (DCGs) are a convenient way to describe lists in Prolog. They are a common mean to specify grammars for natural language processing and to parse formal languages. Despite its long history, tools dedicated to the development and debugging of DCGs are rare. In this paper, we present an interactive, web-based tool to visualise the execution of a DCG. To collect the required information from SWI-Prolog, we discuss several techniques, including meta-interpreters, trace interceptors, and term expansions.}, author = {Nogatz, Falco and Kalkus, Jona and Seipel, Dietmar}, booktitle = {Proceedings of the 20th International Symposium on Principles and Practice of Declarative Programming}, keywords = {myown}, title = {Web-based Visualisation for Definite Clause Grammars using Prolog Meta-Interpreters: System Description}, year = 2018 }
Nogatz, F., Frühwirth, T., Seipel, D.: CHR.js: A CHR Implementation in JavaScript In: Rules and Reasoning. pp. 131–146. Springer (2018).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
- [ DOI ]
Constraint Handling Rules (CHR) is usually compiled to logic programming languages. While there are implementations for imperative programming languages such as C and Java, its most popular host language remains Prolog. In this paper, we present CHR.js, a CHR system implemented in JavaScript, that is suitable for both the server-side and interactive client-side web applications. CHR.js provides (i) an interpreter, which is based on the asynchronous execution model of JavaScript, and (ii) an ahead-of-time compiler, resulting in synchronous constraint solvers with better performances. Because of the great popularity of JavaScript, CHR.js is the first CHR system that runs on almost all and even mobile devices, without the need for an additional runtime environment. As an example application we present the CHR.js Playground, an offline-capable web-interface which allows the interactive exploration of CHRs in every modern browser.

@inproceedings{nogatz2018chrjs, abstract = {Constraint Handling Rules (CHR) is usually compiled to logic programming languages. While there are implementations for imperative programming languages such as C and Java, its most popular host language remains Prolog. In this paper, we present CHR.js, a CHR system implemented in JavaScript, that is suitable for both the server-side and interactive client-side web applications. CHR.js provides (i) an interpreter, which is based on the asynchronous execution model of JavaScript, and (ii) an ahead-of-time compiler, resulting in synchronous constraint solvers with better performances. Because of the great popularity of JavaScript, CHR.js is the first CHR system that runs on almost all and even mobile devices, without the need for an additional runtime environment. As an example application we present the CHR.js Playground, an offline-capable web-interface which allows the interactive exploration of CHRs in every modern browser.}, author = {Nogatz, Falco and Frühwirth, Thom and Seipel, Dietmar}, booktitle = {Rules and Reasoning}, keywords = {myown}, month = {aug}, pages = {131-146}, publisher = {Springer}, title = {CHR.js: A CHR Implementation in JavaScript}, volume = 11092, year = 2018 }
Nogatz, F., Kalkus, J.: Declarative XML Schema Validation with SWI-Prolog In: Seipel, D., Hanus, M., and Abreu, S. (eds.) Declarative Programming and Knowledge Management. pp. 187–197 (2018).
- [ Abstract ]
- [ BibTeX ]
- [ DOI ]
XML Schema is a well-established mechanism to define the structure and constrain the content of an XML document. While this approach taken by itself is declarative, currently available tools for XML validation are not. In this paper we introduce an implementation of an XSD validator in SWI-Prolog, made publicly available as the package library(xsd). Our approach is based on flattening the XSD and XML documents into Prolog facts. The top-down validation makes great use of Prolog's backtracking and unification capabilities. To ensure the compliance to the XSD standard and to support the test-driven development, we have created a test framework based on the Test Anything Protocol and SWI-Prolog's quasi-quotations.

@inproceedings{nogatz2018declarative, abstract = {XML Schema is a well-established mechanism to define the structure and constrain the content of an XML document. While this approach taken by itself is declarative, currently available tools for XML validation are not. In this paper we introduce an implementation of an XSD validator in SWI-Prolog, made publicly available as the package library(xsd). Our approach is based on flattening the XSD and XML documents into Prolog facts. The top-down validation makes great use of Prolog's backtracking and unification capabilities. To ensure the compliance to the XSD standard and to support the test-driven development, we have created a test framework based on the Test Anything Protocol and SWI-Prolog's quasi-quotations.}, author = {Nogatz, Falco and Kalkus, Jona}, booktitle = {Declarative Programming and Knowledge Management}, editor = {Seipel, Dietmar and Hanus, Michael and Abreu, Salvador}, keywords = {myown}, pages = {187-197}, title = {Declarative XML Schema Validation with SWI-Prolog}, year = 2018 }
Seipel, D., Nogatz, F., Abreu, S.: Domain-specific languages in Prolog for declarative expert knowledge in rules and ontologies Computer Languages, Systems & Structures. 51C, 102–117 (2018).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
- [ DOI ]
Declarative if–then rules have proven very useful in many applications of expert systems. They can be managed in deductive databases and evaluated using the well-known forward-chaining approach. For domain-experts, however, the syntax of rules becomes complicated quickly, and already many different knowledge representation formalisms exist. Expert knowledge is often acquired in story form using interviews. In this paper, we discuss its representation by defining domain-specific languages (DSLs) for declarative expert rules. They can be embedded in Prolog systems in internal DSLs using term expansion and as external DSLs using definite clause grammars and quasi-quotations – for more sophisticated syntaxes. Based on the declarative rules and the integration with the Prolog-based deductive database system DDBase, multiple rules acquired in practical case studies can be combined, compared, graphically analysed by domain-experts, and evaluated, resulting in an extensible system for expert knowledge. As a result, the actual modeling DSL becomes executable; the declarative forward-chaining evaluation of deductive databases can be understood by the domain experts. Our DSL for rules can be further improved by integrating ontologies and rule annotations.

@article{Seipel2017, abstract = {Declarative if–then rules have proven very useful in many applications of expert systems. They can be managed in deductive databases and evaluated using the well-known forward-chaining approach. For domain-experts, however, the syntax of rules becomes complicated quickly, and already many different knowledge representation formalisms exist. Expert knowledge is often acquired in story form using interviews. In this paper, we discuss its representation by defining domain-specific languages (DSLs) for declarative expert rules. They can be embedded in Prolog systems in internal DSLs using term expansion and as external DSLs using definite clause grammars and quasi-quotations – for more sophisticated syntaxes. Based on the declarative rules and the integration with the Prolog-based deductive database system DDBase, multiple rules acquired in practical case studies can be combined, compared, graphically analysed by domain-experts, and evaluated, resulting in an extensible system for expert knowledge. As a result, the actual modeling DSL becomes executable; the declarative forward-chaining evaluation of deductive databases can be understood by the domain experts. Our DSL for rules can be further improved by integrating ontologies and rule annotations.}, author = {Seipel, Dietmar and Nogatz, Falco and Abreu, Salvador}, journal = {Computer Languages, Systems & Structures}, keywords = {myown}, pages = {102-117}, title = {Domain-specific languages in Prolog for declarative expert knowledge in rules and ontologies}, volume = {51C}, year = 2018 }

2017[ to top ]

Seipel, D., Nogatz, F., Abreu, S.: Prolog for Expert Knowledge Using Domain-Specific and Controlled Natural Languages In: Proceedings of 8th Language & Technology Conference: Human Language Technologies as a Challenge for Computer Science and Linguistics (LTC). pp. 138–140 (2017).
- [ Abstract ]
- [ BibTeX ]
For representing knowledge in intelligent systems in a declarative and natural way, two major approaches have been used in the past: (1) domain–specific languages (DSLs), and (2) controlled natural languages (CNLs). Early DSLs were defined by technical and abstract syntaxes, e.g., for EBNF and regular expressions. More recently, there is a trend in defining DSLs based on natural language, e.g., for the standard relational query language SQL. On the other hand, CNLs stem from computer linguistics, driven by the idea of representing knowledge as a subset of natural languages. Both approaches have proven very useful in many applications. In this paper, we discuss the two approaches for knowledge representation, namely using DSLs and CNLs. Prolog has a long history in both worlds: with the help of user–defined operators, term expansions, and definite clause grammars, it has proven to be very suitable for defining new DSLs with a natural language flavour.

@inproceedings{seipel2017prolog, abstract = {For representing knowledge in intelligent systems in a declarative and natural way, two major approaches have been used in the past: (1) domain–specific languages (DSLs), and (2) controlled natural languages (CNLs). Early DSLs were defined by technical and abstract syntaxes, e.g., for EBNF and regular expressions. More recently, there is a trend in defining DSLs based on natural language, e.g., for the standard relational query language SQL. On the other hand, CNLs stem from computer linguistics, driven by the idea of representing knowledge as a subset of natural languages. Both approaches have proven very useful in many applications. In this paper, we discuss the two approaches for knowledge representation, namely using DSLs and CNLs. Prolog has a long history in both worlds: with the help of user–defined operators, term expansions, and definite clause grammars, it has proven to be very suitable for defining new DSLs with a natural language flavour.}, author = {Seipel, Dietmar and Nogatz, Falco and Abreu, Salvador}, journal = {Proceedings of 8th Language & Technology Conference: Human Language Technologies as a Challenge for Computer Science and Linguistics (LTC)}, keywords = {myown}, month = {nov}, pages = {138-140}, title = {Prolog for Expert Knowledge Using Domain-Specific and Controlled Natural Languages}, year = 2017 }

2016[ to top ]

Nogatz, F., Seipel, D.: Implementing GraphQL as a Query Language for Deductive Databases in SWI–Prolog Using DCGs, Quasi Quotations, and Dicts In: Proceedings of the 30th Workshop on (Constraint) Logic Programming (WLP 2016) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
The methods to access large relational databases in a distributed system are well established: the relational query language SQL often serves as a low-level language for data access and manipulation, and in addition several endpoints are exposed by public interfaces using for example REST. Similarly to REST, GraphQL is the query protocol of an application layer developed by Facebook. It provides a unified interface between the client and the server for data fetching and manipulation. Using GraphQL's type system, it is possible to specify data handling of various sources and combine, e.g., relational with NoSQL databases. In contrast to REST, GraphQL provides a single endpoint and supports flexible queries over linked data. This makes GraphQL a perfect fit as an interface for deductive databases. In this paper, we give an introduction of GraphQL and a comparison to REST. Using language features recently added to SWI-Prolog 7, we have developed the Prolog library GraphQL.pl, which implements the GraphQL type system and query syntax as a domain-specific language with the help of DCGs. Using our library, the type system created for a deductive database can be validated, while the query system provides a unified interface for data access and introspection.

@inproceedings{nogatz2016graphql, abstract = {The methods to access large relational databases in a distributed system are well established: the relational query language SQL often serves as a low-level language for data access and manipulation, and in addition several endpoints are exposed by public interfaces using for example REST. Similarly to REST, GraphQL is the query protocol of an application layer developed by Facebook. It provides a unified interface between the client and the server for data fetching and manipulation. Using GraphQL's type system, it is possible to specify data handling of various sources and combine, e.g., relational with NoSQL databases. In contrast to REST, GraphQL provides a single endpoint and supports flexible queries over linked data. This makes GraphQL a perfect fit as an interface for deductive databases. In this paper, we give an introduction of GraphQL and a comparison to REST. Using language features recently added to SWI-Prolog 7, we have developed the Prolog library GraphQL.pl, which implements the GraphQL type system and query syntax as a domain-specific language with the help of DCGs. Using our library, the type system created for a deductive database can be validated, while the query system provides a unified interface for data access and introspection.}, author = {Nogatz, Falco and Seipel, Dietmar}, journal = {Proceedings of the 30th Workshop on (Constraint) Logic Programming (WLP 2016)}, keywords = {myown}, month = {sep}, title = {Implementing GraphQL as a Query Language for Deductive Databases in SWI–Prolog Using DCGs, Quasi Quotations, and Dicts}, year = 2016 }
Seipel, D., von der Weth, R., Abreu, S., Nogatz, F., Werner, A.: Declarative Rules for Annotated Expert Knowledge in Change Management In: Proceedings of 5th Symposium on Languages, Applications, Technologies (SLATE 2016) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
In this paper, we use declarative and domain-specific languages for representing expert knowledge in the field of change management in organisational psychology. Expert rules obtained in practical case studies are represented as declarative rules in a deductive database. The expert rules are annotated by information describing their provenance and confidence. Additional provenance information for the whole - or parts of the - rule base can be given by ontologies. Deductive databases allow for declaratively defining the semantics of the expert knowledge with rules. The evaluation of the rules can be optimised and the inference mechanisms could be changed, since they are specified in an abstract way. As the logical syntax of rules had been a problem in previous applications of deductive databases, we use specially designed domain-specific languages to make the rule syntax easier for non-programmers. The semantics of the whole knowledge base is declarative. The rules are written declaratively in an extension Datalog* of the well-known deductive database language Datalog on the data level, and additional Datalog* rules can configure the processing of the annotated rules and the ontologies.

@inproceedings{seipel2016declarative, abstract = {In this paper, we use declarative and domain-specific languages for representing expert knowledge in the field of change management in organisational psychology. Expert rules obtained in practical case studies are represented as declarative rules in a deductive database. The expert rules are annotated by information describing their provenance and confidence. Additional provenance information for the whole - or parts of the - rule base can be given by ontologies. Deductive databases allow for declaratively defining the semantics of the expert knowledge with rules. The evaluation of the rules can be optimised and the inference mechanisms could be changed, since they are specified in an abstract way. As the logical syntax of rules had been a problem in previous applications of deductive databases, we use specially designed domain-specific languages to make the rule syntax easier for non-programmers. The semantics of the whole knowledge base is declarative. The rules are written declaratively in an extension Datalog* of the well-known deductive database language Datalog on the data level, and additional Datalog* rules can configure the processing of the annotated rules and the ontologies.}, author = {Seipel, Dietmar and von der Weth, Rüdiger and Abreu, Salvador and Nogatz, Falco and Werner, Alexander}, journal = {Proceedings of 5th Symposium on Languages, Applications, Technologies (SLATE 2016)}, keywords = {myown}, title = {Declarative Rules for Annotated Expert Knowledge in Change Management}, year = 2016 }
von der Weth, R., Seipel, D., Nogatz, F., Schubach, K., Werner, A., Wortha, F.: Modellierung von Handlungswissen aus fragmentiertem und heterogenem Rohdatenmaterial durch inkrementelle Verfeinerung in einem Regelbanksystem Psychologie des Alltagshandelns. 9, 33–48 (2016).
- [ Abstract ]
- [ BibTeX ]
Neben explizit dargestellten Geschäftsprozessen und Verfahrensregeln gibt es in Organisationen häufig nicht dokumentiertes Handlungswissen in Form informeller Vorgehensregeln. Dieses Wissen lässt sich meist nicht mit dem expliziten vergleichen, da es nicht in einheitlicher Weise erhoben werden kann und zudem meist fragmentiert in verteilten Quellen (Individuen, Gruppen) vorliegt. Die hier vorgestellte Methode soll es ermöglichen, unterschiedlich erhobene Vorgehensregeln durch ein inhaltsanalytisches Verfahren zunächst in ein einheitliches Format zu überführen. Dieses bildet die Grundlage zur Verwaltung der Regeln im deduktiven Datenbanksystem DDBASE, mit dessen Hilfe die einzelnen Vorgehensregeln schon bei der Eingabe analysiert und dann bei der Auswertung verknüpft werden können. Das vorgestellte System unterstützt neben der grafischen Repräsentation auch automatisches Schließen, sodass Schlussfolgerungen gebildet und Widersprüche erkannt werden können. Durch die stetige Erweiterung der Regeln können so neue Thesen in das Gesamtbild eingebracht werden, welches somit über den Umfang einer einzelnen Studie hinausgeht. Als Ergebnis kann so auf Organisationsebene informelles Wissen mit „offiziellen“ Regeln verglichen und Organisationsentwicklungsprozesse exakter modelliert werden.

@article{vonderweth2016modellierung, abstract = {Neben explizit dargestellten Geschäftsprozessen und Verfahrensregeln gibt es in Organisationen häufig nicht dokumentiertes Handlungswissen in Form informeller Vorgehensregeln. Dieses Wissen lässt sich meist nicht mit dem expliziten vergleichen, da es nicht in einheitlicher Weise erhoben werden kann und zudem meist fragmentiert in verteilten Quellen (Individuen, Gruppen) vorliegt. Die hier vorgestellte Methode soll es ermöglichen, unterschiedlich erhobene Vorgehensregeln durch ein inhaltsanalytisches Verfahren zunächst in ein einheitliches Format zu überführen. Dieses bildet die Grundlage zur Verwaltung der Regeln im deduktiven Datenbanksystem DDBASE, mit dessen Hilfe die einzelnen Vorgehensregeln schon bei der Eingabe analysiert und dann bei der Auswertung verknüpft werden können. Das vorgestellte System unterstützt neben der grafischen Repräsentation auch automatisches Schließen, sodass Schlussfolgerungen gebildet und Widersprüche erkannt werden können. Durch die stetige Erweiterung der Regeln können so neue Thesen in das Gesamtbild eingebracht werden, welches somit über den Umfang einer einzelnen Studie hinausgeht. Als Ergebnis kann so auf Organisationsebene informelles Wissen mit „offiziellen“ Regeln verglichen und Organisationsentwicklungsprozesse exakter modelliert werden.}, author = {von der Weth, Rüdiger and Seipel, Dietmar and Nogatz, Falco and Schubach, Katrin and Werner, Alexander and Wortha, Franz}, journal = {Psychologie des Alltagshandelns}, keywords = {myown}, month = {nov}, number = 2, pages = {33-48}, publisher = {innsbruck university press}, title = {Modellierung von Handlungswissen aus fragmentiertem und heterogenem Rohdatenmaterial durch inkrementelle Verfeinerung in einem Regelbanksystem}, volume = 9, year = 2016 }

2015[ to top ]

Nogatz, F.: CHR.js: Compiling Constraint Handling Rules to JavaScript Master Thesis, University of Ulm, Germany (2015).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
Constraint Handling Rules (CHR) is a high-level programming language extension which introduces declarative multiset semantics. Although originally designed in the early 1990s, the number of implementations is still small. While there are adaptions for popular imperative programming languages such as C and Java, its most popular host language is Prolog. As a result, the dissemination of CHR is currently restricted almost entirely to research community. In this thesis we present an implementation of CHR in JavaScript. By embedding it into the dominating web programming language which recently got adopted for server-side frameworks as well, we open this declarative approach to a broad range of developers and new use cases. The embedding of CHR in JavaScript gives the chance to easily create applications with CHR in combination with front-end functions. As a result, we created a web-interface to explore the evaluation of Constraint Handling Rules interactively This visual CHR tracer is based on the created interpreter called CHR.js, whose main target is the full extensibility of CHR. To remain competitive with existing CHR implementations, we created a transpiler for precompilation of CHR.js source code.

@mastersthesis{nogatz2015chrjs, abstract = {Constraint Handling Rules (CHR) is a high-level programming language extension which introduces declarative multiset semantics. Although originally designed in the early 1990s, the number of implementations is still small. While there are adaptions for popular imperative programming languages such as C and Java, its most popular host language is Prolog. As a result, the dissemination of CHR is currently restricted almost entirely to research community. In this thesis we present an implementation of CHR in JavaScript. By embedding it into the dominating web programming language which recently got adopted for server-side frameworks as well, we open this declarative approach to a broad range of developers and new use cases. The embedding of CHR in JavaScript gives the chance to easily create applications with CHR in combination with front-end functions. As a result, we created a web-interface to explore the evaluation of Constraint Handling Rules interactively This visual CHR tracer is based on the created interpreter called CHR.js, whose main target is the full extensibility of CHR. To remain competitive with existing CHR implementations, we created a transpiler for precompilation of CHR.js source code.}, author = {Nogatz, Falco}, journal = {Masterthesis}, keywords = {myown}, school = {Master Thesis, University of Ulm, Germany}, title = {CHR.js: Compiling Constraint Handling Rules to JavaScript}, year = 2015 }

2014[ to top ]

Nogatz, F., Frühwirth, T.: From XML Schema to JSON Schema: Translation with CHR In: Proceedings of the 11th International Workshop on Constraint Handling Rules (2014).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
Despite its rising popularity as data format especially for web services, the software ecosystem around the JavaScript Object Notation (JSON) is not as widely distributed as that of XML. For both data formats there exist schema languages to specify the structure of instance documents, but there is currently no opportunity to translate already existing XML Schema documents into equivalent JSON Schemas. In this paper we introduce an implementation of a language translator. It takes an XML Schema and creates its equivalent JSON Schema document. Our approach is based on Prolog and CHR. By unfolding the XML Schema document into CHR constraints, it is possible to specify the concrete translation rules in a declarative way.

@inproceedings{journals/corr/NogatzF14, abstract = {Despite its rising popularity as data format especially for web services, the software ecosystem around the JavaScript Object Notation (JSON) is not as widely distributed as that of XML. For both data formats there exist schema languages to specify the structure of instance documents, but there is currently no opportunity to translate already existing XML Schema documents into equivalent JSON Schemas. In this paper we introduce an implementation of a language translator. It takes an XML Schema and creates its equivalent JSON Schema document. Our approach is based on Prolog and CHR. By unfolding the XML Schema document into CHR constraints, it is possible to specify the concrete translation rules in a declarative way.}, author = {Nogatz, Falco and Frühwirth, Thom}, journal = {Proceedings of the 11th International Workshop on Constraint Handling Rules}, keywords = {myown}, title = {From XML Schema to JSON Schema: Translation with CHR}, year = 2014 }

2013[ to top ]

Nogatz, F.: From XML Schema to JSON Schema - Comparison and Translation with Constraint Handling Rules Bachelor Thesis, University of Ulm, Germany (2013).
- [ Abstract ]
- [ BibTeX ]
- [ URL ]
This thesis identifies similar semantics in the two schema definition languages XML Schema and JSON Schema to build a dictionary which covers typical use cases to automatically transform first to the latter. As the range of functions of both XML Schema and JSON Schema are not identical, concrete transformation rules to reproduce similar behavior of data constraints are discussed and implemented by use of the logic programming language Constraint Handling Rules. As a result, a Prolog library xsd2json is created which provides tools to translate complex XML Schema documents into their equivalent JSON Schema documents.

@mastersthesis{nogatz2013xsd2json, abstract = {This thesis identifies similar semantics in the two schema definition languages XML Schema and JSON Schema to build a dictionary which covers typical use cases to automatically transform first to the latter. As the range of functions of both XML Schema and JSON Schema are not identical, concrete transformation rules to reproduce similar behavior of data constraints are discussed and implemented by use of the logic programming language Constraint Handling Rules. As a result, a Prolog library xsd2json is created which provides tools to translate complex XML Schema documents into their equivalent JSON Schema documents.}, author = {Nogatz, Falco}, journal = {Bachelor Thesis}, keywords = {myown}, school = {Bachelor Thesis, University of Ulm, Germany}, title = {From XML Schema to JSON Schema - Comparison and Translation with Constraint Handling Rules}, year = 2013 }

Reviewing

2019

WLP: 33rd Workshop on (Constraint) Logic Programming
INAP*: 22nd International Conference on Applications of Declarative Programming and Knowledge Management

2018

WFLP*: 26th International Workshop on Functional and Logic Programming
ICLP*: 34th International Conference on Logic Programming
COMLAN*: International Journal of Computer Languages, Systems and Structures
Declare'17*: Proceedings of the Declare'17 Conference

2017

INAP*: 21st International Conference on Applications of Declarative Programming and Knowledge Management
WFLP*: 25th International Workshop on Functional and Logic Programming
PPDP*: 19th International Symposium on Principles and Practice of Declarative Programming
ICLP*: 33rd International Conference on Logic Programming
SLATE*: Symposium on Languages, Applications and Technologies
COMLAN*: International Journal of Computer Languages, Systems and Structures

2016

IJA*: International Journal of Approximate Reasoning
WLP*: 30th Workshop on (Constraint) Logic Programming
SLATE*: Symposium on Languages, Applications and Technologies

* Reviews done as sub-reviewer.

Falco Nogatz, M.Sc.

Lehrveranstaltungen

Betreuung studentischer Arbeiten

Betreute Abschlussarbeiten:

Betreute Masterpraktika:

Betreute Seminararbeiten:

Werdegang

Veröffentlichungen

Reviewing

2019

2018

2017

2016

Hinweis zum Datenschutz

Hinweis zum Datenschutz

Bildnachweise