Providing students with hands-on experience in kernel programming within a real-world operating system is highly beneficial in an Operating Systems (OS) course for teaching core operating system concepts and developing practical skills. However, accessing suitable devices for such hands-on experimentation poses significant challenges. Traditional solutions involve hosting virtual machines on cloud platforms, which are expensive and do not scale well with increasing student numbers. Additionally, many students' personal devices, such as Macs or iPads, have limited support for running Linux, creating further barriers. In this paper, we introduce KernelVM, a novel cost-effective platform that offers students a Linux virtual machine with full superuser access and pre-configured kernel programming toolchains. KernelVM is accessible via any modern browser on any device. It performs all computations locally within the user's browser, thus eliminating cloud computing costs. KernelVM provides a robust learning environment by incorporating interactive virtual hardware components and an automatic evaluation system, supporting a wide range of tasks, including multi-threaded cryptographic kernel modules and Linux drivers for hardware interaction. We detail the design of KernelVM, and describe our experiences incorporating it for the first time into an OS course with 159 undergraduate students. We found that KernelVM was instrumental in improving the quality and efficiency of hands-on learning experiences, with students reporting increased satisfaction and engagement due to the immediate feedback and the ability to experiment in a risk-free environment. Our experience suggests that KernelVM not only addresses the logistical challenges of kernel programming education, but it helps foster a highly interactive and engaging learning experience.

Open source hardware such as RISC-V has been gaining substantial momentum. Recently, they have begun to embrace Google’s Android operating system to leverage its software ecosystem. Despite the encouraging progress, a challenging issue arises: a majority of Android applications are written in native languages and need to be recompiled to target new hardware platforms. Unfortunately, this recompilation process is not scalable because of the explosion of new hardware platforms. To address this issue, we present WasmAndroid, a high-performance cross-platform runtime for native Android applications. With WasmAndroid, developers can compile their source code to WebAssembly, an efficient and portable bytecode format that can be executed everywhere without additional reconfiguration. Developers can also transpile existing application binaries to WebAssembly when source code is not available. WebAssembly’s language model is very different from other common languages. This mismatch leads to many unique implementation challenges. In this article, we provide workable solutions and conduct a thorough system evaluation. We show that WasmAndroid provides acceptable performance to execute native applications in a cross-platform manner.

Open-source hardware such as RISC-V has been gaining substantial momentum. Recently, they have begun to embrace Google's Android operating system to leverage its software ecosystem. Despite the encouraging progress, a challenging issue arises: a majority of Android applications are written in native languages and need to be recompiled to target new hardware platforms. Unfortunately, this recompilation process is not scalable because of the explosion of new hardware platforms. To address this issue, we present WasmAndroid, a high-performance cross-platform runtime for native programming languages on Android. WasmAndroid only requires developers to compile their source code to WebAssembly, an efficient and portable bytecode format that can be executed everywhere without additional reconfiguration. WasmAndroid can also trans-pile existing application binaries to WebAssembly when source code is not available. WebAssembly's language model is very different from C/C++ and this mismatch leads to many unique implementation challenges. In this paper, we provide workable solutions and conduct a preliminary system evaluation. We show that WasmAndroid provides acceptable performance to execute native applications in a cross-platform manner.

WebAssembly is gaining wide adoption in browser-centric applications thanks to its high portability and security. More recently, researchers start exploring the potential of WebAssembly in non-web environments, particularly in IoT and Edge computing. A key challenge of WebAssembly is performance gap with native code: applications compiled to WebAssembly run slower by an average of 45% as reported by previous benchmark. The main causes of the slowdown are two-folded. Firstly, conventional WebAssembly runtimes translate WebAssembly instructions to native machine code using just-in-time compilers, which do not apply complex code optimization. Secondly, system calls from WebAssembly applications have to be proxy-ed by runtimes in order to reach operating systems, which incurs a significant performance overhead. To address these issues, we present Wasmachine, an OS aiming to efficiently and securely execute WebAssembly applications in IoT and edge devices with constrained resources. Wasmachine achieves efficient execution by compiling WebAssembly ahead of time to native binary and executing it in kernel mode for zero-cost system calls. Even when executing in kernel space, Wasmachine stays secure by exploiting various language features of WebAssembly to deliver software-based fault isolation. We implement the Was-machine prototype in the memory-safe programming language Rust and conduct a performance evaluation. Our results show that WebAssembly applications running in Wasmachine are up to 21% faster than their native counterparts in Linux.

