doc. Ing. Robert Pergl, Ph.D.

Article

10.1007/s10844-022-00706-8

Department of Software Engineering

Functional requirements on a software system are traditionally captured as text that describes the expected functionality in the domain of a real-world system. Natural language processing methods allow us to extract the knowledge from such requirements and transform it, e.g., into a model. Moreover, these methods can improve the quality of the requirements, which usually suffer from ambiguity, incompleteness, and inconsistency. This paper presents a novel approach to using natural language processing. We use the method of grammatical inspection to find specific patterns in the description of functional requirement specifications (written in English). Then, we transform the requirements into a model of Normalized Systems elements. This may realize a possible component of the eagerly awaited text-to-software pipeline. The input of this method is represented by textual requirements. Its output is a running prototype of an information system created using Normalized Systems (NS) techniques. Therefore, the system is ready to accept further enhancements, e.g., custom code fragments, in an evolvable manner ensured by compliance with the NS principles. A demonstration of pipeline implementation is also included in this paper. The text processing part of our pipeline extends the existing pipeline implemented in our system TEMOS, where we propose and implement methods of checking the quality of textual requirements concerning ambiguity, incompleteness, and inconsistency.

Proceedings paper

10.1007/978-3-031-04819-7_14

Department of Software Engineering

During the last decade, there was a huge shift in the problem of evolvability. However, still, the problem remains fully unresolved. Our focus is to improve evolvability in the domain of data stewardship planning. The main problem causing the low evolvability is the use of traditional documents – data management plans. Our approach redesigns the workflow of creating the data management plan with a possibility to extend an application to similar well-structured documents in different domains. We base our approach on principles and recommendations from the Normalized Systems Theory and on the usage of ontologies. The result is a new workflow that should increase the evolvability compared to the current state.

Proceedings paper

10.3233/FAIA220290

Department of Software Engineering

Normalized Systems are a model-driven development technique focusing on evolvability and sustainability of resulting enterprise information systems. It applies well-defined principles to create a fine-grained modular structure while limiting combinatorial effects. The systems are generated (or, more precisely, expanded) from models of so-called NS Elements. NS has its own modelling language; however, interoperability with other knowledge representations is necessary. This work presents our solution for transforming knowledge kept in one of the most generic forms – RDF semantic triples – to NS Elements. The transformation enables mapping using RDFS/OWL ontologies describing both the input RDF. It utilizes SPARQL for executing the transformation to RDF based on the existing NS Element ontology. The presented transformation is demonstrated on an example case study, and its features and limitations are discussed together with potential future steps.

Proceedings paper

10.1007/978-3-031-04829-6_31

Department of Software Engineering

Normalised System Theory provides a theoretical foundation on how to build software with respect to change over time. An advanced development platform has been built by the NSX company to build Normalised Systems in practice, from modelling tools to implementation. However, there is a lack of support for modelling user interfaces in the platform, so any non-default requirements require manual customisations, which can introduce combinatorial effects and thus harm evolvability. Nevertheless, the research and development of modelling languages for user interfaces has been a continuous effort since the software started using user interfaces. So in this study, we aim to find recent existing UI modelling languages, define the criteria of suitability for modelling UI of Normalised Systems and evaluate them. The results can be used for implementing UI modelling for Normalised Systems.

Proceedings paper

10.3233/FAIA210018

Department of Software Engineering

Normalized Systems (NS) theory describes how to design and develop evolvable systems. It is applied in practice to generate enterprise information systems using NS Expanders from models of NS Elements. As there are various wellestablished modelling languages, the possibility to (re-)use them to create NS applications is desired. This paper presents a mapping between the NS metamodel and the Ecore metamodel as a representant of essential structural modelling. The mapping is the basis of the transformation execution tool based on Eclipse Modeling Framework and NS Java libraries. Both the mapping and the tool are demonstrated in a concise case study but cover all essential Ecore constructs. During the work, several interesting similarities of the two metamodels were found and are described, e.g., its meta-circularity or ability to specify data types using references to Java classes. Still, there are significant differences between the metamodels that prevent some constructs from being mapped. The issues with information loss upon the transformation are mitigated by incorporating additional options that serve as key-value annotations. The results are ready to be used for any Ecore models to create an NS model that can be expanded into an NS application.

Proceedings paper

Department of Software Engineering

RDF data are being described by ontologies (OWL or RDFS) to state the meaning and promote interoperability or so-called machine-readability. However, there are many overlapping ontologies that one can use for a single dataset. To overcome this issue, mappings between ontologies are made to capture the relations forming the overlaps. Such mappings can be used with inference and reasoning tools, but rewriting rules must be applied to transform the dataset. This work proposes a new way of transformations builds on top of the SPARQL query language. It uses defined RDF patterns representing modules that can be interrelated. Our method's primary focus is for larger-scale transformations where existing methods require hard-to-maintain, i.e., non-evolvable mapping definitions. A brief demonstration, as well as a comparison with other transformation languages, is provided.

Proceedings paper

10.5220/0010229000650075

Department of Software Engineering

