A Bigraphical Vending Machine as a Webservice: From Specification and Analysis to Implementation using the Bigraph Toolkit Suite

A bigraph-driven vending machine is implemented. The application is realized as a Spring-based webservice. Actions can be initiated by REST endpoints. The system follows a rule-based architecture, where possible operations are grounded on a rule set. Bigraphical Reactive Systems are used for the specification and execution. The actual state of the application is a bigraph stored in a database, which can be viewed and altered directly in the database. A history of states is kept - the application can be transferred to any prior state. The application can be updated or extended by merely changing the bigraphical database model.:First Part: A system of a vending machine is specified and analyzed using BDSL. This concerns the static and dynamic aspects of the system. Second Part: The analysis results are re-used for the implementation using Bigraph Framework. The application is realized as a webservice that is built using the Spring framework.Ein bigraph-gesteuerter Verkaufsautomat wird implementiert. Die Anwendung ist als Spring-basierter Webservice realisiert. Aktionen können über REST-Endpunkte initiiert werden. Das System folgt einer regelbasierten Architektur, bei der die möglichen Operationen auf einem Regelsatz beruhen. Für die Spezifikation und Ausführung werden Bigraphical Reactive Systems verwendet. Der aktuelle Zustand der Anwendung ist ein in einer Datenbank gespeicherter Bigraph, der direkt in der Datenbank eingesehen und verändert werden kann. Es wird eine Historie der Zustände geführt - die Anwendung kann in einen beliebigen früheren Zustand überführt werden. Die Anwendung kann aktualisiert oder erweitert werden, indem lediglich das bigraphische Datenbankmodell geändert wird.:First Part: A system of a vending machine is specified and analyzed using BDSL. This concerns the static and dynamic aspects of the system. Second Part: The analysis results are re-used for the implementation using Bigraph Framework. The application is realized as a webservice that is built using the Spring framework

DANIEL: Towards Automated Bug Discovery By Black Box Test Case Generation & Recommendation

Finding and documenting bugs in software systems is an essential component of the software development process. A bug is defined as a series of steps that produces behavior which differs from the software specification and requirements. Finding steps to produce such behavior requires expert knowledge of the possible operations of the software in development as well as intuition and creativity. This thesis proposes the Directed Action Node Input Execution Language (DANIEL), a language that represents test cases as directed graphs, where each node represents an action, and possible input arguments for each action are represented along the incoming directed edges. With this representation, it is possible to form a union of all recorded test cases, making a combined directed graph which represents all of the paths of interaction with the developing software. This thesis demonstrates how DANIEL can generate prioritized test cases for a web form application, while also preserving workflow context. Using a graph built on Selenium test cases, we evaluate a random walk, a weighted walk, and model-weighted walks integrating logistic regression and XGBoost to compute the relevant probabilities. We find that the weighted walk discovers the most bugs while the model-weighted walk provides the most meaningful coverage

Model-driven interoperability: engineering heterogeneous IoT systems

Interoperability remains a significant burden to the developers of Internet of Things systems. This is because resources and APIs are dynamically composed; they are highly heterogeneous in terms of their underlying communication technologies, protocols and data formats, and interoperability tools remain limited to enforcing standards-based approaches. In this paper, we propose model-based engineering methods to reduce the development effort towards ensuring that complex software systems interoperate with one another. Lightweight interoperability models can be specified in order to monitor and test the execution of running software so that interoperability problems can be quickly identified, and solutions put in place. A graphical model editor and testing tool are also presented to highlight how a visual model improves upon textual specifications. We show using case-studies from the FIWARE Future Internet Service domain that the software framework can support non-expert developers to address interoperability challenges

A Linear Logic approach to RESTful web service modelling and composition

A thesis submitted to the University of Bedfordshire in partial fulfilment of the requirements for the degree of Doctor of PhilosophyRESTful Web Services are gaining increasing attention from both the service and the Web communities. The rising number of services being implemented and made available on the Web is creating a demand for modelling techniques that can abstract REST design from the implementation in order better to specify, analyse and implement large-scale RESTful Web systems. It can also help by providing suitable RESTful Web Service composition methods which can reduce costs by effi ciently re-using the large number of services that are already available and by exploiting existing services for complex business purposes. This research considers RESTful Web Services as state transition systems and proposes a novel Linear Logic based approach, the first of its kind, for both the modelling and the composition of RESTful Web Services. The thesis demonstrates the capabilities of resource-sensitive Linear Logic for modelling five key REST constraints and proposes a two-stage approach to service composition involving Linear Logic theorem proving and proof-as-process based on the π-calculus. Whereas previous approaches have focused on each aspect of the composition of RESTful Web Services individually (e.g. execution or high-level modelling), this work bridges the gap between abstract formal modelling and application-level execution in an efficient and effective way. The approach not only ensures the completeness and correctness of the resulting composed services but also produces their process models naturally, providing the possibility to translate them into executable business languages. Furthermore, the research encodes the proposed modelling and composition method into the Coq proof assistant, which enables both the Linear Logic theorem proving and the π-calculus extraction to be conducted semi-automatically. The feasibility and versatility studies performed in two disparate user scenarios (shopping and biomedical service composition) show that the proposed method provides a good level of scalability when the numbers of services and resources grow

Logic -\u3e Proof -\u3e REST

REST is a common architecture for networked applications. Applications that adhere to the REST constraints enjoy significant scaling advantages over other architectures. But REST is not a panacea for the task of building correct software. Algebraic models of computation, particularly CSP, prove useful to describe the composition of applications using REST. CSP enables us to describe and verify the behavior of RESTful systems. The descriptions of each component can be used independently to verify that a system behaves as expected. This thesis demonstrates and develops CSP methodology to verify the behavior of RESTful applications

Using BIP to reinforce correctness of resource-constrained IoT applications

International audienceIoT applications have either a sense-only or a sense-compute-actuate goal and they implement a capability to process and respond to multiple (external) events while performing computations. Existing IoT operating systems provide a versatile execution environment that adheres to the limitations of the interconnected resource-constrained devices. To reduce the development effort, applications are often built on top of RESTful web services, which can be shared and reused. However, the asynchronous communication between remote nodes is prone to event scheduling delays, which cannot be predicted and taken into account while programming the application. Moreover, to avoid long delays in message processing and communication due to packet collisions, the data transmission frequencies between the system's nodes have to carefully chosen. In general, even when appropriate debugging tools and simulators are available, it is still a hard challenge to guarantee the required functional and non-functional properties at the application and system levels. To this end, we focus on IoT applications for the Contiki OS and we introduce a model-based rigorous analysis approach using the BIP component framework. At the application level, we verify qualitative properties regarding service responsiveness, whereas at the system level we can validate qualitative and quantitative properties using statistical model checking. We present results for an application scenario running on a distributed system infrastructure with nodes executing the Contiki OS