Declarative Paradigm Research Articles

Розробка методичних рекомендацій використання функціональної парадигми програмування в мові Scala

Different approaches to defining data structures and creating programs in different ones are considered programming paradigms. The dependence of the imperative programming paradigm on low-level algorithms and operations. Ideas for the main variables of data structures are given and operations on their mutation. Approaches to the organization of algorithms in the programming language are described in Scala using these data structures. It is shown that in the declarative paradigm programming focus shifts from algorithms to mathematical expressions, and demonstrates how to use high – level operations to create a program for using algebraic expressions.

“Minus Stroke-operation” and its Declarative Aspects

The article considers the capacities of “Minus stroke-operation”, which was introduced as the inverse of “stroke-operation” (dereferencing a pointer).Addressing higher ranks Address Programming is based on “stroke-operation” and, in contrast to the dereference (or indirection) operator, allows you to specify the rank of addressing, which can be both an integer value or an expression of integer type. The paper gives an example of using a “stroke-operation” to obtain the address of an arbitrary element of a linear single-linked list by its sequence number. The dereference operator of modern programming languages does not allow to make it and demands implementation with use of a cycle.“Minus stroke operation” operation is not used in imperative high-level programming languages, be- cause it belongs to the declarative paradigm of programming.Address programming language has the dynamic types of data, which are based on “minus stroke-operation”.This article provides some specific examples of the use of “minus stroke-operation” in the Address Programming language and compares the capabilities of this operation with some modern declarativeprogramming tools. From the above examples it follows the universal power of “minus stroke-operation” as a tool of declarative programming.The paper presents an example of tree representation using “minus stroke-operation”. In Address Programming, you can represent trees by defining only the vertex parents. The result of applying to the address of the node “minus the stroke-operation” is a set of sons of this node. An example of a tree representation in the Address Programming Language with parent-only indication is given.The Address Programming Language is multi-conceptual and combines the concepts of imperative and declarative programming. The basis of the declarative concept of Address Programming (1955) is “minus stroke-operation”.Manuscript received 11.06.2020

From model to implementation: a network algorithm programming language

Software-defined networking (SDN) is a revolutionary technology that facilitates network management and enables programmatically efficient network configuration, thereby improving network performance and flexibility. However, as the application programming interfaces (APIs) of SDN are low-level or functionality-restricted, SDN programmers cannot easily keep pace with the ever-changing devices, topologies, and demands of SDN. By deriving motivation from industry practice, we define a novel network algorithm programming language (NAPL) that enhances the SDN framework with a rapid programming flow from topology-based network models to C+ implementations, thus bridging the gap between the limited capability of existing SDN APIs and the reality of practical network management. In contrast to several state-of-the-art languages, NAPL provides a range of critical high-level network programming features:linebreak (1) topology-based network modeling and visualization; (2) fast abstraction and expansion of network devices and constraints; (3) a declarative paradigm for the fast design of forwarding policies; (4) a built-in library for complex algorithm implementation; (5) full compatibility with C+ programming; and (6) user-friendly debugging support when compiling NAPL into highly readable C+ codes. The expressiveness and performance of NAPL are demonstrated in various industrial scenarios originating from practical network management.

Bidirectional Transformation of MES Source Code and Ontologies

Future production environments must be flexible and reconfigurable. To achieve this, the devices and services to fulfill the different steps of a production order (PO) should not be selected in the manufacturing execution system (MES), but in an edge component close to the shop floor. To enable this, abstract services in the PO and concrete services provided by the field devices on the shop floor need to refer to a production ontology. The creation of this ontology is a challenge of its own. This research proposes a pragmatic automation of an encoding of a primary and light weight production ontology based on the source code of MES. The transformation procedure of source code to resource, product and generic concepts of the manufacturing plant ontology is described. To this end, the knowledge of OPC UA collaborations are also exploited during the creation of resource ontologies. Due to a fundamental difference between source code implementation (imperative paradigm) and ontology representation (declarative paradigm), the problem of information loss is inevitable. This problem is overcome by formulation of production and business rules that encapsulate the logic of the MES. The foundation of ontology is exploited to formulate these rulesets using OWL based constructs and OWL based rule languages such as Semantic Web Rule Language (SWRL), Semantic Query-Enhanced Web Rule Language (SQWRL) and SPARQL Protocol and RDF Query Language (SPARQL) based on feasibility and requirements of specific rules. Further, these rulesets are either run on the automatically generated ontology at design time with an intention to enrich the knowledge base, or production runtime to validate the pre-defined business rules between the production steps. The generated ontology also acts as basis for automatically generating the OWL-S ontologies for the OPC UA application methods for the purpose of dynamic manufacturing service discovery and orchestration. The generated ontology and an abstract PO hooked with formulated rules are cached to the shop-floor network for consequent production control to enable smart edge production. An implementation is conducted on an industrial use-case demonstrator to evaluate the applicability of the proposed approach.