Blockchain aims to be a disruptive technology in many aspects of our lives. It attempts to disrupt the aspect of our lives that were hard to digitize, such as democratic elections or were digitized in a centralized way, such as the financial system or social media. Despite the initial success of blockchain platforms, many hacks, design errors, and a lack of standards was encountered. This paper aims to provide a methodical approach to the design of the blockchain-based systems and help to eliminate these issues. The approach is then demonstrated in an EU parliament elections case study.

Proceedings paper

10.5220/0010653900003064

Department of Software Engineering

Business Object Relationship Modeling (BORM) is a business process analysis method based on communicating finite-state machines and Petri nets. However, because of its tooling support and non-interoperability of formats, it is rather niche. This work proposes a way of representing the knowledge from BORM process models in RDF by creating a BORM ontology. It benefits from previous work done on different conceptual and process modelling languages and their transformations to OWL. The resulting RDF representation brings increased interoperability and enhanced analysis possibilities, e.g., using SPARQL or RDF visualization tools. A part of this work is also a BORM-to-RDF export feature for the OpenPonk modelling platform. The resulting BORM ontology is ready for use in practice and further work.

Invited/Awarded proceedings paper

10.1007/978-3-030-70006-5_9

Department of Software Engineering

Normalized Systems (NS) enables sustainable software development and maintenance using code generation of evolvable information systems from models of so-called NS Elements. To promote semantic interoperability with other conceptual models, RDF and OWL technologies can be used for knowledge representation in NS as it is common within the Semantic Web and Linked Open Data domains. Previous research resulted in initial NS-OWL bi-directional transformation and a prototype tool for its execution. In this extended paper, these efforts are further elaborated into an evolvable solution based on NS Expanders. The transformation utilizes RDF to encode all domain-specific structural knowledge of an NS model to ensure bi-directionality. In addition, it also maps entities of NS metamodel to OWL concepts to serve as an ontology for underlying data. Because of the metacircular NS metamodel, any NS model including the metamodel itself, can be transformed. Moreover, the transformation of application data to or from RDF is also possible. Having the NS metamodel, NS models, and potentially also data in RDF opens further research possibilities in terms of analysis and integrations. The use of NS Expanders caused that the solution can be easily extended and refined, e.g. when the metamodel is updated. The results of our research are expected to help with the design of real-world information systems, including the NS tooling and the metamodel.

Proceedings paper

10.5220/0009356800740085

Department of Software Engineering

Knowledge representation in OWL ontologies gained a lot of popularity with the development of Big Data, Artificial Intelligence, Semantic Web, and Linked Open Data. OWL ontologies are very versatile, and there are many tools for analysis, design, documentation, and mapping. They can capture concepts and categories, their properties and relations. Normalized Systems (NS) provide a way of code generation from a model of so-called NS Elements resulting in an information system with proven evolvability. The model used in NS contains domain-specific knowledge that can be represented in an OWL ontology. This work clarifies the potential advantages of having OWL representation of the NS model, discusses the design of a bi-directional transformation between NS models and domain ontologies in OWL, and describes its implementation. It shows how the resulting ontology enables further work on the analytical level and leverages the system design. Moreover, due to the fact that NS metamodel is metacircular, the transformation can generate ontology of NS metamodel itself. It is expected that the results of this work will help with the design of larger real-world applications as well as the metamodel and that the transformation tool will be further extended with additional features which we proposed.

Proceedings paper

10.1109/CBI49978.2020.00036

Department of Software Engineering

Building ontologies in The Web Ontology Language (OWL) as a knowledge representation about a particular domain gained a lot of interest over the recent years. Thanks to its large community and many options concerning tooling and methods for representation and transformations, OWL is being used not only in Linked Open Data and Artificial Intelligence but also in conceptual modelling. OWL allows capturing concepts and their properties, including relationships which can also be done using traditional conceptual models, for example, in Unified Modelling Language (UML). Both UML and OWL have their own specifics when compared to each other, and one may be more suitable than the other in concrete cases. There are several methods for transformation between knowledge representation in OWL and UML. In this paper, we review key methods for transforming UML to OWL and vice versa. To compare the methods, we use a non-trivial conceptual model that contains all commonly used constructs, e.g., generalization sets, composition, or relationships with constraints. The methods are evaluated in terms of information loss during transformation, the need for human intervention, and versatility.

Proceedings paper

10.1007/978-3-030-37933-9_10

Department of Software Engineering

A Blockchain (BC) is a technology that introduces a decentralized, replicated, autonomous, and secure databases. A smart contract (SC) is a transaction embedded in the blockchain that contains executable code and its internal storage, offering immutable execution and record keeping. The SC has enormous potential in automating traditional paper contracts and encoding contract logic into program code. Thus, replacing the role of a notary and a central authority. It may dramatically reduce an effort with administration workload and enforcement of such contracts. In this paper, we propose a new visual domain specific language that can capture the SC in a user-friendly way and eliminate the errors associated with programming since the SC code is automatically generated from models. Finally, an open-source proof-of-concept environment for designing and generating the SC is introduced to demonstrate the feasibility of proposed concepts.

Proceedings paper

Department of Software Engineering

