Relationships, Objects, Roles, and Queries in Modern Programming Languages

Motivation

The notions of relationship, object and role are common in many domains such as, for example, sociology, cognitive science, organisational science and linguistics. These notions are also well-supported in many areas of computer science, including: conceptual modeling, database systems, formal ontology and computational linguistics. However, despite their fundamental importance, these notions are still poorly represented in modern programming languages.

More specifically, while modern object-oriented programming languages provide first-class support for objects, they lack any notion of relationships and roles. In such languages, objects are forced to implement relationships and roles using a variety of ad-hoc mechanisms (e.g., pointers and hash-tables) leading to a disconnect between designs and models and their implementation. This leads to numerous problems across the software engineering life cycle. At the implementation level, the reliability and maintainability of software are particularly affected. This is because a single role or relationship may be represented by several code fragments that are scattered widely throughout the source code of an application. In current mainstream languages, programmers are also burdened with having to manage consistency properties on relationships explicitly (e.g., the fact that a relationship is one-to-many), and by the lack of linguistic support for commonly used operations on relationships such as querying and join operations.

To address these issues, a growing number of researchers in the software community are incorporating first-class support for relationships, roles, and querying into modern programming languages. There are several different reasons why researchers are motivated to do this:

• Researchers in programming language design wish to bridge the gap between implementation and design. As discussed above, this is because the lack of relationships, roles, and querying at the implementation level causes a disconnect from the design.
• Researchers in program analysis are interested in raising the level of abstraction in programming languages. This is because the absence of language support for relationships, roles, and querying leads to an increased use of pointers. In turn, this complicates many tasks in program analysis as precise pointer alias information becomes necessary.
• Researchers in databases are keen to bridge the ``impedance mismatch'' between programs and databases. Many current languages rely on the use of string values for accessing and querying data bases, which is error-prone, and can lead to security vulnerabilities.
• In the absence of language support for querying, many commonly used operations need to be expressed using nested loops and complex conditional statements. This makes code harder to understand, optimize, and parallelize.
• Researchers in modelling languages and knowledge representation want to clarify whether roles and relationships are dual notions, or whether one can be substituted for by the other. This has an impact on programming language design, in that it helps keeping the number of new constructs as small as possible.

The purpose of this workshop is to bring together leading researchers working on relationship-, role- and query-based systems and related areas for a week-long meeting. It is our aim to have presentations from each community on a balanced set of topics that is designed to be accessible and relevant to all involved. In this way, we aim to cross-fertilise important ideas from these communities, and push forward the state-of-the-art in their respective areas.