Declarative Data Analytics: A Survey

The area of declarative data analytics explores the application of the declarative paradigm on data science and machine learning. It proposes declarative languages for expressing data analysis tasks and develops systems which optimize programs written in those languages. The execution engine can be either centralized or distributed, as the declarative paradigm advocates independence from particular physical implementations. The survey explores a wide range of declarative data analysis frameworks by examining both the programming model and the optimization techniques used, in order to provide conclusions on the current state of the art in the area and identify open challenges.

Abstract solvers for Dung’s argumentation frameworks

Abstract solvers are a quite recent method to uniformly describe algorithms in a rigorous formal way and have proven successful in declarative paradigms such as Propositional Satisfiability and Answer Set Programming. In this paper, we apply this machinery for the first time to a dedicated AI formalism, namely Dung’s abstract argumentation frameworks. We provide descriptions of several advanced algorithms for the preferred semantics in terms of abstract solvers and, moreover, show how slight adaptions thereof directly lead to new algorithms.

Constraints, lazy constraints, or propagators in ASP solving: An empirical analysis

AbstractAnswer set programming (ASP) is a well-established declarative paradigm. One of the successes of ASP is the availability of efficient systems. State-of-the-art systems are based on the ground+solve approach. In some applications, this approach is infeasible because the grounding of one or a few constraints is expensive. In this paper, we systematically compare alternative strategies to avoid the instantiation of problematic constraints, which are based on custom extensions of the solver. Results on real and synthetic benchmarks highlight some strengths and weaknesses of the different strategies.

A multi-paradigm language for reactive synthesis

This paper proposes a language for describing reactive synthesis problems that integrates imperative and declarative elements. The semantics is defined in terms of two-player turn-based infinite games with full information. Currently, synthesis tools accept linear temporal logic (LTL) as input, but this description is less structured and does not facilitate the expression of sequential constraints. This motivates the use of a structured programming language to specify synthesis problems. Transition systems and guarded commands serve as imperative constructs, expressed in a syntax based on that of the modeling language Promela. The syntax allows defining which player controls data and control flow, and separating a program into assumptions and guarantees. These notions are necessary for input to game solvers. The integration of imperative and declarative paradigms allows using the paradigm that is most appropriate for expressing each requirement. The declarative part is expressed in the LTL fragment of generalized reactivity(1), which admits efficient synthesis algorithms, extended with past LTL. The implementation translates Promela to input for the Slugs synthesizer and is written in Python. The AMBA AHB bus case study is revisited and synthesized efficiently, identifying the need to reorder binary decision diagrams during strategy construction, in order to prevent the exponential blowup observed in previous work.

Modeling Hybrid Systems in the Concurrent Constraint Paradigm

Hybrid systems, which combine discrete and continuous dynamics, require quality modeling languages to be either described or analyzed. The Concurrent Constraint paradigm (ccp) is an expressive declarative paradigm, characterized by the use of a common constraint store to communicate and synchronize concurrent agents. In this paradigm, the information is stated in the form of constraints, in contrast to the variable/value style typical of imperative languages. Several extensions of ccp have been proposed in order to model reactive systems. One of these extensions is the Timed Concurrent Constraint Language (tccp) that adds to ccp a notion of discrete time and new features to model time-out and preemption actions. The goal of this paper is to explore the expressive power of tccp to describe hybrid systems. We introduce the language Hy-tccp as a conservative extension of tccp, by adding a notion of continuous time and new constructs to describe the continuous dynamics of hybrid systems. In this paper, we present the syntax and the operational semantics of Hy-tccp together with some examples that show the expressive power of our new language.

