Environment generation for validating event-driven software using model checking

Graphical user interfaces (GUIs) are ubiquitous in real-world software and a notorious source of bugs that are difficult to catch through software testing. Model checking has been used to prove the absence of certain kinds of bugs, but model checking works on an abstract model of the GUI application, which might be inconsistent with its implementation. We present a library for developing directly verified, state-dependent GUI applications in the dependently typed programming language Agda. In the library, the type of a GUI's controller depends on a specification of the GUI itself, statically enforcing consistency between them. Arbitrary properties can be defined and proved in terms of user interactions and state transitions. Our library connects to a custom-built Haskell back-end for declarative vector-based GUI elements. Compared to an earlier version of our library built on an existing imperative GUI framework, the more declarative back-end supports simpler definitions and proofs. As a practical application of our library to a safety-critical domain, we present a case study developed in cooperation with the Medical University of Vienna. The case study implements a healthcare process for prescribing anticoagulants, which is highly error-prone when followed manually. Our implementation generates GUIs from an abstract description of a data-aware business process, making our approach easy to reuse and adapt to other safety-critical processes. We prove medically relevant safety properties about the executable GUI application, such as that given certain inputs, certain states must or must not be reached.

The paper provides the design of a distributed test system for testing distributed GUI (Graphical User Interface) applications. The distributed GUI application that is considered allows multiple operators or users to interact with a distributed system in parallel. The distributed GUI application allows the use of existing GUI test frameworks for local test execution and offers additional services of coordination and synchronization among the deployed GUI test frameworks, test verdict arbitration, and debugging support, all of which are needed to deal with the concurrent nature of the system under test. In addition, the paper offers a test specification method for test cases that is based on the semantic model of a concurrent event flow graph. This method allows the automatic test case execution on top of the suggested distributed test system. The overall approach allows the extension of testing of single GUI application systems towards testing of distributed GUI application systems by preserving investments in test automation for single GUI testing.

Although there have been major achievements in verified software, work on verifying graphical user interfaces (GUI) applications is underdeveloped relative to their ubiquity and societal importance. In this paper, we present a library for the development of verified, state-dependent GUI applications in the dependently typed programming language Agda. The library uses Agda’s expressive type system to ensure that the GUI, its controller, and the underlying model are all consistent, significantly reducing the scope for GUI-related bugs. We provide a way to specify and prove correctness properties of GUI applications in terms of user interactions and state transitions. Critically, GUI applications and correctness properties are not restricted to finite state machines and may involve the execution of arbitrary interactive programs. Additionally, the library connects to a standard, imperative GUI framework, enabling the development of native GUI applications with expected features, such as concurrency. We present applications of our library to building GUI applications to manage healthcare processes. The correctness properties we consider are the following: (1) That a state can only be reached by passing through a particular intermediate state, for example, that a particular treatment can only be reached after having conducted an X-Ray. (2) That one eventually reaches a particular state, for example, that one eventually decides on a treatment. The specification of such properties is defined in terms of a GUI application simulator, which simulates all possible sequences of interactions carried out by the user.

Modeling and simulation (M&S) is increasingly used in drug development to characterize pharmacokinetic-pharmacodynamic (PKPD) relationships and support various efforts such as target feasibility assessment, molecule selection, human PK projection, and preclinical and clinical dose and schedule determination. While model development typically require mathematical modeling expertise, model exploration and simulations could in many cases be performed by scientists in various disciplines to support the design, analysis and interpretation of experimental studies. To this end, we have developed a versatile graphical user interface (GUI) application to enable easy use of any model constructed in SimBiology® to execute various common PKPD analyses. The MATLAB®-based GUI application, called gPKPDSim, has a single screen interface and provides functionalities including simulation, data fitting (parameter estimation), population simulation (exploring the impact of parameter variability on the outputs of interest), and non-compartmental PK analysis. Further, gPKPDSim is a user-friendly tool with capabilities including interactive visualization, exporting of results and generation of presentation-ready figures. gPKPDSim was designed primarily for use in preclinical and translational drug development, although broader applications exist. gPKPDSim is a MATLAB®-based open-source application and is publicly available to download from MATLAB® Central™. We illustrate the use and features of gPKPDSim using multiple PKPD models to demonstrate the wide applications of this tool in pharmaceutical sciences. Overall, gPKPDSim provides an integrated, multi-purpose user-friendly GUI application to enable efficient use of PKPD models by scientists from various disciplines, regardless of their modeling expertise.

