Structured Data Markup allows Web developers to embed semantics in HTML pages, thus enabling clients (search engines, client apps etc.) to distil machine-readable resource descriptions from HTML code. This approach emerged from the Semantic Web paradigm as a powerful alternative to traditional Web scraping. Its enablers are dedicated HTML extensions (e.g., RDFa) and controlled vocabularies (e.g., Schema.org). Originating in a different context, Enterprise Modelling methods rely on diagrammatic means for describing and analysing an enterprise system in terms of key properties and conceptual abstractions. Hence, both the Semantic Web and Enterprise Modelling paradigms share a common interest in machine-processable semantics towards the goal of elevating semantics-awareness in information systems and decision support. Inspired by this overlapping, the paper proposes a mechanism for streamlining semantics between Structured Data Markup and enterprise modelling methods. Towards this goal, it employs the Resource Description Framework and the Agile Modelling Method Engineering Framework.
- Structured Data Markup
- Resource Description Framework
- Agile Modelling Method Engineering
Structured Data Markup is being advocated as a search engine optimisation (SEO) technique enabled by semantic technology grafted on traditional Web development practices . The origins of this approach may be traced back to data gleaning from XML documents  and to microformat profiles . More recently, the lessons learned from microformats have led to the centralisation of prominent description vocabularies under the Schema.org “umbrella terminology”  founded and maintained by the big search engine providers (e.g., Google, Yahoo, Microsoft). From a conceptual perspective, Schema.org can be considered an ontology – i.e., it provides a consensus on terms (categories and properties) that should be used to describe often searched types of resources: organisations, persons, events, actions etc. The Schema.org terminology is complemented by syntaxes that can extend HTML content with machine-readable descriptions of arbitrary resources – e.g., RDFa  introduced by the Resource Description Framework (RDF) .
In parallel developments, technologies and practices dealing with semantics have also emerged from the Enterprise Modelling paradigm – originating in data modelling, then evolving in complexity towards system modelling, business process modelling and multi-view enterprise modelling . Although conceptual modelling is commonly perceived as being based on standards, the literature on modelling pragmatics  raised awareness on the need for domain-specificity or situational customisation of modelling methods, languages and tools. This is especially relevant in Enterprise Modelling where enterprise context or multi-perspective consistency concerns [9, 10] may raise requirements on semantic customisation. Methodologies and fast prototyping enablers have emerged to allow knowledge engineers to tailor and deploy modelling methods and languages for narrow domains or situational cases [11, 12]. They rely on metamodels that integrate concepts in graphical language terminologies which are comparable, to some extent, to ontological terminologies such as Schema.org.
This intuitive observation inspired the work at hand, as it proposes a streamlining between conceptual descriptions made available through semantic HTML markup and modelling languages that are synchronised to this markup with the help of the Agile Modelling Method Engineering (AMME) methodology . The Resource Description Framework (RDF)  is employed as a bridging medium.
Therefore, the problem statement of this paper can be outlined as follows: assuming that an organisation publishes machine-readable conceptual descriptions in their Web pages (either for SEO purposes or for arbitrary client agents), how can these be made available to a diagrammatic Enterprise Modelling environment? The proposed solution extends the previously published method of Agile Modelling Method Engineering (AMME) with a mechanism for importing model contents in a modelling environment, from the RDF knowledge graph that can be distilled from Structured Data Markup; the necessity of AMME comes from the need to customize the targeted modelling language in order to align its semantics with those provided by the Structured Data Markup - especially if the markup uses the Schema.org terminology and not one that is under the control of the organisation using the modelling environment.
The remainder of the paper is organised as follows: Sect. 2 will introduce the technological and methodological enablers for the work at hand - Structured Data Markup and the Agile Modelling Method Engineering. Section 3 will present the mechanism through a running example. Section 4 will comment on related works. The paper ends with conclusions and outlook.
2 Technological and Methodological Enablers
2.1 The Structured Data Markup Processing Workflow
Structured Data Markup emerged from the convergence between traditional SEO practices and semantic technology. SEO aims to make the contents of HTML documents “understandable” for search engines. Structured Data Markup allows Web developers to embed machine-readable semantics (i.e., resource descriptions governed by some ontology) directly in the HTML source, with the help of dedicated syntactic formats – e.g., RDFa. This brings drastic changes to SEO practices, as the traditional techniques are replaced with precise ways of describing content meaning. The Structured Data Markup may be “distilled” into RDF graphs – a data model that is amenable to knowledge representation and reasoning. Arbitrary client agents (not limited to search engines) can thus shift from traditional string-based scraping towards powerful semantic queries and reasoning over the distilled knowledge graphs.
Complementary to the mentioned syntactic formats, a centralised, extensible terminology was set up at Schema.org , incorporating concepts and properties that were previously available in scattered and narrow-scoped microformat profiles or RDF vocabularies (e.g., hCard , FOAF , GoodRelations ).
Figure 1 shows an example of Structured Data Markup and the typical knowledge flow from a public HTML document to a client agent (not limited to search engine crawlers).
On the client side, the document content is formatted by a browser for a human visitor (mid-left side of the figure); the same document can also be distilled into a knowledge graph (bottom side). The example in the figure employs RDFa as a Structured Data Markup syntax , Turtle as a graph serialisation syntax  and SPARQL as a graph query language . The meta layer of the graph uses concepts (Action, Role, DigitalDocument) and properties (name, agent, instrument) from the Schema.org ontology. The example also indicates three categories of information that can be embedded in the HTML source: (i) statements that are human-readable but not machine-readable (i.e., the first statement, written in natural language); (ii) statements that are machine-readable but not human-readable in the browser (i.e., that the Master Student role has additional properties at the given URL); (iii) statements that are both machine-readable and human-readable (that the application requires a Master Student to provide a Recommendation Letter and a template is available at the given URL).
The conversion to the “pure” knowledge graph is performed by openly available “distillers” (see ). The additional step proposed by the work at hand is to further deserialise the graph in an agile modelling environment – this step is supported by a metamodelling plug-in (details in Sect. 3). The graph semantics may thus be exposed to an agile Enterprise Modelling method for further analysis or extension. The ideal case is to have models of certain enterprise facets (e.g., work procedures, enterprise resource descriptions) generated out of Web pages where they are already described – e.g., in a Linked Enterprise Data environment . The possibility is currently investigated by the project motivating this work, EnterKnow .
2.2 Agility at Modelling Method Level
Agile Modelling Method Engineering  is a framework and methodology that allows the customisation and alignment of modelling methods (including their associated modelling language and software) with respect to targeted requirements (on language or model-driven functionality). As the name suggests, AMME transfers agile development principles to the practice of modelling method engineering – i.e., an incremental development cycle is applied, based on fast prototyping platforms such as ADOxx  and a metamodelling approach that agilely customises the building blocks of a “modelling method” defined in . For the purposes of the work at hand, the modelling language must be tailored to accept the contents made available through Structured Data Markup so that the typical modelling procedure may be supported with automated model generation for specific types of models. A multitude of Enterprise Modelling methods have been developed in the Open Models Laboratory collaborative environment (OMiLAB) , some of them developed through the AMME methodology (see an inventory of methods in ).
3 Running Example
Figure 2 showcases a custom-made modelling language to be further used as a basis for the running example. The language is tailored to describe “application procedures” – i.e., bureaucratic processes of applying for certain programs or benefits, extended with descriptions of required documents and dependencies on responsible persons.
Several customisations may be noticed, compared to the established business process modelling languages: the language concepts (including “action types”) are hereby aligned with the Schema.org terminology, with some extensions added whenever properties that are necessary in the modelling environment are not available in Schema.org (e.g., the “condition” attribute, the “followedBy” connector). Certain concepts are enriched with user-editable attributes – e.g., the “ChooseAction” provides a table of alternatives – i.e., what kind of documents must be prepared depending on the applicant type. The language is partitioned into three “views” (types of models): (i) the actual procedure, (ii) the required documents and (iii) the responsibilities. Relations are established across these views (e.g., “agent” to indicate responsibility for an action, “contributor” to indicate required input to a document, “instrument” to indicate documents involved in an action, “target” to indicate the URL where a certain action can be performed on-line). The labels of these concepts and relations are abstracted here to be fully aligned with Schema.org, to keep the example easy to follow. In pragmatic cases, one may encounter cases where they must differ to make models easier to read, hence involving an additional mapping effort. Semantics are reflected in notation by dynamically providing hyperlinks. In terms of syntax, the typical graphical depiction of documentation and responsibilities (e.g., swimlanes) is replaced with hyperlinks, allowing each model type to evolve independently.
The transfer of Structured Data Markup to the modelling environment is governed by a schema comprising two layers: (i) the modelling language terminology aligned with the markup vocabulary (Schema.org in the discussed example); (ii) a fixed RDF schema that maps the markup elements to different types of diagrammatic constituents that are allowed in the modelling environment (e.g., swimlanes, visual connectors, hyperlinks etc.). These are used in the HTML (extended with RDFa) fragment displayed in Fig. 3, which is rendered in the browser as a simple bulleted list of procedure steps (the information visible in the browser is bolded).
From the same HTML fragment, RDFa distillers will extract the process description as a machine-readable knowledge graph (Fig. 4). This further becomes the input for the import plug-in prepared for the modelling environment (current implementation is based on ADOxx) to generate model elements. The terms employed in the machine-readable descriptions may be distinguished by their prefices: prefix s: (or no prefix in the HTML fragment) corresponds to Schema.org terms; prefix l: corresponds to terms that are not found in Schema.org but are necessary in the modelling language (e.g., the connectors between actions); prefix d: corresponds to model elements, i.e. those terms that will become diagrammatic constituents (nodes, connectors etc.); prefix o: corresponds to the schema of diagrammatic constituents allowed in ADOxx.
The schema of diagrammatic constituents makes an explicit mapping indicating what kind of constructs are to be generated in the modelling tool (rather than relying on labels which may be ambiguous): “Node Element” is the class of all diagrammatic nodes; a “ComplexConnector” corresponds to any connector that has attributes attached to it; Hyperlink properties allow navigation between elements in different models; “NonVisualEntity” is any resource that is not present on the modelling canvas (has no graphical symbol attached), but is editable as table structure annotation attached to model elements. A taxonomy of such constituents is the outcome of analysing the extensive corpus of modelling languages presented in a first volume authored by the OMiLAB global community  and is currently being developed towards an ontology of diagrammatic constituents – its origin is in the schema introduced in .
4 Discussion on Related Works
Conceptual redundancy often manifests between the data models driving run-time information systems and the conceptualisations governing design-time tools (e.g., modelling tools). The bridging of these two facets traditionally takes the form of model-driven code generation or of process-aware information systems  taking semantic input from some process representation. The proposal of this paper reverses the typical “flow of semantics” by enabling the retrieval of machine-readable semantics from a run-time system (i.e., a running Web page) to a modelling environment tailored through AMME to accommodate the imported knowledge graphs. The reverse flow of RDF graphs, from modelling tools to Linked Data-driven applications was previously discussed in other works . Complementing those works, this paper completes a two-way interoperability channel for modelling environments, a feature traditionally limited to XML-based interoperability.
The proposal may also be positioned as a knowledge conversion step, as it bridges machine-oriented and human-oriented knowledge representations, thus complementing efforts such as knowledge extraction from HTML  and potentially supporting knowledge transfer systems . The paper also invites discussion on the semantics of instantiation, previously analysed by  - the resources mentioned in HTML documents are dually instantiated in relation to their diagrammatic manifestation and a metamodel. The interplay of Semantic Web and Enterprise Modelling has traditionally focused on the consistency of modelling languages, i.e., their ontological commitment , or on the ability to infer relations on certain enterprise model types . Our work pursues a descriptive purpose rather than a prescriptive one, by advocating a more flexible and agile notion of “modelling languages”, with models taking input from machine-readable descriptions that are currently spreading across the Web to fulfil the global knowledge graph ambition of the Semantic Web.
The paper advocates a streamlining of semantics between the Semantic Web and Enterprise Modelling paradigms. The proposal is supported by a description of technological and methodological enablers - RDF for interoperability and AMME for tailoring a modelling language to targeted semantic requirements. The streamlining proposal presented in the paper is being investigated in the EnterKnow  project on more realistic use cases than the showcase modelling language presented here.
Schema.org is frequently enriched and it may take valuable input from the use cases served by the work at hand (e.g., currently the Action concepts in Schema.org are lacking properties required to express action flows). Enterprise Modelling use cases may inspire the addition of concepts for describing enterprise assets.
In terms of limitations, the current implementation is not fully optimised, as it requires manual manipulation to prepare the import – i.e., to add position coordinates for the graphical layout of models (such information cannot be expected to be available in the general case for Structured Data Markup); since named graphs are not supported by the current specification of RDFa, conventions are necessary (e.g., one graph per HTML page). Finally, technical evaluations are still necessary to assess the usability and speed of model generation compared to manual creation of comparable models.
Google Structured Data (2017). https://developers.google.com/search/docs/guides/intro-structured-data
W3C: Gleaning Resource Descriptions from Dialects of Languages (GRDDL) (2007). https://www.w3.org/TR/grddl/
Microformats.org (2017). http://microformats.org/wiki/about
Schema.org – official website (2011). http://schema.org/
W3C: Rich Structured Data Markup for Web Documents (2015). https://www.w3.org/TR/rdfa-primer/
W3C. RDF 1.1 – official website (2014). https://www.w3.org/TR/rdf11-concepts/
Frank, U.: Multi-perspective enterprise modeling (MEMO) – conceptual framework and modeling languages, In: Sprague Jr., R.H. (ed.) Proceedings of the 35th Hawaii International Conference on System Sciences, pp 1258–1267. IEEE (2002)
Bjeković, M., Proper, H.A., Sottet, J.-S.: Embracing pragmatics. In: Yu, E., Dobbie, G., Jarke, M., Purao, S. (eds.) ER 2014. LNCS, vol. 8824, pp. 431–444. Springer, Cham (2014). doi:10.1007/978-3-319-12206-9_37
Jeusfeld, M.A.: SemCheck: checking constraints for multi-perspective modeling languages. In: Karagiannis, D., Mayr, H., Mylopoulos, J. (eds.) Domain-Specific Conceptual Modeling, pp. 31–53. Springer, Cham (2016). doi:10.1007/978-3-319-39417-6_2
Karagiannis, D., Buchmann, R.A., Bork, D.: Managing consistency in multi-view enterprise models: an approach based on semantic queries. In: Proceedings of ECIS 2016, Association for Information Systems, p. 53 (2016)
Karagiannis, D.: Agile modelling method engineering. In: Karanikolas, N., Akoumianakis, D., Mara, N., Vergados, D., Michalis, X. (eds.) Proceedings of the 19th Panhellenic Conference on Informatics, pp. 5–10. ACM (2015)
Frank, U.: Domain-specific modelling languages: requirements analysis and design guidelines. In: Reinhartz-Berger, I., Sturm, A., Clark, T., Cohen, S., Betin, J. (eds.) Domain Engineering, pp. 133–157. Springer, Heidelberg (2013). doi:10.1007/978-3-642-36654-3_6
Microformats.org: H-Card (2017). http://microformats.org/wiki/h-card
Brickley, D., Miller, L.: FOAF Vocabulary Specification 0.99 (2014). http://xmlns.com/foaf/spec/
Hepp, M.: GoodRelations: an ontology for describing products and services offers on the web. In: Gangemi, A., Euzenat, J. (eds.) EKAW 2008. LNCS, vol. 5268, pp. 329–346. Springer, Heidelberg (2008). doi:10.1007/978-3-540-87696-0_29. http://www.heppnetz.de/projects/goodrelations/
W3C: Terse RDF Triple Language (2014). https://www.w3.org/TR/turtle/
W3C: SPARQL 1.1 Query Language (2013). https://www.w3.org/TR/sparql11-query/
W3C: RDFa 1.1 Distiller (2013). https://www.w3.org/2012/pyRdfa/Overview.html
Wood, D. (ed.): Linking Enterprise Data. Springer Science & Business Media, Heidelberg (2010)
EnterKnow project (2017). http://enterknow.granturi.ubbcluj.ro/
BOC-Group: ADOxx tool (2017). https://www.adoxx.org/live/home
Karagiannis, D., Kühn, H.: Metamodelling platforms. In: Bauknecht, K., Tjoa, A.M., Quirchmayr, G. (eds.) EC-Web 2002. LNCS, vol. 2455, p. 182. Springer, Heidelberg (2002). doi:10.1007/3-540-45705-4_19
The Open Models Initiative Laboratory (2017). http://www.omilab.org/psm/home
Karagiannis, D., Mayr, H.C., Mylopoulos, J. (eds.): Domain-Specific Conceptual Modelling. Springer, Heidelberg (2016)
Karagiannis, D., Buchmann, R.A.: Linked open models: extending linked open data with conceptual model information. Inf. Syst. 56, 174–197 (2016)
Dumas, M., van der Aalst, W.M.P., ter Hofstede, A.H.M. (eds.): Process-Aware Information Systems: Bridging People and Software through Process Technology. Wiley-Interscience, New York (2005)
Buchmann, R.A., Karagiannis, D.: Domain-specific diagrammatic modelling: a source of machine-readable semantics for the Internet of Things. Cluster Comput. 20(1), 895–908 (2017)
Wu, X., Cao, C., Wang, Ya., Fu, J., Wang, S.: Extracting knowledge from web tables based on DOM tree similarity. In: Lehner, F., Fteimi, N. (eds.) KSEM 2016. LNCS, vol. 9983, pp. 302–313. Springer, Cham (2016). doi:10.1007/978-3-319-47650-6_24
Marumo, N., Beppu, T., Yamaguchi, T.: A knowledge-transfer system integrating workflow, a rule base, domain ontologies and a goal tree. In: Buchmann, R., Kifor, C.V., Yu, J. (eds.) KSEM 2014. LNCS, vol. 8793, pp. 357–367. Springer, Cham (2014). doi:10.1007/978-3-319-12096-6_32
Laarman, A., Kurtev, I.: Ontological metamodeling with explicit instantiation. In: van den Brand, M., Gašević, D., Gray, J. (eds.) SLE 2009. LNCS, vol. 5969, pp. 174–183. Springer, Heidelberg (2010). doi:10.1007/978-3-642-12107-4_14
Guizzardi, G.: Ontological foundations for structural conceptual models. CTIT, Centre for Telematics and Information Technology, Ph.D. thesis Series, No. 05-74 (2005)
Lantow, B., Sandkuhl, K., Fellmann, M.: Visual language and ontology based analysis: using OWL for relation discovery and query in 4EM. In: Abramowicz, W., Alt, R., Franczyk, B. (eds.) BIS 2016. LNBIP, vol. 263, pp. 23–35. Springer, Cham (2017). doi:10.1007/978-3-319-52464-1_3
This work is supported by the Romanian National Research Authority through UEFISCDI, under grant agreement PN-III-P2-2.1-PED-2016-1140.
Editors and Affiliations
Rights and permissions
© 2017 IFIP International Federation for Information Processing
About this paper
Cite this paper
Ghiran, AM., Buchmann, R.A., Osman, CC., Karagiannis, D. (2017). Streamlining Structured Data Markup and Agile Modelling Methods. In: Poels, G., Gailly, F., Serral Asensio, E., Snoeck, M. (eds) The Practice of Enterprise Modeling. PoEM 2017. Lecture Notes in Business Information Processing, vol 305. Springer, Cham. https://doi.org/10.1007/978-3-319-70241-4_22
Publisher Name: Springer, Cham
Print ISBN: 978-3-319-70240-7
Online ISBN: 978-3-319-70241-4
eBook Packages: Computer ScienceComputer Science (R0)