Approach Based on Web Services for Business Process Adaptation

Abstract Business process lifecycle is chiefly divided into two phases namely modeling and execution. Therefore, flexibility of business process can be taken into account either at build-time or at runtime. The first kind is well supported mainly by declarative modeling paradigms. Nevertheless, many challenges are posed by the second kind of flexibility (such as at which level of abstraction can flexibility be expressed and by what criteria should it be performed) as well as by the business process adaptation when we consider the implementation phase of business process. In this context, our aim in this paper is to propose an approach based on web services in order to support business process adaptation during its implementation. The proposal is to implement as web services the manners in which activities are executed and that can be subject to change. Each manner refers to the actions implementing the current activity. It can then be adapted to execute the same business process in another organization.

SWOWS and dynamic queries to build browsing applications on linked data

The linked data initiative is pushing dataset maintainers to publish data online in a highly reusable way through a set of open standards, such as RDF and SPARQL. The variety and amount of structured data available on the Web are increasing, but their consumption is still quite limited. In particular, applications that are used to explore linked data are usually generic linked data browsers or applications with hard-coded logic tailored for specific needs. SWOWS is a platform for declarative specification of applications consuming linked data. In this paper, we describe the use of the platform for creating browsing applications tailored to specific contexts, and show how the declarative paradigm supports the development of flexible applications. To this end, the platform has been extended to support the dynamic generation of SPARQL queries. An example of a linked data browser created with the platform is given.

A reactive extension of the OpenMusic visual programming language

Objectives: OpenMusic (OM) is a domain-specific visual programming language designed for computer-aided music composition. This language based on Common Lisp allows composers to develop functional processes generating or transforming musical data, and to execute them locally by demand-driven evaluations. As most historical computer-aided composition environments, OM relies on a transformational declarative paradigm, which is hard to conciliate with reactive data-flow (an evaluation scheme more adequate to the development of interactive systems). We propose to link these two evaluation paradigms in the same and consistent visual programming framework.Methods: We establish a denotational semantics of the visual language, which gives account for its demand-driven evaluation mechanism and the incremental construction of programs. We then extend this semantics to enable reactive computations in the functional graphs.Results: The resulting language merges data-driven executions with the existing demand-driven mechanism. A conservative implementation is proposed.Conclusions: We show that the incremental construction of programs and their data-driven and demand-driven evaluations can be smoothly integrated in the visual programming workflow. This integration allows for the propagation of changes in the programs, and the evaluation of graphically designed functional expressions as a response to external events, a first step in bridging the gap between computer-assisted composition environments and real-time musical systems.

Declarative business process modelling: principles and modelling languages

The business process literature has proposed a multitude of business process modelling approaches or paradigms, each in response to a different business process type with a unique set of requirements. Two polar paradigms, i.e. the imperative and the declarative paradigm, appear to define the extreme positions on the paradigm spectrum. While imperative approaches focus on explicitly defining how an organisational goal should be reached, the declarative approaches focus on the directives, policies and regulations restricting the potential ways to achieve the organisational goal. In between, a variety of hybrid-paradigms can be distinguished, e.g. the advanced and adaptive case management.This article focuses on the less-exposed declarative approach on process modelling. An outline of the declarative process modelling and the modelling approaches is presented, followed by an overview of the observed declarative process modelling principles and an evaluation of the declarative process modelling approaches.

Notification Oriented and Object Oriented Paradigms Comparison via Sale System

