52 research outputs found
Transient Typechecks are (Almost) Free
Transient gradual typing imposes run-time type tests that typically cause a linear slowdown in
programs’ performance. This performance impact discourages the use of type annotations because
adding types to a program makes the program slower. A virtual machine can employ standard justin-time optimizations to reduce the overhead of transient checks to near zero. These optimizations
can give gradually-typed languages performance comparable to state-of-the-art dynamic languages,
so programmers can add types to their code without affecting their programs’ performance
Reference Mutability for DOT
Reference mutability is a type-based technique for controlling mutation that has been thoroughly studied in Java. We explore how reference mutability interacts with the features of Scala by adding it to the Dependent Object Types (DOT) calculus. Our extension shows how reference mutability can be encoded using existing Scala features such as path-dependent, intersection, and union types. We prove type soundness and the immutability guarantee provided by our calculus
Automated Repair of Resource Leaks in Android Applications
Resource leaks -- a program does not release resources it previously acquired
-- are a common kind of bug in Android applications. Even with the help of
existing techniques to automatically detect leaks, writing a leak-free program
remains tricky. One of the reasons is Android's event-driven programming model,
which complicates the understanding of an application's overall control flow.
In this paper, we present PlumbDroid: a technique to automatically detect and
fix resource leaks in Android applications. PlumbDroid uses static analysis to
find execution traces that may leak a resource. The information built for
detection also undergirds automatically building a fix -- consisting of release
operations performed at appropriate locations -- that removes the leak and does
not otherwise affect the application's usage of the resource. An empirical
evaluation on resource leaks from the DroidLeaks curated collection
demonstrates that PlumbDroid's approach is scalable and produces correct fixes
for a variety of resource leak bugs. This indicates it can provide valuable
support to enhance the quality of Android applications in practice
A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Pearl)
Idris' Effects library demonstrates how to embed resource dependent algebraic effect handlers into a dependently typed host language, providing run-time and compile-time based reasoning on type-level resources. Building upon this work, Resources is a framework for realising Embedded Domain Specific Languages (EDSLs) with type systems that contain domain specific substructural properties. Differing from Effects, Resources allows a language’s substructural properties to be encoded within type-level resources that are associated with language variables. Such an association allows for multiple effect instances to be reasoned about autonomically and without explicit type-level declaration. Type-level predicates are used as proof that the language’s substructural properties hold. Several exemplar EDSLs are presented that illustrates our framework’s operation and how dependent types provide correctness-by-construction guarantees that substructural properties of written programs hold
LMS-Verify: abstraction without regret for verified systems programming
Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. High-level languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.
Recent years have seen a surge in staging and generative programming: the key idea is to use high-level languages and their abstraction power as glorified macro systems to compose code fragments in first-order, potentially domain-specific, intermediate languages, from which fast C can be emitted. But what about security? Since the end result is still C code, the safety guarantees of the high-level host language are lost.
In this paper, we extend this generative approach to emit ACSL specifications along with C code. We demonstrate that staging achieves ``abstraction without regret'' for verification: we show how high-level programming models, in particular higher-order composable contracts from dynamic languages, can be used at generation time to compose and generate first-order specifications that can be statically checked by existing tools. We also show how type classes can automatically attach invariants to data types, reducing the need for repetitive manual annotations.
We evaluate our system on several case studies that varyingly exercise verification of memory safety, overflow safety, and functional correctness. We feature an HTTP parser that is (1) fast (2) high-level: implemented using staged parser combinators (3) secure: with verified memory safety. This result is significant, as input parsing is a key attack vector, and vulnerabilities related to HTTP parsing have been documented in all widely-used web servers.</jats:p
- …