Inheritance as a relation for expressing generalisations and specialisations or taxonomies is natural for conceptual modelling, but causes evolvability problems in software implementations. Each inheritance relation represents a tight coupling between a superclass and a subclass. Coupling in this case leads to a combinatorial effect or even combinatorial explosion in case of complex hierarchies. This paper analyses how multiple inheritance and method resolution order affect these problems in the Python programming language. The analysis is based on the design of inheritance implementation patterns from our previous work. Thanks to the flexibility of Python, it shows that inheritance can be implemented with minimisation of combinatorial effect using the patterns. Nevertheless, it is crucial to generate helper constructs related to the patterns from the model automatically for the sake of evolvability, including potential future in the patterns themselves.

Article

10.1162/dint_a_00037

Department of Software Engineering

Thousands of community-developed (meta)data guidelines, models, ontologies, schemas and formats have been created and implemented by several thousand data repositories and knowledge-bases, across all disciplines. These resources are necessary to meet government, funder and publisher expectations of greater transparency and access to and preservation of data related to research publications. This obligates researchers to ensure their data is FAIR, share their data using the appropriate standards, store their data in sustainable and community-adopted repositories, and to conform to funder and publisher data policies. FAIR data sharing also plays a key role in enabling researchers to evaluate, re-analyse and reproduce each other's work. We can map the landscape of relationships between community-adopted standards and repositories, and the journal publisher and funder data policies that recommend their use. In this paper, we show how the work of the GO-FAIR FAIR Standards, Repositories and Policies (StRePo) Implementation Network serves as a central integration and cross-fertilisation point for the reuse of FAIR standards, repositories and data policies in general. Pivotal to this effort, the FAIRsharing, an endorsed flagship resource of the Research Data Alliance that maps the landscape of relationships between community-adopted standards and repositories, and the journal publisher and funder data policies that recommend their use. Lastly, we highlight a number of activities around FAIR tools, services and educational efforts to raise awareness and encourage participation.

Proceedings paper

10.1007/978-3-030-45688-7_76

Department of Software Engineering

There is a growing need for more client applications for different platforms while maintaining a consistent appearance. Managing this usually requires a lot of tedious labour work. In this paper, we explored what should be included in the design system based on the real-world needs, how to represent and formalise it using semantic web technologies to achieve evolvability and interoperability, and how to convert it into code automatically leveraging the Normalised System theory. Our solution is already a foundation for the ontology representing the design system and working prototype of the code generator using the ontology.

Proceedings paper

10.1007/978-3-030-45688-7_5

Department of Software Engineering

A problem of evolvability is widely discussed in the current world, and still, it has not been fully addressed yet. Our approach tries to improve evolvability in a domain of documents. Our approach is based on principles and recommendations from the Normalized Systems Theory. We try to redefine the process of how the document is created and maintained by involving ontologies. We offer a solution which should increase evolvability for a sort of documents which is created by a template and which is often updated. We demonstrate our solution to an example of a Data Management Plan document.

Proceedings paper

10.1007/978-3-030-65847-2_13

Department of Software Engineering

Powerful incentives are driving the adoption of FAIR practices among a broad cross-section of stakeholders. This adoption process must factor in numerous considerations regarding the use of both domain-specific and infrastructural resources. These considerations must be made for each of the FAIR Guiding Principles and include supra-domain objectives such as the maximum reuse of existing resources (i.e., minimised reinvention of the wheel) or maximum interoperation with existing FAIR data and services. Despite the complexity of this task, it is likely that the majority of the decisions will be repeated across communities and that communities can expedite their own FAIR adoption process by judiciously reusing the implementation choices already made by others. To leverage these redundancies and accelerate convergence onto widespread reuse of FAIR implementations, we have developed the concept of FAIR Implementation Profile (FIP) that captures the comprehensive set of implementation choicesmade at the discretion of individual communities of practice. The collection of community-specific FIPs compose an online resource called the FIP Convergence Matrix which can be used to track the evolving landscape of FAIR implementations and inform optimisation around reuse and interoperation. Ready-made and well-tested FIPs created by trusted communities will find widespread reuse among other communities and could vastly accelerate decision making on well-informed implementations of the FAIR Principles within and particularly between domains.

Proceedings paper

Department of Software Engineering

Public blockchains are increasingly important in industries such as finance, supply-chain management, and governance. In the last two years, there has been increased usage of blockchain for decentralized finance (DeFi). The usage of DeFi mainly consists of cryptocurrency lending and providing liquidity for decentralized exchanges. However, the considerable volume of reports shows large financial losses during network congestion, increasing transaction prices, programming errors, and hacker attacks. One survey suggested that only 40\% of people working with DeFi smart contracts understand their source code. To address the issues, this paper proposes a model-driven approach to create blockchain smart contracts based on a visual domain-specific language called DasContract. An improved design of the DasContract language is presented, and a code generation process into a blockchain smart contract is described. The proposed approach is demonstrated on a proof-of-concept model of a decentralized mortgage process where the contract is designed, generated, and simulated in a blockchain environment.

Proceedings paper

Department of Software Engineering