Spreadsheets are one of the most widely used data management tools. Although intuitive and easy to use, they suffer from a number of issues. Numerous publications indicate that most spreadsheets contain errors and that spreadsheet-based data shadow systems lead to problems such as the “spreadmart dilemma” creating inconsistent views on organizational data. In this paper, we describe “ The Semantic Spreadsheet ”, a new data model for a semantically accurate spreadsheet system. Unlike the existing data models, the described model is a presentation independent data model based on the Resource Description Framework (RDF) that avoids the spreadmart dilemma by providing a semantically sound data structure. We describe the set-theoretic and relational algebraic operations on the data model and show how it can improve data integrity.

Web browsers are becoming a de-facto universal computing platform. Recently, research communities are attempting to enhance browsers with the capacity to run applications written in general programming languages. Existing approaches mainly compile source codes to browsers' native instruction sets JavaScript or WebAssembly. However, they usually fall short in practice because browsers lack operating system abstractions (e.g., thread and filesystem) and many programs would require extensive modifications. This paper presents BroswerVM, a new approach to run unmodified and complete operating systems and applications inside browsers. BrowserVM is a WebAssembly-based virtual machine hypervisor. BrowserVM efficiently conducts processor emulation through dynamic binary translation. It also provides performant hardware emulation for hard disks, graphics cards and network adapters. Implementing BrowserVM is challenging because of the unique characteristics of WebAssembly: semantic gap with low-level CPU assembly and high initialization overhead. We detail the methods to deal with these challenges and conduct a performance benchmark on BrowserVM. Our results indicate that though slower than native hypervisors, BroswerVM provides acceptable performance to execute existing applications that are not compute-intensive.

Navigating source code, an activity common in software development, is time consuming and in need of improvement. We present CodeGazer, a prototype for source code navigation using eye gaze for common navigation functions. These functions include actions such as "Go to Definition'' and "Find All Usages'' of an identifier, navigate to files and methods, move back and forth between visited points in code and scrolling. We present user study results showing that many users liked and even preferred the gaze-based navigation, in particular the "Go to Definition'' function. Gaze-based navigation is also holding up well in completion time when compared to traditional methods. We discuss how eye gaze can be integrated into traditional mouse & keyboard applications in order to make "look up'' tasks more natural.

When a user needs to reposition the cursor during text editing, this is often done using the mouse. For experienced typists especially, the switch between keyboard and mouse can slow down the keyboard editing workflow considerably. To address this we propose ReType, a new gaze-assisted positioning technique combining keyboard with gaze input based on a new 'patching' metaphor. ReType allows users to perform some common editing operations while keeping their hands on the keyboard. We present the result of two studies. A free-use study indicated that ReType enhances the user experience of text editing. ReType was liked by many participants, regardless of their typing skills. A comparative user study showed that ReType is able to match or even beat the speed of mouse-based interaction for small text edits. We conclude that the gaze-augmented user interface can make common interactions more fluent, especially for professional keyboard users.

Electronic paper (e-paper) is a display technology that aims to imitate conventional paper. Currently most e-paper applications on handheld devices are restricted to digital book readers. Few studies explore the potential of e-paper on input oriented applications. In this paper, we introduce a novel e-paper application PaperWork, which allows users to offload their commonly used office applications from a PC to an e-paper device remotely. There are considerable challenges when building a system for a resource constrained e-paper device which we will highlight in this work. In addition to presenting a new e-paper system we also conduct a usability study of this system.

The text processing tool LATEX has prevailed as a standard in many fields of exact sciences; it is evident that LATEX is likely to be here to stay. From that perspective, it is important to explore what are the best possible ways to support the author in efficiently editing documents. There have been several approaches that provide graphical editing support for LATEX. We argue that a true WYSIWYG (What You See Is What You Get) approach is a justified requirement for future systems and we present here the first cloud-based true WYSIWYG editor. This allows the author to edit the document in its print form directly in a web-based PDF viewer. Building such a system creates unique challenges compared to existing approaches. We identify these challenges and name workable solutions. We also provide a usability evaluation of the new system. In short our finding is that editing LATEX directly in the PDF view is possible for a wide range of edits and valuable for many major user groups and use cases; hence it is a fair requirement for future top-of-the-line LATEX editors.

Program analysis is the process of gathering deeper insights about a source code and analysing them to resolve software problems of arbitrary complexity. The key challenge in program analysis is to keep it fast, precise and straightforward. This research focuses on three key objectives to achieve an efficient program analysis: (i) expressive data representation, (ii) optimised data structure and (iii) fast data processing mechanisms. State of the art technologies such as Resource Description Framework (RDF) as data representation format, triplestores as the storage & processing layer, and datalog to represent program analysis rules are considered in our research. diagram(BDD) to be embedded in the triplestore. Additionally, an ontology is being designed to standardise the definitions of concepts and representation of the knowledge in the program analysis domain.

