Jinn

Lee, Byeongcheol; Wiedermann, Ben; Hirzel, Martin; Grimm, Robert; McKinley, Kathryn S.

doi:10.1145/1809028.1806601

Cited by 11 publications

(1 citation statement)

References 20 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Such errors can be hard to find. Automatic detection of such errors is sometimes possible, but requires an addition tool like Jinn (Furr and Foster, 2005;Lee et al, 2010). Listing (Python) 10.7: PRS loses type safety as a sensor node sends a double, and the server stores a string.…”

Section: Type Safetymentioning

confidence: 99%

Orchestrating the Internet of Things with Task-Oriented Programming

Lubbers

2023

View full text Add to dashboard Cite

The development of reliable software for the internet of things (IoT) is difficult because IoT systems are dynamic, interactive, distributed, collaborative, multi-tiered, and multitasking in nature. The complexity is increased further by semantic friction that arises through different hardware and software characteristics between tiers. Many computers that operate in IoT systems are edge devices that interact with the environment using sensors and actuators. Edge devices are often powered by low-cost microcontrollers designed for embedded applications. They have little memory, unhurried processors, and are slow in communication but are also small and energy efficient. Task-oriented programming (TOP) can cope with the challenges of IoT programming. In TOP, the main building blocks are tasks, an abstract representation of work. During execution, the current value of the task is observable, and other tasks can act upon it. Collaboration patterns can be modelled by combining and transforming tasks into compound tasks. Programming edge devices benefits from TOP as well, but running such a system within the limitations of resource-constrained microcontrollers is not straightforward. This dissertation demonstrates how to include edge devices in TOP systems using domain-specific languages (DSLs). With these techniques, all tiers and their interoperation of an IoT system are specified in a single high-level source, language, paradigm, high abstraction level, and type system. First, I present advanced DSL embedding techniques. Then mTask is shown, a TOP DSL for IoT edge devices, embedded in iTask. Tasks are constructed and compiled at run time in order to allow tasks to be tailored to the current work requirements. The task is then sent to the device for interpretation. A device is programmed once with a lightweight domain-specific OS to be used in an mTask system. This OS executes tasks in an energy-efficient way and automates all communications and data sharing. All aspects of the mTask system are shown: example applications, language design, implementation details, integration with iTask, and green computing facilities such as automatic sleeping. Finally, tierless IoT programming is compared to traditional tiered programming. In tierless programming frameworks, the size of the code and the number of required programming languages is reduced significantly. By using a single paradigm and a system-wide type system, tierless programming reduces problems such as semantic friction; maintainability and robustness issues; and interoperation safety.

show abstract

Section: Type Safetymentioning

confidence: 99%

Orchestrating the Internet of Things with Task-Oriented Programming

Lubbers

2023

View full text Add to dashboard Cite

show abstract

Debugging mixed-environment programs with Blink

Lee

Hirzel

Grimm

et al. 2014

Softw. Pract. Exper.

Self Cite

View full text Add to dashboard Cite

Programmers build large-scale systems with multiple languages to leverage legacy code and languages best suited to their problems. For instance, the same program may use Java for ease of programming and C to interface with the operating system. These programs pose significant debugging challenges, because programmers need to understand and control code across languages, which often execute in different environments. Unfortunately, traditional multilingual debuggers require a single execution environment. This paper presents a novel composition approach to building portable mixed-environment debuggers, in which an intermediate agent interposes on language transitions, controlling and reusing single-environment debuggers. We implement debugger composition in Blink, a debugger for Java, C, and the Jeannie programming language. We show that Blink is (i) simple: it requires modest amounts of new code; (ii) portable: it supports multiple Java virtual machines, C compilers, operating systems, and component debuggers; and (iii) powerful: composition eases debugging, while supporting new mixed-language expression evaluation and Java native interface bug diagnostics. To demonstrate the generality of interposition, we build prototypes and demonstrate debugger language transitions with C for five of six other languages (Caml, Common Lisp, C#, Perl 5, Python, and Ruby) without modifications to their debuggers. Using real-world case studies, we show that diagnosing language interface errors require prior single-environment debuggers to restart execution multiple times, whereas Blink directly diagnoses them with one execution.Traditional debuggers are not much help with mixed-language programs because they are limited to a single execution environment. For example, native programs and their debuggers (e.g., the gdb debugger for C, C++, and Fortran) require language implementations to use the same application binary interface (ABI). The ABI is machine dependent and thus precludes portable execution environments for managed languages, such as Java, C#, JavaScript, and Python. For portability, managed languages rely on virtual machine (VM) execution, using interpretation, just-in-time compilation, and garbage collection. They abstract over internal code, the stack, and data representations. Debuggers for managed languages, such as the standard Java debugger jdb, operate on VM abstractions, for example, through the Java Debug Wire Protocol (JDWP), but do not understand native code. Current mixed-language debuggers are limited to XDI and dbx, which support Java and C within a single JVM [6,7], and the Visual Studio debugger, which supports managed and native code in the Common Language Runtime (CLR) [8]. While these debuggers understand all environments, they are behemoths that are generally not portable. The challenge when building a mixed-environment debugger is that each environment has different representations; managed debuggers operate at the level of bytecodes and objects, whereas native debuggers deal with machine instructio...

show abstract

Detecting Cross-language Memory Management Issues in Rust

Wang

Sun³

et al. 2022

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Jinn

Cited by 11 publications

References 20 publications

Orchestrating the Internet of Things with Task-Oriented Programming

Orchestrating the Internet of Things with Task-Oriented Programming

Debugging mixed-environment programs with Blink

Detecting Cross-language Memory Management Issues in Rust

Contact Info

Product

Resources

About