The pace of technology change has accelerated in the past decade. Conceptually similar technologies are introduced on nearly a daily basis. On one hand, IT experts call for applying the most modern approaches and technologies to software projects, on the other, companies suffer from liabilities to a technology used in their legacy solutions. This seems to result in a disturbing situation when a specific technology of an ongoing software project becomes legacy almost before the project successfully hits a production. This poses a continual challenge for software development, and effective ways of technology transition are sought. Affordance-Driven Assembling (ADA) represents such an effort from the standpoint of enterprise engineering theories. In this paper, we formulate a high-level architecture of a software system based on ADA. We demonstrate the architecture on an example of an object-oriented system. We evaluate the qualities of such architecture from the perspective of evolvability using Normalized Systems Theory, and we formulate conclusions on potential of this approach.

Article

10.1016/j.is.2018.11.009

Department of Software Engineering

This paper conducts an empirical study that explores the differences between adopting a traditional conceptual modeling (TCM) technique and an ontology-driven conceptual modeling (ODCM) technique with the objective to understand and identify in which modeling situations an ODCM technique can prove beneficial compared to a TCM technique. More specifically, we asked ourselves if there exist any meaningful differences in the resulting conceptual model and the effort spent to create such model between novice modelers trained in an ontology-driven conceptual modeling technique and novice modelers trained in a traditional conceptual modeling technique. To answer this question, we discuss previous empirical research efforts and distill these efforts into two hypotheses. Next, these hypotheses are tested in a rigorously developed experiment, where a total of 100 students from two different Universities participated. The findings of our empirical study confirm that there do exist meaningful differences between adopting the two techniques. We observed that novice modelers applying the ODCM technique arrived at higher quality models compared to novice modelers applying the TCM technique. More specifically, the results of the empirical study demonstrated that it is advantageous to apply an ODCM technique over an TCM when having to model the more challenging and advanced facets of a certain domain or scenario. Moreover, we also did not find any significant difference in effort between applying these two techniques. Finally, we specified our results in three findings that aim to clarify the obtained results.

Article

10.1162/dint_a_00043

Department of Software Engineering

Effective stewardship of data is a critical precursor to making data FAIR. The goal of this paper is to bring an overview of current state of the art of data management and data stewardship planning solutions (DMP). We begin by arguing why data management is an important vehicle supporting adoption and implementation of the FAIR principles, we describe the background, context and historical development, as well as major driving forces, being research initiatives and funders. Then we provide an overview of the current leading DMP tools in the form of a table presenting the key characteristics. Next, we elaborate on emerging common standards for DMPs, especially the topic of machine-actionable DMPs. As sound DMP is not only a precursor of FAIR data stewardship, but also an integral part of it, we discuss its positioning in the emerging FAIR tools ecosystem. Capacity building and training activities are an important ingredient in the whole effort. Although

Proceedings paper

Department of Software Engineering

Inheritance is a well-known construct in conceptual modelling, as well as in the object-oriented programming, where it is often used to enable reusability and to modularize complex applications. While it helps in conceptual modelling and understanding of complex domains, it usually results in evolvability issues in software implementations. This paper discusses problems caused by single and multiple inheritance with respect to increasing accidental complexity of a model and evaluates various patterns that can be used to transform conceptual-level inheritance into implementation with respect to code evolvability. The points are illustrated on the transformation of an example ontological conceptual model in OntoUML into various software implementation models.

Article

10.1162/dint_a_00038

Department of Software Engineering

The FAIR Principles articulate the behaviors expected from digital artifacts that are Findable, Accessible, Interoperable and Reusable by machines and by people. Although by now widely accepted, the FAIR Principles by design do not explicitly consider actual implementation choices enabling FAIR behaviors. As different communities have their own, often well-established implementation preferences and priorities for data reuse, coordinating a broadly accepted, widely used FAIR implementation approach remains a global challenge. In an effort to accelerate broad community convergence on FAIR implementation options, the GO FAIR community has launched the development of the FAIR Convergence Matrix. The Matrix is a platform that compiles for any community of practice, an inventory of their self-declared FAIR implementation choices and challenges. The Convergence Matrix is itself a FAIR resource, openly available, and encourages voluntary participation by any self-identified community of practice (not only the GO FAIR Implementation Networks). Based on patterns of use and reuse of existing resources, the Convergence Matrix supports the transparent derivation of strategies that optimally coordinate convergence on standards and technologies in the emerging Internet of FAIR Data and Services.

Proceedings paper

10.1007/978-3-030-35646-0_7

Department of Software Engineering

Process modelling is the key part of a problem domain analysis, and there are multiple modelling languages for that purpose. In this paper, we present the mapping of three of such languages – namely BPMN, BORM, and UML Activity Diagram – with Unified Foundational Ontology UFO, more specifically its part describing behavioural aspects called UFO-B. Due to the mapping, we were able to find out interesting similarities and options when working with the selected languages and we also compare them in terms of expressiveness with respect to UFO. The specific properties of each languages became even more highlighted and explained, so this comparison can be used for a decision which language to use in a particular case. Our contribution can be used for future work in models integrations and transformations.

Invited/Awarded proceedings paper

Department of Software Engineering

In this keynote, I discuss two pillars of intellectual human endeavour: naming and hierarchies. I dig into the essence of these corner-stones of conceptualisation and explore their presence, significance and forms in various disciplines. Challenges of naming and hierarchies in engineering disciplines are discussed and lessons learned are formulated.

Article