Semi-stream join algorithms join a continuous stream with a large disk-based relation. While there are efficient semi-stream equijoins for exact matches in the joined data, there are currently no semi-stream similarity joins for approximate matches. The existing similarity join algorithms work either offline (on datasets that are fully known) or on several streams (using a join window), and are less suitable for applications where continuous, immediate and complete similarity join results are required. To address this gap we propose S3J, the first semi-stream similarity join algorithm. To utilize disk and CPU optimally, S3J combines a disk-intensive queue-based semi-stream join approach with a CPU-intensive similarity matching algorithm. The similarity matching algorithm is based on tries to minimize the memory footprint. Moreover, it supports parallel execution to utilize modern multicore CPUs. We provide a cost model for S3J and evaluate its performance empirically.

OAuth has become a widespread authorization protocol to allow inter-enterprise sharing of user preferences and data: a Consumer that wants access to a user's protected resources held by a Service Provider can use OAuth to ask for the user's authorization for access to these resources. However, it can be tedious for a Consumer to use OAuth as a way to organize user identities, since doing so requires supporting all Service Providers that the Consumer would recognize as users' "identity providers". Each Service Provider added requires extra work, at the very least, registration at that Service Provider. Different Service Providers may differ slightly in the API they offer, their authentication/authorization process or even their supported version of OAuth. The use of different OAuth Service Providers also creates privacy, security and integration problems. Therefore OAuth is an ideal candidate for Software as a Service, while posing interesting challenges at the same time. We use conceptual modelling to derive new high-level models and provide an analysis of the solution space. We address the aforementioned problems by introducing a trusted intermediary -- OAuth Hub -- into this relationship and contrast it with a variant, OAuth Proxy. Instead of having to support and control different OAuth providers, Consumers can use OAuth Hub as a single trusted intermediary to take care of managing and controlling how authentication is done and what data is shared. OAuth Hub eases development and integration issues by providing a consolidated API for a range of services. We describe how a trusted intermediary such as OAuth Hub can fit into the overall OAuth architecture and discuss how it can satisfy demands on security, reliability and usability.

Whilst Model Based Testing (MBT) is an improvement over manual test specification, the leap from it to MBT can be hard. Only recently MBT tools for Web applications have emerged that can recover models from existing manually specified test cases. However, there are further requirements for supporting both MBT and manually specified tests. First, we need support for the generation of test initialization procedures. Also, we want to identify areas of the system that are not testable due to defects. We present Form Tester, a new MBT tool addressing these limitations. An evaluation with real Web applications shows that Form Tester helps to reduce the time spent on developing test cases.

Eye gaze tracking is a promising input method which is gradually finding its way into the mainstream. An obvious question to arise is whether it can be used for point-and-click tasks, as an alternative for mouse or touch. Pointing with gaze is both fast and natural, although its accuracy is limited. There are still technical challenges with gaze tracking, as well as inherent physiological limitations. Furthermore, providing an alternative to clicking is challenging.

MOTIVATION: Free energy nearest-neighbour (NN) thermodynamics is widely used in DNA biochemistry, ranging from the calculation of melting temperatures to the prediction of secondary structures. Methods to calculate NN parameters require the knowledge of total sequence entropies and enthalpies, which are not always available. RESULTS: Here, we implement and test a new melting temperature optimization method where we obtain the NN parameters directly from the temperatures. In this way, we bypass the constraints imposed by total sequence entropies and enthalpies. This enabled us to calculate the missing NN entropies and enthalpies for some published datasets, including salt-dependent parameters. Also this allowed us to combine 281 sequences from different types of melting temperature data for which we derived a new set of NN parameters, which have a smaller uncertainty and an improved predictive power. AVAILABILITY AND IMPLEMENTATION: C++ source code and compiled binaries for several Linux distributions are available from https://sites.google.com/site/geraldweberufmg/vargibbs and from OpenSuse build service at https://build.opensuse.org/package/show/home:drgweber/VarGibbs. The software package contains scripts and data files to reproduce all results presented here.