This paper presents a new programming paradigm named Notification-Oriented Paradigm (NOP) and analyses the performance aspects of NOP programs by means of an experiment. NOP provides a new manner to conceive, structure, and execute software, which would allow causal-knowledge organization and decoupling better than standard solutions based upon current paradigms. These paradigms are essentially Imperative Paradigm (IP) and Declarative Paradigm (DP). In short, DP solutions are considered easier to use than IP solutions due to the concept of high-level programming. However, they are considered slower in execution and lesser flexible in development. Anyway, both paradigms present similar drawbacks such as redundant causal-evaluation and strongly coupled entities, which decrease software performance and processing distribution feasibility. These problems exist due to an orientation to a monolithic inference mechanism based on sequential evaluation searching on passive computational entities. NOP proposes another way to structure software and make its inferences, which is based on small, collaborative, and decoupled computational entities whose interaction happens through precise notifications. This paper presents a quantitative comparison between two equivalent implementations of a sale system, one developed according to the principles of Object-Oriented Paradigm (OOP/IP) in C++ and other developed according to the principles of NOP based on a NOP framework in C++. The results showed that NOP implementation obtained quite equivalent results with respect to OOP implementation. This happened because the NOP framework uses considerable expensive data-structures over C++. Thus, it is necessary a new compiler to NOP in order to actually use its potentiality.

A Game Comparative Study: Object-Oriented Paradigm and Notification-Oriented Paradigm

This paper presents a new programming paradigm named Notification-Oriented Paradigm (NOP) and analyses the performance aspects of NOP programs by means of an experiment. NOP provides a new manner to conceive, structure, and execute software, which would allow better performance, causal-knowledge organization, and decoupling than standard solutions based upon usual paradigms. These paradigms are essentially Imperative Paradigm (IP) and Declarative Paradigm (DP). In short, DP solutions are considered easier to use than IP solutions due to the concept of high-level programming. However, they are considered slower in execution and less flexible in development. Anyway, both paradigms present similar drawbacks such as redundant causal-evaluation and strongly coupled entities, which decrease the software performance and the processing distribution feasibility. These problems exist due to an orientation to a monolithic inference mechanism based upon sequential evaluation by searching on passive computational entities. NOP proposes another way to structure software and make its inferences, which is based upon small, collaborative, and decoupled computational entities whose interaction happens through precise notifications. In this context, this paper presents a quantitative comparison between two equivalent implementations of a computer game simulator (Pacman simulator), one developed according to the principles of Object-Oriented Paradigm (OOP/IP) in C++ and other developed according to the principles of NOP. The results obtained from the experiments demonstrate, however, a quite lower performance of NOP implementation. This happened because NOP applications are still developed using a framework based on C++. Besides, the paper shows that optimizations in the NOP framework improve NOP program performance, thereby evidencing the necessity of developing a NOP language/compiler.

Notification Oriented Paradigm (NOP) and Imperative Paradigm: A Comparative Study

This paper presents a new programming paradigm named Notification Oriented Paradigm (NOP) and analyses performance aspects of NOP programs by means of an experiment. NOP provides a new manner to conceive, structure, and execute software, which allows better performance, causal-knowledge organization, and entity decoupling than standard solutions based upon current paradigms. These paradigms are essentially Imperative Paradigm (IP) and Declarative Paradigm (DP). In short, DP solutions are considered easier to use than IP solutions thanks to the concept of high-level programming. However, they are considered slower to execute and lesser flexible to program than IP. Anyway, both paradigms present similar drawbacks like causal-evaluation redundancies and strongly coupled entities, which decrease software performance and processing distribution feasibility. These problems exist due to an orientation to monolithic inference mechanism based upon sequential evaluation by means of searches over passive computational entities. NOP proposes another manner to structure software and make its inferences, which is based upon small, smart, and decoupled collaborative entities whose interaction happen by means of precise notifications. This paper discusses NOP as a paradigm and presents certain comparison of NOP against IP. Actually, performance is evaluated by means of IP and NOP programs with respect to a same application, which allow demonstrating NOP superiority.

Product configuration as decision support: The declarative paradigm in practice

