Refined Environment Classifiers

We give a Natural Deduction formulation of an adaptation of Gödel’s functional (Dialectica) interpretation to the extraction of (more) efficient programs from (classical) proofs. We adapt Jørgensen’s formulation of pure Dialectica translation by eliminating his “Contraction Lemma” and allowing free variables in the extracted terms (which is more suitable in a Natural Deduction setting). We also adapt Berger’s uniform existential and universal quantifiers to the Dialectica-extraction context. The use of such quantifiers without computational meaning permits the identification and isolation of contraction formulas which would otherwise be redundantly included in the pure-Dialectica extracted terms. In the end we sketch the possible combination of our refinement of Gödel’s Dialectica interpretation with its adaptation to the extraction of bounds due to Kohlenbach into a light monotone functional interpretation.KeywordsProgram extraction from (classical) proofsComplexity of extracted programsBerger’s uniform quantifiersGödel’s Functional interpretationProof-Carrying CodeProof Mining

Region-based memory management is an alternative to standard tracing garbage collection that makes operation such as memory deallocation explicit but verifiably safe. In this article, we present a new compiler intermediate language, called the Capability Language (CL), that supports region-based memory management and enjoys a provably safe type systems. Unlike previous region-based type system, region lifetimes need not be lexically scoped, and yet the language may be checked for safety without complex analyses. Therefore, our type system may be deployed in settings such as extensible operating systems where both the performance and safety of untrusted code is important. The central novelty of the language is the use of static capabilities to specify the permissibility of various operations, such as memory access and deallocation. In order to ensure capabilities are relinquished properly, the type system tracks aliasing information using a form of bounded quantification. Moreover, unlike previous work on region-based type systems, the proof of soundness of our type system is relatively simple, employing only standard syntactic techniques. In order to show how our language may be used in practice, we show how to translate a variant of Tofte and Talpin's high-level type-and-effects system for region-based memory management into our language. When combined with known region inference algorithms, this translation provides a way to compile source-level languages to CL.

An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.

Automating memory management improves both resource safety and programmer productivity. One approach, region-based memory management [9] (RBMM), applies compile-time reasoning to identify points in a program at which memory can be safely reclaimed. The main advantage of RBMM over traditional garbage collection (GC) is the avoidance of expensive runtime analysis, which makes reclaiming memory much faster. On the other hand, GC requires no static analysis, and, operating at runtime, can have significantly more accurate information about object lifetimes. In this paper we propose a hybrid system that seeks to combine the advantages of both methods while avoiding the overheads that previous hybrid systems incurred. Our system can also reclaim array segments whose elements are no longer reachable.

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

In this paper, we prove the safety of integrating region-based memory management and Cheney-style copying garbage collection. The safety property relies on a refinement of the region typing rules that forbids dangling pointers during evaluation.To accommodate the triggering of garbage collection at any step in the evaluation process, we base our type-safety result for the region-based system on a small-step contextual semantics and show that whenever a well-typed expression reduces to another expression, possibly by deallocating a region, then no dangling pointer is introduced. Because there are no dangling pointers in the initial heap, no dangling pointers appear during evaluation.Although in principle, the refinement of the region typing rules leads to less flexibility and can cause worse memory behavior than when dangling pointers are permitted, experiments show that, for a range of benchmark programs, the refinement has little effect on overall memory behavior.

Cyclone is a type-safe programming language derived from C. The primary design goal of Cyclone is to let programmers control data representation and memory management without sacrificing type-safety. In this paper, we focus on the region-based memory management of Cyclone and its static typing discipline. The design incorporates several advancements, including support for region subtyping and a coherent integration with stack allocation and a garbage collector. To support separate compilation, Cyclone requires programmers to write some explicit region annotations, but a combination of default annotations, local type inference, and a novel treatment of region effects reduces this burden. As a result, we integrate C idioms in a region-based framework. In our experience, porting legacy C to Cyclone has required altering about 8% of the code; of the changes, only 6% (of the 8%) were region annotations.

We will discuss the methodology and accuracy of the Echo Nest Musical Fingerprint (ENMFP), an open-source fingerprint code generator and query server that works on music files. We define fingerprinting as matching an arbitrary audio signal to its underlying song in a 10 million song database. 1. MUSIC FINGERPRINTING “Fingerprinting” of audio files [1] [3] is becoming a necessary feature for any large scale music understanding service or system. Online music stores want to resolve existing user catalog against their cloud storage to save bandwidth. Music indexing tools want to adjust poor metadata. Music listeners want to remove duplicates and see necessary context next to their audio. The Echo Nest Corporation recently implemented a fingerprint scheme that is based on portions of their Analyze product and will be released as an open source service for any use– with the intended goal to catalog every music file on any node of the internet. We define fingerprinting as converting an unknown audio query Q, represented as a series of time domain samples to a match of a known song S which is represented as an ID, metadata (artist, title, etc) and list of matching tracks T . Each T is itself an audio file of any bitrate, compression type, volume or quality. Our intended goal is to match on files, not in-the-air recordings such as Shazam [3]. 2. FEATURES AND CODE GENERATION Our “code generator” is a modified version of the hosted service Analyze [2], which computes segmentation, timbre and chroma features, beat and section and other audioderived attributes from any audio file. The code generator itself only computes the segmentation and chroma features in Analyze, which results in a d = 12 vector C for each discovered segment in Q. On average, a pop song will emit roughly 4 segments per second of audio, but the rate widely varies with the song’s complexity and speed. This segment-aligned chroma vector C is then vector quantized Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. c © 2010 International Society for Music Information Retrieval. to a 10-bit code c. (The VQ code table was trained on 10,000 random songs from a large collection.) Successive chains of three c are hashed together to a 30bit key by simply shifting c0 to bitspace 30-21, c1 to 2011, c2 to 10-1. Each code is stored alongside a time offset value t, which is the position of the start of the segment and is quantized to 32ms increments. 3. QUERIES IN PRACTICE We treat each code as a term in a document in an inverted index. The track ID from T is stored as the document ID with each hashed 30-bit key stored as a term (with term offset stored natively as t.) This allows fast lookup of a series of query hashes in the inverted index. The underlying data store has a lookup table keyed on each of the possible 30bit keys (2) with list of track IDs associated to each key. A multi-code query (in practice, we expect roughly 30 seconds of audio as Q, which would be on average 120 hash keys) simply returns the track ID with the most matches of each code term. If the query server returns more than one strong match, we compute a histogram of all time offset t differences per matching key. We then use the total of the top two histogram buckets to inform the “true score.” This allows us to ensure that the codes occur in order even if Q is from a different section of the song and thus has a different absolute time offset.