Recently, a number of semi-stream join algorithms have been published. The typical system setup for these consists of one fast stream input that has to be joined with a disk-based relation R. These semi-stream join approaches typically perform the join with a limited main memory partition assigned to them, which is generally not large enough to hold the whole relation R. We propose a caching approach that can be used as a front-stage for different semi-stream join algorithms, resulting in significant performance gains for common applications. We analyze our approach in the context of a seminal semi-stream join, MESHJOIN (Mesh Join), and provide a cost model for the resulting semi-stream join algorithm, which we call CMESHJOIN (Cached Mesh Join). The algorithm takes advantage of skewed distributions; this article presents results for Zipfian distributions of the type that appears in many applications.

The Kaczmarz method is an iterative method for solving large systems of equations that projects iterates orthogonally onto the solution space of each equation. In contrast to direct methods such as Gaussian elimination or QR-factorization, this algorithm is efficient for problems with sparse matrices, as they appear in constraint-based user interface (UI) layout specifications. However, the Kaczmarz method as described in the literature has its limitations: it considers only equality constraints and does not support soft constraints, which makes it inapplicable to the UI layout problem. In this paper we extend the Kaczmarz method for solving specifications containing soft constraints, using the prioritized IIS detection algorithm. Furthermore, the performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that these methods offer improvements in performance over standard methods like Matlab's LINPROG, a well-known efficient linear programming solver.

Layout managers are used to control the placement of widgets in graphical user interfaces (GUIs). Constraint-based layout managers are among the most powerful. However, they are also more complex and their layouts are prone to problems such as over-constrained specifications and widget overlap. This poses challenges for GUI builder tools, which ideally should address these issues automatically. We present a new GUI builderthe Auckland Layout Editor (ALE)that addresses these challenges by enabling GUI designers to specify constraint-based layouts using simple, mouse-based operations. We give a detailed description of ALE's edit operations, which do not require direct constraint editing. ALE guarantees that all edit operations lead to sound specifications, ensuring solvable and non-overlapping layouts. To achieve that, we present a new algorithm that automatically generates the constraints necessary to keep a layout non-overlapping. Furthermore, we discuss how our innovations can be combined with manual constraint editing in a sound way. Finally, to aid designers in creating layouts with good resize behavior, we propose a novel automatic layout preview. This displays the layout at its minimum and in an enlarged size, which allows visualizing potential resize issues directly. All these features permit GUI developers to focus more on the overall UI design.

SUMMARY: The mesoscopic statistical physics models, known generically as Peyrard-Bishop (PB) models, have found many applications for the study of oligonucleotide properties. Unfortunately, PB models have not reached a wider non-specialized audience for the lack of freely available software implementations. Here we present an extensible C++ implementation of four variants of the PB model, which allows the user to calculate melting temperatures from tested model parameters. Even for a non-specialist, it should be straightforward to change these parameters to reflect different experimental environments or different types of oligonucleotides. For users with some proficiency in C++ programming, it should be feasible to extend the code to other PB models owing to the generic programming implementation adopted for TfReg. Pre-calculated parameters are included that allow the immediate calculation of melting temperatures and thermal equivalence indexes for DNA and RNA. AVAILABILITY: C++ source code and compiled binaries for several Linux distributions are available from https://sites.google.com/site/geraldweberufmg/tfreg and from OpenSuse build service at http://build.opensuse.org. CONTACT: [email protected] SUPPLEMENTARY INFORMATION: Supplementary data are available at Bioinformatics online.

Linear relaxation is a common method for solving linear problems as they occur in science and engineering. In contrast to direct methods such as Gauss-elimination or QR-factorization, linear relaxation is inherently efficient for problems with sparse matrices as they are often encountered, for instance, in the application domain of constraint-based UI layout. However, the linear relaxation method as described in the literature has its limitations: it works only with square matrices and does not support soft constraints, which makes it inapplicable to the UI layout problem. In this paper we extend linear relaxation to non-square matrices and soft constraints, and identify pivot assignment as the major issue to overcome in this process. We propose two algorithms for pivot assignment: random pivot assignment, and a more complex deterministic pivot assignment algorithm. Compared to the standard pivot assignment, which selects the elements on the diagonal of the problem matrix as pivot elements, these algorithms make the solving process more robust and make it possible to solve non-square matrices. Furthermore, we propose two algorithms for solving specifications containing soft constraints: constraint insertion and constraint removal. With these algorithms, it is possible to prioritize constraints. That is, if there are conflicting constraints in a specification as is commonly the case for UI layout, only the constraints with lower priority are violated to resolve the conflict. The performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that our best linear relaxation algorithm performs significantly better than that of LP-Solve, which is a well-known efficient linear programming solver, and QR-decomposition.

