Logic programming in the context of multiparadigm programming: the Oz experience

Oz is a multiparadigm language that supports logic programming as one of its major paradigms. A multiparadigm language is designed to support different programming paradigms (logic, functional, constraint, object-oriented, sequential, concurrent, etc.) with equal ease. This article has two goals: to give a tutorial of logic programming in Oz and to show how logic programming fits naturally into the wider context of multiparadigm programming. Our experience shows that there are two classes of problems, which we call algorithmic and search problems, for which logic programming can help formulate practical solutions. Algorithmic problems have known efficient algorithms. Search problems do not have known efficient algorithms but can be solved with search. The Oz support for logic programming targets these two problem classes specifically, using the concepts needed for each. This is in contrast to the Prolog approach, which targets both classes with one set of concepts, which results in less than optimal support for each class. To explain the essential difference between algorithmic and search programs, we define the Oz execution model. This model subsumes both concurrent logic programming (committed-choice-style) and search-based logic programming (Prolog-style). Instead of Horn clause syntax, Oz has a simple, fully compositional, higher-order syntax that accommodates the abilities of the language. We conclude with lessons learned from this work, a brief history of Oz, and many entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic Programming

First international Competition on Runtime Verification: rules, benchmarks, tools, and final results of CRV 2014

The first international Competition on Runtime Verification (CRV) was held in September 2014, in Toronto, Canada, as a satellite event of the 14th international conference on Runtime Verification (RV’14). The event was organized in three tracks: (1) offline monitoring, (2) online monitoring of C programs, and (3) online monitoring of Java programs. In this paper, we report on the phases and rules, a description of the participating teams and their submitted benchmark, the (full) results, as well as the lessons learned from the competition.ICT COST ActionFFG HARMONIAAustrian Science Fund (FWF)31704

Potential transformational leadership and public employee performance: a case study of the Egyptian ministry of antiquities

There has been a growing interest to understand how the officials of public sector agencies manage their employee performance to provide quality services to the citizens they serve. There is quite limited research that dealt with the obstacles the public sector officials identified as barriers to efficiently manage employee performance. This qualitative study focuses on the role of transformational leadership (TL) and challenges to manage employees\u27 performance at Egyptian ministry of Antiquities. Semi-structured interviews were conducted with ten of public officials, using an 8-item, open-ended questionnaire. By using primary sources, the study found eight key obstacles that managers listed as deterrents to manage employee performance as the following: lack of financial resources, bureaucratic control mechanisms such as centralization, formalization, red tape, and routinization, low employee motivation, salaries and wages below the market level, employee self-preservation, overstaffing, unqualified staff and ineffective leadership training. The study further reveals that the role of TL was minimal, as leaders identified mostly possess the characteristics of transactional leadership. These findings would possibly help the Egyptian public officials to improve the performance of the management, and thus improve the quality of services to citizens

Static analysis of unbounded structures in object-oriented programs

In this thesis we investigate different techniques and formalisms to address complexity introduced by unbounded structures in object-oriented programs. We give a representation of a weakest precondition calculus for abstract object creation in dynamic logic. Based on this calculus we define symbolic execution including abstract object creation. We investigate the complex behaviour introduced by multi-threading and give a formalism based on the transformation of multi-threaded reentrant call-graphs to thread automata and the application of context free language reachability to decide deadlock freedom of such programs. We give a formalisation of the observable interface behaviour of a concurrent, object-oriented language with futures and promises. The calculus captures the core of the Creol language and allows for a comparison with the concurrency model of thread-based, object-oriented languages like Java or C#. We give a technique to detect deadlock freedom for an Actor-like subset of the Creol language. LEI Universiteit LeidenThe work in this thesis has been carried out at the Christian-Albrechts--Universität zu Kiel, the Centrum Wiskunde & Informatica (CWI), and the Universiteit Leiden. The research was partially funded by the EU-project IST- 33826 Credo: Modeling and analysis of evolutionary structures for distributed services; the EU-project FP7-231620 HATS: Highly Adaptable and Trustworthy Software using Formal Methods; and the German-Norwegian DAAD-NWO exchange project Avabi (Automated validation for behavioral interfaces of asynchronous active objects).Algorithms and the Foundations of Software technolog