10.5334/dsj-2019-059

Department of Software Engineering

The Data Stewardship Wizard is a tool for data management planning that is focused on getting the most value out of data management planning for the project itself rather than on fulfilling obligations. It is based on FAIR Data Stewardship, in which each data-related decision in a project acts to optimize the Findability, Accessibility, Interoperability and/or Reusability of the data. The background to this philosophy is that the first reuser of the data is the researcher themselves. The tool encourages the consulting of expertise and experts, can help researchers avoid risks they did not know they would encounter by confronting them with practical experience from others, and can help them discover helpful technologies they did not know existed. In this paper, we discuss the context and motivation for the tool, we explain its architecture and we present key functions, such as the knowledge model evolvability and migrations, assembling data management plans, metrics and evaluation of data management plans.

Proceedings paper

10.1007/978-3-030-06097-8_3

Department of Software Engineering

Nowadays, the pace of technology innovation and disruption accelerates. This poses a challenge of transforming complex functionalities of enterprise systems to a new technological environment. In this paper, we explain how enterprise engineering tau-theory and beta-theory may help to manage the relationship between system function and its construction (F/C), thus facilitating changing technology challenges more rigorously and efficiently. We introduce the notion of Affordance-Driven Assembling (ADA) and its simplified version Objectified Affordance-Driven Assembling (O-ADA), which together with the so-called Semantic Descriptions represent a software-engineering approach enabling reasoning about users and their purposes versus components and their properties. Our experiments show that engineering methods based on these theories may increase reusability of code

Proceedings paper

Department of Software Engineering

Every year, the amount of data (in science) grows significantly as information technologies are used more intensively in various domains of human activities. Biologists, chemists, linguists, and others are not data experts but often just regular users who need to capture and process some huge amount of data. This is where serious problems emerge – bad data management leading to losing important data, producing unverifiable results, wasting funds, and so on. Thousands of qualified data stewards will be needed in following years to deal with this issues. At the Faculty of Information Technology, CTU in Prague, we participate in the European platform ELIXIR in which we work on the Data Stewardship Wizard to help researchers and data stewards with building high-quality FAIR data management plans that are accurate and helpful to their projects. We cooperate on this challenging project with our colleagues from other ELIXIR nodes.

Proceedings paper

10.1007/978-3-030-00847-5_5

Department of Software Engineering

This paper conducts an empirical study that explores the differences between adopting a traditional conceptual modeling (TCM) technique and an ontology-driven conceptual modeling (ODCM) technique with the objective to understand how these techniques influence the consistency between the resulting conceptual models. To determine these differences, we first briefly discuss previous research efforts and compose our hypothesis. Next, this hypothesis is tested in a rigorously developed experiment, where a total of 100 students from two different Universities participated. The findings of our empirical study confirm that there do exist meaningful differences between adopting the two techniques. We observed that novice modelers applying the ODCM technique arrived at higher consistent models compared to novice modelers applying the TCM technique. More specifically, our results indicate that the adoption of an ontological way of thinking facilitates modelers in constructing higher consistent models.

Proceedings paper

Department of Software Engineering

We may say that documents are one of the cornerstones of our civilization. Information technologies enabled unparalleled flexibility and power for retrieving, storing, and sharing documents. However, in a daily documents-intensive job, one needs to deal with severe complications of documents evolvability and reusability of their parts. Maintaining consistency across several documents and their versions is typically a tedious and error-prone task. Similar evolvability challenges have been dealt with in software engineering and principles such as modularity, loose coupling, and separation of concerns have been studied and applied. There is a hypothesis that they may help in the domain of evolvable documents, as well. We perceive devising a conceptualization of documents as the first step in this endeavor. In this paper, we present a generic conceptualization leading to evolvable documents applicable in any documentation domain, and we propose next steps.

Proceedings paper

10.1007/978-3-030-06097-8_7

Department of Software Engineering

Blockchain (BC) is a technology that introduces a decentralized, replicated, autonomous and secure databases. Smart contract (SC) is a transaction embedded to blockchain that contains executable code and its own internal storage, offering immutable execution and record keeping. Enterprise Engineering (EE) examines all aspects of organizations from business processes, informational and technical resources, to organizational structure. Therefore, blockchain and smart contracts have been subject of interest concerning the discipline of Enterprise Engineering (EE) and how they can be used together.

Article

Department of Software Engineering

Documents surround us in our everyday lives and affect us even without noticing it. Information technology brought an evolution to documents in terms of flexibility and efficiency in their composing, processing, and sharing. However, in these days, an electronic document lacks the evolvability and reusability of its parts. Maintaining the consistency across one or even several documents and their versions makes it a very complicated task. We encounter a similar problem in the software development domain where, however, effective principles and techniques have been developed and adopted. Incorporating modularity, design patterns, loose coupling, separation of concerns, and other principles are being successfully applied to achieve evolvability. Results are proven in decades by scientific research and countless practical applications. Hypothetically, such principles may be used also for documents in order to achieve reliable and easy-to-maintain documents. This paper presents our generic conceptualization leading to evolvable documents and which is applicable in any documentation domain based on related work in the electronic documents, as well as the evolvable software development domains. Advantages and core ideas of our conceptualization are then demonstrated in a case study - prototype design of OntoUML modelling language documentation. Finally, possible next steps for generic evolvable documents are proposed, as we perceive our contribution as the first step in the journey towards evolvable documents in the scientific point of view. The results from this paper can be used for further research and as the first boilerplate for designing custom evolvable documentation.