This paper presents an investigation into the migration from standard centralized control to modular, distributed control for a fruit packing machine. Along with control that was developed using IEC 61499, a simulation model of the plant was developed in parallel. Both were deployed to hardware to demonstrate seamless testing using a single underlying architecture. A visualization of the simulation model was created to view the simulation live. Comparisons between IEC 61499 and traditional techniques were outlined during the implementation. Difficulties in applying commonly used traditional design elements to the IEC 61499 standard were addressed.

We comment on the flexibility profiles calculated by Zeng et al., and show that these profiles do not represent the local flexibility of the DNA molecule. If one takes into account the physics of elasticity, the averaged flexibility profile show an additional peak which is missed in the original calculation. We show that it is not possible to calculate the flexibility of a 6-mer using tetranucleotide elastic constants, the shortest sequence is a 7-mer. For 6-mers, dinucleotide or trinucleotide parameters are needed. We present calculations for dinucleotide flexibility parameters and show that the same additional peak is present for both 7-mers and 6-mers.

Single sign-on (SSO) protocols allow one person to use the same login credentials for several organizations. Enterprises face increasing competitive pressure to position themselves with regard to SSO, yet the ramifications of a move to SSO are not fully understood. In this paper we discuss OpenID, a relatively new SSO protocol that is gaining traction on the web. We apply enterprise application modelling techniques to OpenID in order to obtain well-founded decision aids for enterprises: we show how published modelling approaches can be used to analyse risks in OpenID, and show that these can identify security problems with common OpenID practice. Finally, we propose analysis principles that condense important general insights of authentication modelling.

To fulfill the increasing demand of business for the latest information, current data integration approaches are moving towards real-time updates. One important element in real-time data integration is the join of a continuous incoming data stream with a disk-based relation. In this paper we investigate a stream-based join algorithm, called mesh join (MESHJOIN), and propose an improved version called reduced MESHJOIN (R-MESHJOIN). Both algorithms tune the memory, allocating parts of the memory to key components. In MESHJOIN there is a dependency between the size of partitions in an internal queue for the stream data and the number of iterations required to bring the disk-based relation into memory. This dependency hampers the optimal distribution of memory among the join components. In particular the size of the disk-buffer varies with the size of the disk-based relation which is unnecessary. On the other hand the R-MESHJOIN algorithm removes this dependency. This enables an optimal distribution of available memory among the join components. In R-MESHJOIN a change in the size of the disk-based relation does not affect the size of the disk-buffer. An experimental study is conducted in order to validate the arguments.

Load testing of Web applications can be specified by simulating realistic user behavior with stochastic form-oriented analysis models. Stochastic models have advantages over load test models that simply play back recorded session data: they are easier to specify and achieve a higher coverage of the different operational paths. There are challenges when specifying load tests such as the generation of form parameters and the recognition of pages returned by the system. We propose how these challenges can be overcome by adding additional specifications to a form-oriented model. Furthermore, we discuss several workload models and explain why some commonly used workload models are in fact unrealistic and produce misleading results. The stochastic form-oriented load testing approach can be generalized to deal with other submit-response systems such as those consisting of Web services.

GUIDs are globally unique identifiers that can be generated independently. They play an important role in many distributed systems. However, compared to most local identifiers, they are relatively large (16 bytes). We discuss techniques that can make the use of GUIDs more efficient, so that they become more viable as a ubiquitous solution for large distributed databases and similar applications relying on artificial identifiers. The proposed techniques include canonical GUIDs for primitive values and a compression scheme for timestamp-based GUIDs. The techniques have been implemented and can be used in different programming languages. Furthermore, general aspects and potential problems of GUIDs as defined in the RFC 4122 are discussed.

Journal Article Modelling form-based interfaces with bipartite state machines Get access D. Draheim, D. Draheim * a Institute of Computer Science, Freie Universität Berlin, Takustr. 9, 14195 Berlin, Germany * Corresponding author. Tel.: +4930 838 75144; fax: +4930 838 75109. E-mail addresses:[email protected] (D. Draheim), [email protected] (G. Weber). Search for other works by this author on: Oxford Academic Google Scholar G. Weber G. Weber b Department of Computer Science, The University of Auckland, Private Bag 92019, Auckland 1020, New Zealand Search for other works by this author on: Oxford Academic Google Scholar Interacting with Computers, Volume 17, Issue 2, March 2005, Pages 207–228, https://doi.org/10.1016/j.intcom.2005.01.002 Published: 01 March 2005 Article history Received: 06 July 2004 Revision received: 06 September 2004 Accepted: 12 January 2005 Published: 01 March 2005