prof. Dr. Ing. Petr Kroha, CSc.

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.3233/FAIA210063

Department of Software Engineering

We investigate inconsistency problem in textual functional requirements specifications. We argue that some sources of inconsistency can be revealed during the very first steps of textual requirements analysis. In this paper, we focus on those facts and rules that domain experts find so obvious that they do not even mention them to the analysts during the discussions about the product to be constructed. However, what is very obvious for stakeholders may not be obvious for analysts. We call such rules default consistency rules. We argue that the lack of the default consistency rules leads to incompleteness in the requirements, and it causes inconsistency with all its unpleasant consequences. In this contribution, we describe our approach to the problem of how the missing information can be both identified in the original requirements and found in external sources. We show a motivational example and explain our method.

Proceedings paper

10.1007/978-3-030-79022-6_7

Department of Software Engineering

In this paper, we describe our graph-oriented method used to find semantically similar sentences in external information sources that have a semantic enrichment potential in relation to sentences of textual functional requirements specification. Our motivation is to reduce the incompleteness of requirements that may be a source of inconsistency. We found there are some facts and rules so obvious for domain experts that they do not even mention them in requirements. We call such rules default consistency rules. These rules are often not implemented and can not be revealed from the requirements because they are not mentioned there.

Proceedings paper

10.5220/0009344202890296

Department of Software Engineering

In this contribution, we investigate the incompleteness problem in textual requirements specifications. Missing alternative scenarios are one of the incompleteness sources, i.e., descriptions of processing in the cases when something runs in another way as expected. We check the text of requirements specification using linguistic patterns, and we try to reveal scenarios and alternative scenarios. After that process is finished, we decide whether the set of alternative scenarios is complete. As a result, we generate warning messages. We illustrate our approach with examples.

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.

Proceedings paper

10.1007/978-3-030-16181-1_83

Department of Software Engineering

In this contribution, we investigate the ambiguity problem in textual requirements specifications. We focused on the structural ambiguity and extracted some patterns to indicate this kind of ambiguity. We show that the standard methods of linguistics are not enough in some cases, and we describe a class of ambiguity caused by coreference that needs an underlying domain model or a knowledge base to be solved. Part of our implemented solution is a cooperation of our tool TEMOS with the Prolog inference machine working with facts and rules acquired from OCL conditions of the domain model.

Proceedings paper

10.5220/0007978003230330

Department of Software Engineering

In this contribution, we investigate the incompleteness problem in textual requirements specifications. Incompleteness is a typical problem that arises when stakeholders (e.g., domain experts) hold some information for generally known, and they do not mention it to the analyst. A model based on the incomplete requirements suffers from missing objects, properties, or relationships as we show in an illustrating example. Our presented methods are based on grammatical inspection, semantic networks (ConceptNet and BabelNet), and pre-configured data from on-line dictionaries. Additionally, we show how a domain model has to be used to reveal some missing parts of it. Our experiments have shown that the precision of our methods is about 60–82 %.

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

In this contribution, we investigate whether it is possible to use chaotic properties of time series in forecasting. Time series of market data have components of white noise without any trend, and they have components of brown noise containing trends. We constructed a new technical indicator MH (Moving Hurst) based on Hurst exponent that describes chaotic properties of time series. Further, we stated and proved a hypothesis that this indicator can bring more profit than the very well known indicator MACD (Moving Averages Convergence Divergence) that is based on moving averages of time series values. In our experiments, we tested and eva- luated our proposal using hypothesis testing. We argue that Hurst exponent can be used as an indicator of technical analysis under considerations discussed in our paper.

Proceedings paper

10.5220/0006827302310238

Department of Software Engineering

In this paper, we investigate methods of grammatical inspection to identify patterns in textual requirements specification. Unfortunately, a text in natural language includes additionally many inaccuracies caused by ambiguity, inconsistency, and incompleteness. Our contribution is that using our patterns, we are able to extract the information from the text that is necessary to fix some of the problems mentioned above. We present our implemented tool TEMOS that is able to detect some inaccuracies in a text and to generate fragments of the UML class model from textual requirements specification. We use external on-line resources to complete the textual information of requirements.

Proceedings paper

10.1007/978-3-319-58274-0_3

Department of Software Engineering

In this contribution, we present our approach to querying XML document that is stored in a distributed system. The main goal of this paper is to describe how to use Spark SQL framework to implement a subset of expressions from XPath query language. Five different methods of our approach are introduced and compared, and by this, we also demonstrate the actual state of query optimization on Spark SQL platform. It may be taken as the next contribution of our paper. A subset of expressions from XPath query language (supported by the implemented methods) contains all XPath axes except the axes of attribute and namespace while predicates are not implemented in our prototype. We present our implemented system, data, measurements, tests, and results. The evaluated results support our belief that our method significantly decreases data transfers in the distributed system that occur during the query evaluation.

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.1007/978-3-319-44039-2_18

Department of Software Engineering

In this contribution, we present our original approach to distributed wide-column store database tuning based on data locality optimization. The main goal of the optimization is the reduction of communication overhead in distributed environment during Map-Reduce query evaluation. The optimization is realized by the minimisation of the total number of key-value pairs emitted from mappers. To achieve the goal, we combine several Map-Reduce optimization methods, adapt them to wide-column store model and utilize them to overcome architectural limitation. To prove our idea, we implemented the proposed solution in HBase system that represents this class of DBMS. We present our data, measurements, and tests. The evaluated results support our idea that this method can significantly decrease data transfers in the distributed system.

Proceedings paper

10.1109/IJCNN.2016.7727600

Department of Theoretical Computer Science
Department of Software Engineering

Educational data can help us to personalise university information systems. In this paper, we show how educational data can be used to improve the performance of interaction-based recommender systems. Educational data is transformed to student profiles helping to prevent cold start problems when recommending projects to students with few user interactions. Our results show that our hybrid interaction based recommender boosted by educational profiles significantly outperforms bestseller recommendation, which is a mainstream recommendation method for cold start users.

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-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-319-04298-5

Department of Software Engineering

In this contribution, we describe and compare two genetic systems which create tading strategies. The first systém is based on the idea that the connection weight matrix of a neural network represents the genotype of and individual and can be changed by genetic algorithm. The second systém uses genetic programming to derive trading strategies. As input data in our experiments, we used technical indicators of NASDAQ stocks. As output, the algorithms generate trading strategies, i.e. buy, hold, and sell signals. Our hypothesis that strategies obrained by genetic programming bring better results than buy-and-hold stratégy has been proven as statistically significant. We discuss our results and compare them to our previous experiments with fuzzy technology, fractal approach, and with simple technical indicator strategy.

Proceedings paper

10.1007/978-3-642-27534-0

Department of Software Engineering

In this contribution, we investigate the possibilities of using fuzzy and fractal methods for analysing time series of market data. First, we implemented and tested a fuzzy component that provides fuzzyfication by the Mamdani Larsen inference method with static rules using not only Gauss but also Cauchy and Mandelbrot distribution. Second, we implemented and tested a fractal component that provides fuzzy clustering by the Takagi Sugeno method with dynamic fuzzy rules. Looking for an optimum, we simulated many parameter combinations and compared the results. We present some interesting results of our experiments.