Proceedings paper

10.1007/978-3-030-00787-4_3

Department of Software Engineering

Model-driven development approach to software engineering requires precise models defining as much of the system as possible. OntoUML is a conceptual modelling language based on UFO, which provides constructs to create ontologically well-founded and precise conceptual models. In the approach we utilize, OntoUML is used for making conceptual models of software application data. Such a model is then transformed into its proper realization in a relational database, preserving all the implicit constraints defined by various types of universals and relations in the original OntoUML model. In this paper, we discuss possible optimizations of the transformation of Kinds and Subkinds – rigid sortal universal types, a backbone of OntoUML models.

Proceedings paper

10.1007/978-3-319-57955-9_2

Department of Software Engineering

The discipline of enterprise engineering and the DEMO methodology provide enterprise designers with a formal techniques to design companies where competency, responsibility and authority is clearly defined. In such companies, process-based anomalies can be avoided and people tend to cooperate more effectively and contentedly. These techniques are so far mostly used just for business process modeling consultancy. DEMO-based software systems are needed to adopt and support these techniques in professional companies. This paper proposes a theoretical computation concept called DEMO Machine that provides us with formal foundations for a simulation of DEMO models. We demonstrate these formal foundations on a Volley Club example.

Proceedings paper

10.1145/3139903.3139912

Department of Software Engineering

This paper describes an original method and a tool for an a posteriori analysis of a running object software system, specifically system's runtime structural properties. Highly context-dependent systems pose a challenge of understanding their runtime behaviour. The typical approach is to let the system run and manually observe its runtime properties, which is cognitively demanding and error-prone. Smalltalk, and Pharo in particular, focuses on providing live introspection and immediate feedback during the development. In our method, we take the advantage of these possibilities and combine them with the (relatively new) concept of metalinks as a way to hook into existing code without modifying it, and to set specific attributes to be observed. The result is an analysis tool focused on visualization of ad-hoc runtime structures -- that is, providing an analyst with a live view of the stepwise construction and runtime changes of a system based on a UML instance visualization. We demonstrate the tool on analyzing the construction loop of Pharo's Spec UI framework.

Proceedings paper

10.1007/978-3-319-56535-4_86

Department of Software Engineering

Hundreds of programming languages are available today and new ones are still emerging. Nevertheless, they are founded in several (old) paradigms. Knowing the essence of paradigms helps to orient one- self in this Babylon, which is challenging especially for the growing com- munity of programmers with no computer science background. In this paper we focus on functional paradigm, which has a raising attention both in new languages (like Clojure and ClojureScript) and a growing support in traditional languages (like C++ and Java). We do not discuss why this happens here, but we focus on analysing fundamental concepts in the functional paradigm and functional programming languages. We describe them and divide them into two categories: key principles and additional principles. Next, we apply this conceptual framework to anal- yse the ES5 and ES6 versions of JavaScript. We conclude that ES6 is a good step towards functional principles support. Also, the presented con- ceptual framework may be used for similar analyses of other languages.

Proceedings paper

10.1007/978-3-319-57955-9_7

Department of Software Engineering

The goal of this paper is to contribute to efforts of improving the Business Process Modelling (BPM) practice. We present an original method for converting 0enterprise ontology Design & Engineering Method for Organisations (DEMO) process models into a BPMN 2.0 notation. By this approach, we are able to mitigate certain methodological deficiencies of BPMN. The method exhibits the following qualities: Implementation of the complete transaction pattern formulated by the PSI-theory, correct managing of multiple child transaction instances, and executability of the resulting BPMN model.

Article

10.12688/f1000research.11407.1

Department of Software Engineering

Scientific research relies on computer software, yet software is not always developed following practices that ensure its quality and sustainability. This manuscript does not aim to propose new software development best practices, but rather to provide simple recommendations that encourage the adoption of existing best practices. Software development best practices promote better quality software, and better quality software improves the reproducibility and reusability of research. These recommendations are designed around Open Source values, and provide practical suggestions that contribute to making research software and its source code more discoverable, reusable and transparent. This manuscript is aimed at developers, but also at organisations, projects, journals and funders that can increase the quality and sustainability of research software by encouraging the adoption of these recommendations.

Proceedings paper

10.1007/978-3-319-56535-4_84

Department of Software Engineering

Increase flexibility, decrease usability” is a known trade-off influencing the effectiveness of reusing artefacts in many engineering disciplines. We claim that software development is influenced, too. The goal of this paper is to elaborate on flexibility and usability in component-based software development. It explains that equally flexible components can considerably differ in usability costs. Therefore, the architecture of components matters to evaluate final cost on building software. We propose a model of building components that can help to decrease costs on software development, while providing a demanded level of flexibility.

Proceedings paper

10.1145/3139903.3139908

Department of Software Engineering