<div><p class="Els-history-head">The development of rocketry and rocket payload technology is very rapid in the industrial era 4.0. Rockets are usually used as dynamic sensors or carriers for specific missions for sensing and retrieving data from space for meteorological, military, etc. This article aims to design, realize and test a Rocket Payload Monitoring System Based on an Inertial Measurement Unit (IMU) Sensor to monitor the condition of the payload movement behavior. Rocket Payload is a substance carried in a Payload Test Rocket (RUM) in the form of a cylindrical payload. This research focuses on designing a Graphical User Interface (GUI) application to display data in real-time. The type of research used is Research and Development (R&D) with a prototyping development model. The results obtained in the form of Rocket Payload Design and GUI design can be concluded that the GUI application can visualize all sensor and camera data in real-time.</p></div>

This paper introduces an automated grader for Java programs called GUI_Grader that allows students a degree of flexibility in graphical user interface (GUI) design. GUI_Grader allows students to build multi-window Java applications, choose among alternative GUI components, and decide how to order, position and label components. This enables students to practice some aspects of designing their own GUI applications while still providing automated grading `based on a single test plan. The data-driven approach helps to maintain consistency between test plans and program specifications. Testing GUI_Grader on Java assignments from both a first-year and an upper-year course confirms the feasibility of the approach.

Web and Event-driven applications (EDS) is a class of applications that is quickly becoming ubiquitous. All EDS take sequences of events (e.g., messages, mouse-clicks) as input, change their state, and produce an output (e.g., events, system calls, text messages), where as in web, user session data gathered as users operate web applications can be considered as input, change their state, and produce an output. Examples include web applications, graphical user interfaces (GUIs), network protocols, device drivers, and embedded applications. Testing for functional correctness of EDS such as stand-alone GUI and web-based applications is critical to many organizations. These applications share several important characteristics. Both are particularly challenging to test because users can invoke many different sequences of events that affect application behavior. Hence here a novel model is provided to rank the test cases based on their prioritization.

Verifying the functional behavior of graphical user interface (GUI) applications is essential for reducing post-release issues. In practice, a developer/tester performs this verification by executing a sequence of GUI actions and then witnessing the expected behavior on the GUI screen. An automated witness generator facilitates the verification process. However, creating an unambiguous and monitorable specification for the correct behavior and then generating the correct GUI actions to trigger that behavior is challenging. In this study, we propose FARLEAD2, an automated witness generator that uses unambiguous, monitorable, and easy-to-read staged test scenarios (STSs) to specify expected behavior. FARLEAD2 maximizes its effectiveness and performance using generalized experienced replay (GER) to exploit the experience gathered from previously witnessed scenarios on new, unwitnessed test scenarios. To the best of our knowledge, STS and GER are novel improvements to GUI testing. Our evaluation of Android GUI applications shows that FARLEAD2 effectively generates a witness 95.7 times out of 100 and does it in 520 seconds, on average, indicating that FARLEAD2 is approximately 65 percent faster and 6.3 percent more effective than its best predecessor.

Module Checking

Common design patterns in application development mix implementation of business logic with application logic, user interface logic, or with data access logic. This leads to results that business logic is not well maintainable and reusable, the application code should be reimplemented each time the business logic has changed or the same business logic should be reimplemented for each application. This paper presents a new rule-based approach to Web-based IS development making possible separating the business logic from interface or application logic when creating complex Web-based software applications. The technology consists of 2 main parts: the application server Xstone for creating 3-layered systems and the RqlGandalf rule solver. The middleware server Xstone connects to Oracle, PostgreSQL databases and the Rql rule system. The Rql rule system is targeted for defining and using business logic rules. The Rql rule system is able to read data from a SQL database: it can call the application server and import/convert SQL-given data into its own knowledge base. The presented rule-based system development technology is implemented for the Linux platform as open source software.

The R environment provides a natural platform for developing new statistical methods due to the mathematical expressiveness of the language, the large number of existing libraries, and the active developer community. One drawback to R, however, is the learning curve; programming is a deterrent to non-technical users, who typically prefer graphical user interfaces (GUIs) to command line environments. Thus, while statisticians develop new methods in R, practitioners are often behind in terms of the statistical techniques they use as they rely on GUI applications. Meta-analysis is an instructive example; cutting-edge meta-analysis methods are often ignored by the overwhelming majority of practitioners, in part because they have no easy way of applying them. This paper proposes a strategy to close the gap between the statistical state-of-the-science and what is applied in practice. We present open-source meta-analysis software that uses R as the underlying statistical engine, and Python for the GUI. We present a framework that allows methodologists to implement new methods in R that are then automatically integrated into the GUI for use by end-users, so long as the programmer conforms to our interface. Such an approach allows an intuitive interface for non-technical users while leveraging the latest advanced statistical methods implemented by methodologists.

Dynamic Software Product Line (DSPL) Engineering has gained interest through its promise of being able to unify software adaptation whereby software adaptation can be realised at compile time and runtime. While previous work has enabled program logic adaptation by the use of language extensions and platform support, little attention has been placed on Graphical User Interface (GUI) variability. Different design patterns including the Model View Controller are commonly used in GUI implementation, with GUI documents being used for declaring the GUI. To handle dynamic GUI variability currently, the developer needs to implement GUI refinements using multiple techniques. This paper proposes a solution for dealing with GUI document variability, statically and dynamically, in a unified way. In our approach, we currently use a compile time method for producing GUI variants, and code transformations to handle these variants within the application at runtime. To avoid GUI duplicates, only GUI variants that are unique, and related to a valid product configuration, are produced. To validate our approach, we implemented tool support to enable this for Android based applications.

High Performance Computing (HPC) applications commonly use Message Passing Interface (MPI) to scale complex workloads on distributed memory architectures, while Graphical User Interface (GUI) is the primary basis for pre-processing and post-processing. Containerization enables portability and reproducibility for applications. Docker is a widely used containerization platform but cannot be easily adopted in secure HPC environments due to the need for root privileges to run Docker containers and the ensuing security issues, as well as the lack of native support for Message Passing Interface (MPI) and HPC workload managers. In addition to offering portability and reproducibility to scientific computing, Singularity and Sarus are container runtimes that enable containers to run on HPC with user credentials by removing security concerns and allowing reuse of Docker containers without any changes. This work presents approaches to creating and running MPI and GUI applications in an isolated container environment on HPC in the cloud. We provide performance evaluation of application containers transformed from Docker to Singularity and Sarus in the context of native on HPC in the cloud.

기존의 대부분의 퍼지 제어기는 퍼지 추론시 [0, 1]의 소속도를 갖는 퍼지 소속함수들의 실수연산으로 인하여 연산수행 속도가 저하되는 문제를 가지고 있다 따라서 본 논문에서는 실수연산으로 인하여 야기되었던 속도 저하문제를 해결하기 위한 새로운 퍼지연산 기법으로 실수 값을 갖는 퍼지 소속함수 값을 정수형 격자(pixel)에 매핑시켜 정수형 퍼지 소속 함수값만을 가지고 연산함으로써 기존의 퍼지제어기에 비해 매우 빠른 연산을 수행 할 수 있는 고속 퍼지제어기를 제안한다. 또한 퍼지 제어시스템 설계시에 퍼지 입출력 변수들의 퍼지항들을 입력시킬 수 있는 GUI(Graphic User Interface)를 제공하여 소속함수의 수정 및 퍼지 값 입력시 사용자에게 보다 편리한 환경을 제공한다 In fuzzy inferencing, most of conventional fuzzy controllers have problems of speed down in floating point operations of fuzzy membership functions in (0,1) as compared with integer operations. Therefore, in this paper, we propose a high-speed fuzzy controller with only integer operations. In this, for fast fuzzy computations, we use a scan line conversion algorithm to convert lines of each fuzzy linguistic term to the set of the closest integer pixels. We also implement a GUI (Graphic User Interface) application program for the convenient environments to modify and input fuzzy membership functions.

The state explosion problem is the central challenge in automatic verification using model checking. In many cases, representing the state space of a system as a lattice is an effective way of representing very large state spaces. The partial order of the lattice represents an information ordering between states, which can be used as an abstraction mechanism to reduce the computational cost of model checking. The 'traditional' logical framework for model checking finite state systems has serious deficiencies when applied to information-ordered state spaces. Interpreting the truth of a proposition about a state or a sequence of states in a four-valved truth domain is better from a modelling point of view, allowing us to reason about partial and contradictory information. Moreover, it overcomes a serious technical difficulty encountered when using a two-valued truth domain. The paper defines the syntax and semantics of a four-valued temporal logic that can be used for specifying properties of a computer system. This framework has particular relevance to hardware verification. It could be used by several model checking algorithms. Symbolic trajectory evaluation (STE) [33] is a model checking algorithm that has had success in model checking using information orderings to reduce computational cost. Previous work used a two-valued logic though, which limited the expressiveness of the logic. Using the framework presented here, the STE algorithm can be generalised, and then applied in practice to a richer logic. Some examples are shown in this paper. Keywords:Symbolic trajectory evaluation, quarternary logic, model checking, temporal logic, bilattices.