On The New Prospects for Knowledge Representation in The Time of Dynamic Compilation
|Director of thesis||Prof. Kilian Stoffel|
|Co-director of thesis|
|Summary of thesis||
Even though KB systems differ in their motivation from standard enterprise applications, both rely in their essence on translating what we know about a certain domain into computer models that can be used to support business operations in that domain. Concepts and techniques in Knowledge Representation and Reasoning have also proven useful in various areas of information systems like in configurations, diagnosing medical conditions, the semantic web and many others. Nevertheless, adopting a KR approach is still regarded with caution in the circles of conventional software developers and when it comes to standard enterprise applications development, software engineers most often choose to adhere to their long-established heritage of expressing domain knowledge in a relational scheme and encapsulating it with some layers including the business rules layer that is usually expressed in an imperative manner. Nowadays and in response to big data calls, we can observe a growing trend in shifting from this traditional conservative and rather over-engineered approach towards a more open and flexible architectures that tolerate less structured data models.
My research interests lie in the potentials of pushing this trend of openness even more by importing concepts from knowledge representation into traditional applications development so that instead of revolving in two different orbits, efforts spent in both paradigms can benefit one another. More precisely I am interested in expressing domain knowledge usually represented using an ontological language such as OWL in a more general purpose programming language such as Java or python. In fact, on the contrary to the apparent complexity of integrating ontologies into conventional applications, such an integration could simplify the handling of constantly changing requirements and in the same time foster more possibilities for entailment reasoning. Unfolding this twofold hypothesis yields many interesting questions that are worth further investigation and analysis:
* Can we “easily” integrate ontologies into a conventional codebase? I.e., Can we bring ontologies into the comfort-zone of end-application developers by expressing them in a language or a programming paradigm, say, OOP paradigm that developers are already familiar with?
* How would this potential translation into executables impact the expressiveness of the executable ontology compared to the source? Vice versa, since the domain knowledge is now contained in the executable, would this reduce or even eliminate the need for imperative business rules?
* What are the possible forms of entailment that can be performed in such settings? How do they compare into state of the art entailment regimes? Would using meta-programming techniques suit the potential entailment procedures?
* To which extent can we exploit the compiler dynamic compilation feature in materializing entailed statements and would such a materialization help in reducing code refactoring time?
|Administrative delay for the defence|