UML is an industry standard abstraction language, which encompasses a wide range of structural and behavioural diagrams. It reduces the gap between the functional requirements and system design phase of the software development process. Automated code generation from UML reduces development time and enables effective communication between managers and developers. Our tool exploits the one to one mapping between structural diagrams and object oriented code. Behavioural diagrams like activity, sequence and state diagrams are merged into a single structural diagram for code generation. The UML design diagrams are converted to platform independent textual representation, XML Metadata Interchange (XMI). The XMI parser generates an abstract syntax tree (AST). A template matching algorithm is used to convert the AST to the Java code. The tool also enables code generation in a phased manner to implement and verify the features of each diagram. The evaluation of the tool is shown using a case study and the results are compared with existing open source code generation tools. The generated OO code is functional and executable.

Software clone detection techniques identify fragments of code that share some level of syntactic similarity. In this study, we investigate security-sensitive clone clusters: clusters of syntactically similar fragments of code that are protected by some privileges. From a security perspective, security-sensitive clone clusters can help reason about the implemented security model: given syntactically similar fragments of code, it is expected that they are protected by similar privileges. We hypothesize that clones that violate this assumption, defined as security-discordant clones, are likely to reveal weaknesses and flaws in access control models. In order to characterize security-discordant clones, we investigated two of the largest and most popular open-source PHP applications: Joomla! and Moodle, with sizes ranging from hundred thousands to more than a million lines of code. Investigation of security-discordant clone clusters in these systems revealed several previously undocumented, recurring, and application-independent security weaknesses. Moreover, security-discordant clones also revealed four, previously unreported, security flaws. Results also show how these flaws were revealed through the investigation of as little as 2% of the code base. Distribution of weaknesses and flaws between the two systems is investigated and discussed. Potential extensions to this exploratory work are also presented.

Meta-programming languages provide infrastructure to generate and execute object programs at run-time. In a typed setting, they contain a modal type constructor which classifies object code. These code types generally come in two flavors: closed and open. Closed code expressions can be invoked at run-time, but the computations over them are more rigid, and typically produce less efficient residual object programs. Open code provides better inlining and partial evaluation of object programs, but once constructed, expressions of this type cannot in general be evaluated.Recent work in this area has focused on combining the two notions into a sound system. We present a novel way to achieve this. It is based on adding the notion of names from the work on Nominal Logic and FreshML to the λ -calculus of proof terms for the necessity fragment of modal logic S4. The resulting language provides a more fine-grained control over free variables of object programs when compared to the existing languages for meta-programming. In addition, this approach lends itself well to addition of intensional code analysis, i.e. ability of meta programs to inspect and destruct object programs at run-time in a type-safe manner, which we also undertake.

Generalized index search tree (GiST) greatly simplifies data access methods development. Important parts like query processing, failure recovery, memory management are implemented in generic code, so access method developer has to implement only specifics of the desired algorithm. But this generality comes with a significant cost of fitting a method for GiST API. In this paper we present number of tweaks to the R-tree implementation inside PostgreSQL GiST framework and analyze possible ways of GiST API advancements.

We describe the foundation of the metaprogramming language, Mœbius, which supports the generation of polymorphic code and, more importantly, the analysis of polymorphic code via pattern matching. Mœbius has two main ingredients: 1) we exploit contextual modal types to describe open code together with the context in which it is meaningful. In Mœbius, open code can depend on type and term variables (level 0) whose values are supplied at a later stage, as well as code variables (level 1) that stand for code templates supplied at a later stage. This leads to a multi-level modal lambda-calculus that supports System-F style polymorphism and forms the basis for polymorphic code generation. 2) we extend the multi-level modal lambda-calculus to support pattern matching on code. As pattern matching on polymorphic code may refine polymorphic type variables, we extend our type-theoretic foundation to generate and track typing constraints that arise. We also give an operational semantics and prove type preservation. Our multi-level modal foundation for Mœbius provides the appropriate abstractions for both generating and pattern matching on open code without committing to a concrete representation of variable binding and contexts. Hence, our work is a step towards building a general type-theoretic foundation for multi-staged metaprogramming that, on the one hand, enforces strong type guarantees and, on the other hand, makes it easy to generate and manipulate code. This will allow us to exploit the full potential of metaprogramming without sacrificing the reliability of and trust in the code we are producing and running.

To promote the newly emerging OSLC (Open Services for Lifecycle Collaboration) tool interoperability standard, an open source code generator is developed that allows for the specification of OSLC-compliant tool interfaces, and from which almost complete Java code of the interface can be generated. The software takes a model-based development approach to tool interoperability, with the aim of providing modeling support for the complete development cycle of a tool interface. The software targets both OSLC developers, as well as the interoperability research community, with proven capabilities to be extended to support their corresponding needs.