AbstractProduct configuration is a key technology, which enables businesses to deliver and deploy individualized products. In many cases, finding the optimal configuration solution for the user is a creative process that requires them to decide trade-offs between conflicting goals (multicriteria optimization problem). These problems are best supported by an interactive dialog that is managed by a dedicated software program (the configurator) that provides decision support. We illustrate this using a real example (configuration of a business software system). This productively used application makes the user aware of which choices are available in a given situation, provides assistance in resolving inconsistent choices and defaults, and generates explanations if desired. One of the key configurator components used to manage this is a truth maintenance system. We describe how this component is used and two novel extensions to it: methods for declarative handling of defaults (of varying strength) and the declarative handling of incompleteness. Finally, we summarize our experiences made during the implementation of this application and the pros and cons of declarative versus procedural approaches.

Thresholded Tabulation in a Fuzzy Logic Setting

Fuzzy logic programming represents a flexible and powerful declarative paradigm amalgamating fuzzy logic and logic programming, for which there exists different promising approaches described in the literature. In this paper we propose an improved fuzzy query answering procedure for the so called multi-adjoint logic programming approach, which avoids the re-evaluation of goals and the generation of useless computations thanks to the combined use of tabulation with thresholding techniques. The general idea is that, when trying to perform a computation step by using a given program rule R, we firstly analyze if such step might contribute to reach further significant solutions (non tabulated yet). When it is the case, it is possible to avoid a useless computation step via a rule R by using thresholds and filters based on the truth degree of R, as well as a safe, accurate and dynamic estimation of the maximum truth degree associated to its body.

A hybrid programming scheme combining fuzzy-logic and functional-logic resources

This paper focuses on the integration of the (also integrated) declarative paradigms of functional-logic and fuzzy-logic programming, in order to obtain a richer and much more expressive programming scheme where mathematical functions cohabit with fuzzy-logic features. Our final goal is to achieve a fully integrated language amalgamating powerful programming resources from both worlds, including an efficient (lazy) evaluation mechanism, non-determinism, similarity relations, and so on. Starting with two representative languages from both settings, namely Curry and Likelog, we propose a hybrid dialect where a set of rewriting rules associated to the functional-logic dimension of the language, are accompanied with a set of similarity equations between symbols of the same nature and arity, which represents the fuzzy counterpart of the novel framework. Then, we directly act inside the kernel of the operational mechanism of the language, thus obtaining a fuzzy variant of needed narrowing which safely deals with similarity relations. A key point in the design of this last operational method is that, in contrast with the crisp case, the fuzzified version of the function which determines the set of tuples that enable new narrowing steps for a given goal, say λ fuzzy , must explicitly take care of binding variables belonging to both goals and program rules. This action is crucial to model the notion of needed narrowing with similarity relations step by means of a transition system whose final states are triples of the form 〈 value , substitution , similarity _ degree 〉 which collect the three relevant components of the new notion of fuzzy computed answer. Finally, we prove that the resulting strategy verifies that, apart from computing at least the same elements of the crisp case ( crispness), all similar terms of a given goal are completely treated too by fully exploiting the similarities collected in a given program ( fuzziness) while avoiding the risk of infinite loops associated to the intrinsic (reflexive, symmetric and transitive) properties of similarity relations ( termination).

Optimizing Fuzzy Logic Programs by Unfolding, Aggregation and Folding

Multi-adjoint logic programming represents a very recent, extremely flexible attempt for introducing fuzzy logic into logic programming. Inspired by our previous experiences in the field of (declarative) program transformation, in this paper we propose the development of a fold/unfold based transformation system for optimizing such kind of fuzzy logic programs. The starting point is a set of unfolding-based transformations together with a reversible kind of fuzzy folding, that we have designed in the past. The present work substantially improves this last transformation operation by allowing the possibility of using rules belonging to different programs in a transformation sequence when performing a folding step, which is crucial to obtain better, recursive and elegant definitions of fuzzy predicates. In contrast with other declarative paradigms, in the fuzzy setting it is mandatory to pack sets of fuzzy predicates in tuples, if we really want the folding operation to proceed. This implies the need for re-defining the classical “definition introduction” transformation rule and introducing a completely new operation, that we call “aggregation”, which is especially tailored for the new framework. Finally, we illustrate how the effects of appropriately applying our set of transformation rules (definition introduction, aggregation, folding, unfolding and facting) to a given program, are able to improve the execution of goals against transformed programs.