Lock sensitive analysis of parallel programs

"Lock sensitive analysis of parallel programs" (Lock-Sensitive Analyse nebenläufiger Programme) Diese Dissertation behandelt einen Modellprüfungsalgorithmus für dynamische Pushdown-Netzwerke mit Monitoren (Monitor-DPNs). Monitor-DPNs sind ein Modell für parallele Programme mit rekursiven Prozeduren, Thread-Erzeugung, und wechselweisem Ausschluss durch Monitore. Betrachtet werden Vorgängermengenberechnungen, mit denen man viele interessante Eigenschaften ausdrücken kann, unter Anderem Race-Conditions, Bitvektoranalysen und das (EF,EX)-Fragment der branching-time Logik CTL

Developing Executable Digital Models with Model-Based Systems Engineering – An Unmanned Aerial Vehicle Surveillance Scenario Example

There is an increase in complexity in modern systems that causes inconsistencies in the iterative exchange loops of the system design process and in turn, demands greater quality of system organization and optimization techniques. A recent transition from document-centric systems engineering to Model-Based Systems Engineering (MBSE) is being documented in literature from various industries to address these issues. This study aims to investigate how MBSE can be used as a starting point in developing digital twins (DT). Specifically, the adoption of MBSE for realizing DT has been investigated, resulting in various literature reviews that indicate the most prevalent methodologies and tools used to enhance and validate existing and future systems. An MBSE-enabled template for virtual model development was executed for the creation of executable models, which can serve as a research testbed for DT and system and system-of-systems optimization. This study explores the feasibility of this MBSE-enabled template by creating and simulating a surveillance system that monitors and reports on the health status and performance of an armored fighting vehicle via an Unmanned Aerial Vehicle (UAV). The objective of this template is to demonstrate how executable SysML diagrams are used to establish a collaborative working environment between multiple platforms to better convey system behavior, modifications, and analytics for various system stakeholders

SAVCBS 2004 Specification and Verification of Component-Based Systems: Workshop Proceedings

This is the proceedings of the 2004 SAVCBS workshop. The workshop is concerned with how formal (i.e., mathematical) techniques can be or should be used to establish a suitable foundation for the specification and verification of component-based systems. Component-based systems are a growing concern for the software engineering community. Specification and reasoning techniques are urgently needed to permit composition of systems from components. Component-based specification and verification is also vital for scaling advanced verification techniques such as extended static analysis and model checking to the size of real systems. The workshop considers formalization of both functional and non-functional behavior, such as performance or reliability

A Machine-Checked, Type-Safe Model of Java Concurrency : Language, Virtual Machine, Memory Model, and Verified Compiler

The Java programming language provides safety and security guarantees such as type safety and its security architecture. They distinguish it from other mainstream programming languages like C and C++. In this work, we develop a machine-checked model of concurrent Java and the Java memory model and investigate the impact of concurrency on these guarantees. From the formal model, we automatically obtain an executable verified compiler to bytecode and a validated virtual machine

Spatial coordination in wireless sensor network applications

In distributed systems, dependency among different computations of an application leads to a problem of deciding the locations of computations. Spatial requirements of a computation can be expressed in terms of spatial relationships with other computations. This research presents programming abstractions and language constructs which can be used for specifying spatial coordination requirements for distributed computations. A spatial coordination middleware has been implemented for satisfying spatial coordination requirements of systems implemented using the Actor model of concurrent computation. Our approach abstracts spatial requirements of concurrent computations and provides key programming primitives for specifying these requirements. We have also implemented a number of higher level spatial coordination primitives which can be translated into the basic primitives. Spatial requirements can be specified using these primitives and then the runtime system converts them into a constraint satisfaction problem and satisfies them. Our approach reduces the programming complexity and provides a middleware which separates spatial requirements from functional code and enables the application programmer to change spatial requirements at runtime without effecting application's functionality. We have identified some of the high level primitives and provided a mechanism to develop high level primitives on top of the basic primitives. This thesis presents the rationale, design, implementation, and evaluation of spatial coordination. By comparing programs written with and without our spatial coordination primitives, we show how spatial coordination enables a programmer to specify spatial requirements declaratively and simplify the programming task. Experimental results demonstrate the performance of the approach, as the number of constraints increases