Aspects of live-programming that have originated with Lisp and Smalltalk systems have recently seen a renewed research and industrial interest due to their educational and productivity potential (Live workshops at ECOOP, ICSE, and SPLASH, live facilities for the .Net, Java, Python, and Swift platforms). Especially in the case of visual modeling and simulation tools that are used by experts outside Informatics (such as ecologists, biologists, economists, epidemiologists, ...), this constant-feedback loop that live-systems provide can ease the development and comprehension of complex systems, via truly explorable environments. Unfortunately, taking the domain of Epidemiology as a case-study, we observe that the visual component of such systems have no notion of modularity and thus exploration is limited only to small monolithic examples. In order to address this issue we propose a model for modular visual exploration. This model is based on an extension of the OpenPonk platform targeting the Kendrick epidemiological language. Through this model we were able to map the separation of concerns of the Kendrick DSL, in a live visual notation that supports modularity and exploration of part-whole hierarchies.

Article

10.2298/CSIS170109035R

Department of Software Engineering

OntoUML is an ontologically well-founded conceptual modelling language that distinguishes various types of classifiers and relations providing precise meaning to the modelled entities. While Model-Driven Development is a wellestablished approach, OntoUML has been overlooked so far as a conceptual modelling language for the PIM of application data. This paper is an extension of the paper presented at MDASD 2016, where we outlined the transformation of Rigid Sortal Types – Kinds and Subkinds. In this paper, we discuss the details of various variants of the transformation of these types and the rigid generalization sets. The result of our effort is a complete method for preserving high-level ontological constraints during the transformations, specifically special multiplicities and generalization set meta-properties in a relational database using views, CHECK constraints and triggers.

Proceedings paper

10.1145/2991041.2991055

Department of Software Engineering

In this paper we present OpenPonk: a free, open-source, simple to use platform for developing tools for conceptual modeling: diagramming, DSLs, and algorithms operating on the models and diagrams, such as automatic layouting, model transformations, validations, etc. This project differentiates itself from the current efforts by providing completely free and open-source live development environment, which is simple to learn, use, and extend. There are already several plugins and extensions that bring several notations and algorithms, some of which are presented in this paper, alongside the overview of the core of the platform, and how they integrate with each other. We also present a comprehensive project case study utilizing OpenPonk.

Proceedings paper

10.1007/978-3-319-49454-8_5

Department of Software Engineering

OntoUML is an ontologically well-founded conceptual modelling language that distinguishes various types of classifiers and relations providing precise meaning to the modelled entities. Efforts arise to incorporate OntoUML into the Model-Driven Development approach as the conceptual modelling language for the platform independent model of application data. This paper discusses the transformation of an OntoUML platform independent model into an implementation specific model of a relational database schema, while preserving the semantics of the OntoUML universal types.

Proceedings paper

10.1007/978-3-319-45547-1_1

Department of Software Engineering

OntoUML is an ontologically well-founded conceptual modelling language that distinguishes various types of classifiers and relations providing precise meaning to the modelled entities. Efforts arise to incorporate OntoUML into the Model-Driven Development approach as a conceptual modelling language for the PIM of application data. In our previous research, we outlined our approach to the transformation of an OntoUML PIM into an ISM of a relational database. In a parallel paper, we discuss the details of the transformation of Rigid Sortal Types, while this paper is focused on the transformation of Anti-rigid Sortal Types.

Proceedings paper

10.15439/2016F250

Department of Software Engineering

OntoUML is an ontologically well-founded conceptual modelling language that distinguishes various types of classifiers and relations providing precise meaning to the modelled entities. Efforts arise to incorporate OntoUML into the Model-Driven Development approach as a conceptual modelling language for the PIM of application data. In a prequel paper, we have introduced and outlined our approach for a transformation of OntoUML PIM into a PSM of a relational database. In this paper, we discuss the details of various variants of the transformation of Rigid Sortal types of OntoUML.

Proceedings paper

10.1007/978-3-319-39567-8_10

Department of Software Engineering

The discipline of enterprise engineering and the DEMO methodology enable a model-driven approach to enterprise software systems development. Apart from the graphical notation, the DEMO models may be fully specified in the DEMOSL language, which may become a basis for an workflow software system implementation. However, the current specification of DEMOSL has been designed mostly for the reasoning between human stakeholders. In this paper a formal calculation construct called a DEMO Machine is proposed and basic ontological foundations of this machine are elaborated based on the alignment with the theories of enterprise engineering, various ontological and formal quality criteria and the application of the Generic Systems Development Process for Model Driven Engineering (GSDP-MDE methodology).

Proceedings paper

Department of Software Engineering

Design & Engineering Methodology for Organisations (DEMO) is a methodology for (re)designing and (re)engineering of organisations. Having a strong theoretical background in the PSI theory (Performance in Social Interactions), DEMO deals with communication and interaction between subjects (human beings) that play a crucial role within all company processes. Advanced information systems are used to support processes and communications. In these systems, confirmations are very usual patterns. In this paper, we present a design of a confirmation engine based on the transaction axiom of the PSI theory. We discuss a theoretical background of this engine, our implementation, and how this module fits into the IT infrastructure.

Proceedings paper

10.1007/978-3-319-19297-0

Department of Software Engineering

