Graph databases are the next generation of relational databases, as they allow convenient retrieval of complex network structures and employ graph theory to store and navigate relationships. The resulting data models are simpler and more expressive than those produced using traditional relational databases. However, there is a shortage of tools for creating such graphs in an intuitive visual way. Metamodeling can help in this respect, as it enables the agile customization of tools for diagrammatic knowledge representation and editing, under constraints imposed through metamodels. Our goal is to present a modeling tool that was customized to support the creation of Resource Description Framework (RDF) data graphs, by integrating notions of Conceptual Modeling and the Agile Modeling Method Engineering (AMME) framework, using ADOxx as an instance environment to obtain a usable prototype - a starting point for the future evolution an Open Models Laboratory project. The proposed modeling tool is inspired by the model-driven code generation paradigm, as an ADOxx script was developed to generate, out of diagrammatic structures, RDF graphs written in the N-triples serialization syntax. The paper highlights benefits of the proposed modeling tool as this successfully resolves fundamental user-oriented issues regarding the easy production of knowledge graphs guided by the Linked Enterprise Data paradigm and supported by a Conceptual Modeling "look and feel".
Web 2.0 established a large information space where people share valuable data and
contribute human-readable knowledge in various fields - see Wikipedia, a free
encyclopedia project, where many individuals are motivated to contribute by adding and
revising content. The next stage, Web 3.0, has encouraged a similar production scale
and scope for machine-readable knowledge to be made available to Linked Enterprise
Data projects [
In order to support enterprise knowledge creation, conceptual modeling methods can be employed - not only for data modeling purposes, but also for capturing domain-specific abstractions, business entities and their relationships. Modeling methods are deployed as tools that enable the description of a system based on instantiated concepts defined on a metamodel level, and can be enhanced by mechanisms that are relevant for the production or transformation of knowledge graphs.
The goal of this paper is to present a conceptual modeling tool that was customized
with the help of a metamodeling methodology to allow users to easily construct RDF
knowledge graphs by visual means. The model-driven code generation paradigm
inspired the work, in the sense that the tool generates knowledge encoded in the
machine-readable N-triples syntax [
Code generation is acknowledged as a key benefit of conceptual modeling,
supporting the development of software systems in the sense that development time
becomes consistently shorter. As examples, Modeliosoft tool products [
The motivation for creating a new modeling tool for creating RDF data graphs is
that nowadays we have an increased utilization of enterprise knowledge, but the
means of creating that knowledge with an optimal learning curve for non-technical
users are limited. RDF graphs should be created in an easy way, not more
complicated than filling data in the cells of SQL tables, and not necessarily conforming a
preimposed schema since RDF graphs can be schemaless databases – i.e., instance data
can be created separately from the schema; or, the schema is employed for semantic
annotation purposes, to support reasoning rather than validation. Linked Enterprise
Data is commonly lifted or derived through adapters (e.g., D2RQ [
We aim to minimize the effort of RDF data creation by developing a diagrammatic
tool with conceptual modeling "look and feel", potentially evolving towards a flexible
knowledge base editor (with the possibility to add domain-specific dynamic notation
and other metamodeling-powered features). In the current draft, the tool only allows
simple graph editing, limited annotation of nodes and the generation of
machinereadable serialization. The key novelty is that this is built on an open access
metamodeling platform, ADOxx [
The requirements selected for this tool originate in teaching goals – i.e., to provide an intuitive RDF editing toolkit to novices, focusing on a visual building process as a replacement for the traditional text-based or form-based building. Additionally, a meta-requirement imposed the need to have an agilely evolving tool that can incorporate additional functionality and domain-specific annotations towards the goal of enabling enterprise knowledge creation – hence the adopted metamodeling approach.
The remainder of the paper is further structured as follows: Section 2 introduces background on the enablers - RDF, AMME and the ADOxx metamodeling platform. Section 3 provides methodological considerations in relation to Design Science, as a guide for this effort. Section 4 provides comments on related works and proposed benefits. Section 5 presents the modeling method conceptualization providing insights about syntax, semantics, the serialization mechanism and the modeling procedure. The paper ends with conclusions and an outlook to future developments. 2
Enterprises are willing to adopt the Linked Enterprise Data concept [
Agile development accepts change and even expects it, therefore the proposed tool
also highlights characteristics of Agile Modeling Method Engineering (AMME) as a
key methodology for customizing modeling tools for a diversity of purposes.
According to [
The standard technology for representing and sharing semantic information is the
Resource Description Framework (RDF), where "resources" can be anything
including documents, people, objects or abstract concepts. In particular, RDF is used to
publish and interlink data on the Web or to represent knowledge in knowledge
management applications. RDF employs a graph-based data model, which is significantly
different than the earlier interoperability standards such as XML (based on DOM and
hierarchical data structures). Data graphs are more flexible than DOM trees because
the queries are more powerful and flexible as they can navigate a graph in any
direction along arbitrary chains of relationships. RDF databases are considered NoSQL
databases since they are queried with other means than SQL – the standard language
for this is SPARQL [
The RDF data model is based on small units called statements, describing resources in the form of triples of resource identifiers (URIs): <Subject> <Predicate> <Object> .
As exemplified in Figure 1, the triples can be visualized as a connected graph, consisting of nodes and arcs. The subjects and objects of the triples are the nodes and the predicates form the arcs – however, predicates themselves can also be described thus becoming subjects (nodes) in other graphs. Resources are of two types: addressable, easy to access on the Web through a URL (files, e-mail accounts, Web services, HTML paragraphs) and non-addressable, representing abstract or concrete things that can have a representation on the Web but they generally exist independently of the Internet (concrete persons, places, attributes, verbs, concepts). This second category rely on a universal identification scheme - URIs which become the terms used to write RDF statements and at the same time act like identifiers (similar to ISBNs for books, but also indicating provenance as an HTTP domain). Most of the terms used in RDF statements are URIs or URLs, but there are some exceptions: the object can be anonymous/blank, without identity or provenance, or a literal representing a simple data value of some type - integer, boolean etc. Subjects can also be anonymous/blank, while the predicate is always an URI. RDF offers multiple syntaxes for writing such graphs in machine-readable form - the most important ones are Turtle, RDF/XML and N-triples. The paper's proposed modeling tool is programmed to automatically generate in N-triples the RDF data graphs that are built by visual means, as enabled by a metamodeling platform (ADOxx) and methodology (AMME). 2.2
Agile software development started as a global movement promoting a different way
of thinking than traditional approaches such as waterfall, encouraging evolutionary
development, continuous improvement and adaptability. In order to support agile
development, to transfer agility principles also to the world of conceptual modeling
and to motivate the relevance of agile modeling methods, the framework of AMME
was created. The following paragraph summarizes its role, as described in [
AMME is guided by modeling requirements which can evolve as richer semantics
become necessary for design-time and run-time modeling use cases, or are affected by
change requests as users become more familiar with modeling possibilities. The
outcome of AMME is a modeling tool tailored for a customized diagrammatic language,
including any relevant functionality that can be built on models created with that
language. The OMiLAB environment facilitates the deployment of AMME, fosters a
community of researchers having a common understanding of model value and of the
concept of modeling method as introduced by [
AMME has been applied to several OMiLAB projects - some of them are
presented in [
ADOxx [
In ADOxx diagrammatic elements are described by their conceptual schemata
defining machine-readable properties to be exposed to the modeler for editing. The
schemata will generate annotation sheets supporting various ways of describing or
linking model elements - they are repurposed in the work at hand to derive RDF
descriptions. A formal description of the ADOxx metamodeling approach was presented
in [
Design Science is a solution-oriented methodology focusing on the design and
investigation of artifacts developed to address a particular problem. For ex ample, the
design of an enterprise modeling method aligned to business goals is subordinated to
Design Science, as opposed to observational science which focuses on the utilization
of such methods. A modeling method becomes usable when deployed as a modeling
tool – however, both a method and a tool can be considered Design Science artifacts
(addressing requirements on different levels of abstraction and reusability). More
generally, artifacts can be models, methods, constructs, design theories. All these
categories are knowledge-containing - the knowledge may cover design logic,
conceptualization cycles, tool usage procedures etc. In our case, the artifact is a modeling
tool whose development steps have deployed the building blocks of the "modeling
method" notion published in [
The proposed tool can be considered the deployment of a modeling method – however, due to the origin of this tool in a student project guided as a learning experience, the development process was as follows: we initiated this effort as a simple ADOxx implementation exercise (triggered by the requirement to support basic RDF editing), followed by an abstraction exercise (i.e., a reflection on how the results illustrate the abstract notion of modeling method). For the future, we aim to formalize and extend this modeling method (as recommended by AMME), then to revisit the tool implementation coming from an enriched understanding of the modeling method concept and finally to evolve the tool according to the richer method specifications.
The project aims to address the shortage of visual RDF e diting tools by providing an open use and open source tool for this purpose. In the engineering cycle inspired by Design Science, the first step was the problem investigation, followed by the treatment design step (the interaction between artifact and context – a university setting where RDF is being taught as a knowledge representation technique). The next step, the design validation, takes place whenever changes are being made in artifact – currently this mostly took the form of basic tool testing. In addition, the treatment validation also involved the expert opinion of professors supervising the project. The simulation method has been used as the prototype can be easily applied in a simulated context for producing RDF graphs given some enterprise description.
A variety of tools have been developed during recent times to support a visual
management of knowledge representations, including knowledge graphs, ontologies or
diagrammatic models. TopBraid Composer [
Callimachus [
The proposed modeling tool is based on an evolving modeling method, driven by changing requirements that originated in a student project. This required the application of AMME in building a flexible modeling tool which can also evolve as the RDF specification evolves, or as additional features are required. Flexibility is enabled by employing metamodeling and ADOxx, where both the visualization layer and the code generation layer can be further enriched. In the current iteration the proposed tool is limited to instance-level graphs and limited schema support, therefore it does not extend to the scope covered by e.g., OWLGrEd. However, its implementation relying on OMiLAB resources (AMME, ADOxx) is open to a flexible evolution, and to an investigation of mapping the formal semantics of RDF and OWL to underlying metamodeling structures that facilitate the tool implementation.
The modeling tool presented in this paper allows the visual construction of RDF data graphs. The syntax in RDF is the set of rules an d principles that govern the structure of RDF statements, as composed of the three terms: a subject, a predicate (or property, relation, attribute) and an object. Based on these, a modeling symbol has been attached to each machine-readable concept in the ADOxx Development Toolkit.
Figure 2 describes the concepts that have explicit machine-readable semantics based on the minimum graph-based RDF semantics. The root class, D _construct, provides the predefined ADOxx skeleton for all concepts in modeling tool, any concept inherits from it several built-in properties allowing the definition of graphical notation and the conceptional schema of attributes for editable annotations/properties. The class Node was created for inheritance purposes, as this is not visible to users. The other subclasses represent the typical term types in RDF statements (URI/URL, Simple/Literal values, Anonymous/Blank, RDF Class). URI allows to set the prefix, whereas Literal values can get a data type and a language code as annotations. All of these terms are contained in Graphs, which is a class created for aggregation purposes (see the graphic container in Figure 4).
Modeling relations manifest as visual connectors, inside a model type. The relations created in the ADOxx Development Toolkit are highlighted in Figure 3, to ca pture some of the standard relations that occur in RDF graphs (rdf:type, rdfs:subClassOf) as well as visual connectors that become predicates. The proposed modeling tool is based on the model-driven code generation paradigm as an ADOxx script was developed to generate in N-triples syntax a serialization of the diagrammatic graphs. In the ADOxx Development Toolkit a menu item was created to trigger the script and generate the serialization code. Also, a function was created for storing internal IDs of modeling objects according to every connector that is created in diagrammatic models, which form the statements created graphically by the user by drawing the property relation between the subject and object nodes.
Figure 4 presents an example of a model and also the usage flow: the user creates visual data graphs – for each GUI event object IDs are stored in a text file; afterwards, this file is converted by a user-triggered menu item in the N-triples syntax according to the types of various nodes. The ADOxx script (see a code sample in Figure 5) for generating serializations in the N-triples syntax comprises the following procedures: ─ Procedure "GetGraphPrefix" searches graphs in the active model and obtains their ids. For each graph found, it searches for the attributes and the value is stored for using it further on nodes, to form the URIs; ─ Procedures "TransformURI", "TransformAnonymous", "TransformSimpleValue", as the IDs of nodes have been sen t to transform from object ID to the specific forms prescribed by the N-triples syntax: <URI> for nodes of type URI, underscore-prefixed identifiers for Anonymous, and typed values for literal nodes. For URIs, the graph-level prefix is added; ─ Procedures "TransformType", "TransformSubClassOf", the IDs of visual connectors are transformed according to their prescribed types (rdf:type, rdfs:subClassOf) or according to their URI. As suggested before, the modeling procedure is determined by how different steps of the code generation were scripted: IDs are collected through GUI interaction events and written in a text file during the graphical creation of connectors. Then, the user decides when to convert this collection of IDs into N-triples according to the syntactic rules of N-triples.
Validation checks are also applied to ensure correctness: the metamodel-level constraints allow the user to create graphs to contain any subjects, predicates and objects as long as the statements are correctly and conforming to RDF principles. In other words, it prevents errors such as: a simple value cannot be a subject, a "subClassOf" connector can only connect "Classes" etc. Another aspect that requires sanity checks is the graph structure: the statements must be part of some graph, and also this graph must have a previously defined prefix/namespace attached to it. This opens the path to further extend the tool towards a more refined distinction between named graphs and simple graphs. 6
The paper contributes to research related to the implementation of modeling tools that support users in expressing graph-like knowledge conforming the Resource Description Framework. RDF data graphs have a high degree of flexibility in data representation, which can be easily integrated on a metamodeling level to support the creation of enterprise knowledge graphs by visual means. The modeling tool described in this paper can have impact in the Linked Enterprise Data area - however current evaluations did not involve real stakeholders. The tool was only used in a teaching environment and in a testing context. An RDF creation productivity framework is under development to support the compared evaluation of such tools.
The proposed modeling tool showcases the agility enabled by AMME in creating
purposeful tools that do not deploy a traditional modeling language, but rather a di
agrammatic method for producing technology-specific code. This can be included in
the paradigm of Technology-Specific Modeling Languages, a flavor of
DomainSpecific Modeling Languages as introduced in [
In future work, additional mechanisms will be added to allow integration with
ontologies that will also be created with diagrammatic means (see [