Monitoring and analyzing the operation of enterprises is a key capability of Governance, Risk, and Compliance (GRC) solutions and is relevant for high­risk organizations, such as financial services. The potential of state­of­the­art process mining (data­driven process analysis) is limited by quality issues with transactional data registration and extraction. A novel approach is proposed to address these challenges: the Enterprise Operational Analysis (EOA) founded in DEMO and the Enterprise Operating System (EOS). The EOS is a software system based on enterprise engineering, and stores, interprets, and executes DEMO models as native source code. The EOS provides workflow­like capabilities and supports EOA. Combining the EOS with state­of­the­art process mining offers the following advantages: guaranteed completeness of analysis, elimination of 'mining' for events, facilitating process conformance checking, analysis on various levels of granularity from various perspectives. It enables enterprises to systematically analyze, improve and deploy business procedures. A professional business case is analyzed.

Proceedings paper

10.1007/978-3-319-19297-0_1

Department of Software Engineering

Monitoring and analyzing the operation of enterprises is a key capability of Governance, Risk, and Compliance (GRC) solutions and is rele- vant for high-risk organizations, such as financial services. The potential of state-of-the-art process mining (data-driven process analysis) is limited by quality issues with transactional data registration and extraction. A novel approach is proposed to address these challenges: the Enterprise Operational Analysis (EOA) founded in DEMO and the Enterprise Operating System (EOS). The EOS is a software system based on enterprise engineering, and stores, interprets, and executes DEMO models as native source code. The EOS pro- vides workflow-like capabilities and supports EOA. Combining the EOS with state-of-the-art process mining offers the following advantages: guaranteed completeness of analysis, elimination of ‘mining’ for events, facilitating process conformance checking, analysis on various levels of granularity from various perspectives. It enables enterprises to systematically analyze, improve and deploy business procedures. A professional business case is analyzed.

Proceedings paper

10.1007/978-3-319-24626-0_8

Department of Software Engineering

This paper addresses the notion of process decomposition as a tool for managing process complexity in BORM Object Relation Diagram. It investigates the composition principle already present in ORD and shows it as ambiguous and mostly unsuitable for that purpose. Substantial changes to the original meta-model of ORD are proposed by introducing a new concept called tasks. The implications of introducing this new concept are then investigated, especially concerning decomposition of communications in a BORM process.

Proceedings paper

10.1007/978-3-662-44860-1_7

Department of Software Engineering

Business Object Relation Modelling (BORM) is a method for systems analysis and design that utilises an object oriented paradigm in combination with business process modelling. BORM’s Object Relation Diagram (ORD) is successfully used in practice for object behaviour analysis (OBA). OBA has found its firm place for visualisation and simulation of processes, however several ontological flaws were identified and there seems to be missing a strong formal foundation that would enable correct reasoning about the models. In this paper, we propose a sound formal foundation for BORM’S ORD. Based on this formal foundation (which we call “the prefix machine”), we get not only to a precise behaviour specification, but it also offers some interesting means of process analysis.

Proceedings paper

10.5220/0004897603150322

Department of Software Engineering

Business Object Relation Modelling (BORM) is a method for systems analysis and design that utilises an object oriented paradigm in combination with business process modelling. BORM’s Object Relation Diagram (ORD) is successfully used in practice for object behaviour analysis (OBA). We, however, identified several flaws in the diagram’s behaviour semantics. These occur mostly due to inconsistent and incomplete formal specification of the ORD behaviour. In this paper, we try to amend this gap by introducing so called input and output conditions, which we consider to be the most important first step towards a sound formal specification of the ORD.

Proceedings paper

Department of Theoretical Computer Science

Floods impose a signifi cant risk to buildings sustainability. Due to climate changes, this issue becomes a topic for more and more areas. Among various categories, cultural heritage is especially vulnerable to fl oods and usually requires unique and individual approach because its assets cannot be reproduced in contrast to ordinary buildings and objects. This contribution would like to present some results of the ongoing research project focused on protection of cultural heritage from fl ood danger.

Proceedings paper

10.1007/978-3-642-41638-5_6

Department of Software Engineering

Instance-level modelling is a sort of conceptual modelling that deals with concrete objects instead of general classes and types. Instance-level modelling approach oers a rather innovative way for com- munication with domain experts extremely useful for them, as they can see their real data in the context of the given model. Various approaches were presented in the paper Instance-Level modelling and Simulation Using Lambda-Calculus and Object-Oriented Environments" at EOMAS 2011. The present paper is a sequel and it presents additional approaches we nd useful in practice: Fact-oriented modelling, OntoUML in combi- nation with OCL and the Alloy and Eclipse-based framework Dresden- OCL.We present key features of the various approaches and demonstrate them on a running example, we follow up with a discussion comparing these approaches. Notice that OntoUML combined with the Alloy is an original research achievement built on the research of OntoUML.

Proceedings paper

10.1007/978-3-642-41366-7

Department of Software Engineering

OntoUML is a promising method for ontological modelling. In this paper, we discuss its possible use for software engineering.We propose a method of transformation of an ontological model into a softwareengineering object-oriented class model in UML and its instantiation. Our approach is based on the following best practices: pure objectoriented paradigm and approach of dividing state and identity as introduced in the Clojure programming language.