TypeEvalPy: A Micro-benchmarking Framework for Python Type Inference Tools

Hindley and Milner's type system, in its purest form, allows what one might call full type inference. Even when a program contains no explicit type information, its very structure gives rise to a conjunction of type equations (or, more generally, to a constraint) whose resolution allows reconstructing the type of every variable and of every sub-expression. Actual programming languages based on this type system, such as Standard ML, Objective Caml, and Haskell, do allow users to provide explicit type information via optional type annotations. Yet, this extra information does not make type inference any easier: it simply gives rise to extra equations, leading to a more specific constraint.There are extensions of Hindley and Milner's type system where full type inference becomes undecidable or intractable. Then, it is common to require explicit type information, via mandatory type annotations. Polymorphic recursion is a simple and well-known instance of this phenomenon. This talk presents two more elaborate instances, commonly known as arbitrary-rank polymorphism and generalized algebraic data types.In both cases, type inference is made tractable thanks to mandatory type annotations. There is a twist, though: these required annotations are often numerous and redundant. So, it seems desirable to make them optional again, and to set up a distinct mechanism to guess some of the elided annotations. This mechanism, referred to as elaboration, can be heuristic. It must be predictable. In the two cases considered in this talk, it is a form of local type inference.This approach leads to a so-called stratified type inference system, where type information is propagated first in a local, ad hoc manner during elaboration, then in a possibly nonlocal, but well-specified manner during constraint solving. This appears to be one of the less displeasing ways of describing type inference systems that are able to exploit optional type annotations to infer better (or different) types.

Types are a good starting point for various software reengineering tasks. Unfortunately, programs requiring reengineering most desperately are written in languages without an adequate type system (such as COBOL). To solve this problem, we propose a method of automated type inference for these languages. The main ingredients are that if variables are compared using some relational operator their types must be the same; likewise if an expression is assigned to a variable, the type of the expression must be a subtype of that of the variable. We present the formal type system and inference rules for this approach, show their effect on various real life COBOL fragments, describe the implementation of our ideas in a prototype type inference tool for COBOL, and discuss a number of applications.

Deriving a complete type inference for Hindley–Milner and vector sizes using expansion

Gradual typing lets programmers evolve their dynamically typed programs by gradually adding explicit type annotations, which confer benefits like improved performance and fewer run-time failures. However, we argue that such evolution often requires a giant leap, and that type inference can offer a crucial missing step. If omitted type annotations are interpreted as unknown types, rather than the dynamic type, then static types can often be inferred, thereby removing unnecessary assumptions of the dynamic type. The remaining assumptions of the dynamic type may then be removed by either reasoning outside the static type system, or restructuring the code. We present a type inference algorithm that can improve the performance of existing gradually typed programs without introducing any new run-time failures. To account for dynamic typing, types that flow in to an unknown type are treated in a fundamentally different manner than types that flow out. Furthermore, in the interests of backward-compatibility, an escape analysis is conducted to decide which types are safe to infer. We have implemented our algorithm for ActionScript, and evaluated it on the SunSpider and V8 benchmark suites. We demonstrate that our algorithm can improve the performance of unannotated programs as well as recover most of the type annotations in annotated programs.

Type feedback and type inference are two common methods used to optimize dynamic languages such as JavaScript. Each of these methods has its own strengths and weaknesses, and we propose that each can benefit from the other if combined in the right way. We explore the interdependency between these two methods and propose two novel ways to combine them in order to significantly increase their aggregate benefit and decrease their aggregate overhead. In our proposed strategy, an initial type inference pass is applied that can reduce type feedback overhead by enabling more intelligent placement of profiling hooks. This initial type inference pass is novel in the literature. After profiling, a final type inference pass uses the type information from profiling to generate efficient code. While this second pass is not novel, we significantly improve its effectiveness in a novel way by feeding the type inference pass information about the function signature, i.e., the types of the function's arguments for aspecific function invocation. Our results show significant speedups when using these low-overhead strategies, ranging from 1.2x to 4x over an implementation that does not perform type feedback or type inference based optimizations. Our experiments are carried out across a wide range of traditional benchmarks and realistic web applications. The results also show an average reduction of 23.5% in the size of the profiled data for these benchmarks.

Type information is a crucial information to support object-oriented reengineering. In a dynamically typed language like Smalltalk standard static type inference is a complex and heavily computational task. In this paper, we report how we use message passing control and compiler extension to support dynamic inference type in Smalltalk.

The lack of static type information is one of the main obstacles to program comprehension in dynamically-typed languages. While static type inference algorithms try to remedy this problem, they usually suffer from the problem of false positives or false negatives. In order to partially compensate for the lack of static type information, a common practice in dynamically-typed languages is to name or annotate method arguments in such a way that they reveal their expected type, e.g., aString, anInt, or string: String. Recent studies confirmed that these type annotations are indeed frequently used by developers in dynamically-typed languages. We propose a lightweight heuristic that uses these hints from method argument names to augment the performance of a static type inference algorithm. The evaluation through a proof-of-concept prototype implemented in Pharo Smalltalk shows that the augmented algorithm outperforms the basic algorithm, and correctly infers types for 81% more method arguments.

A system of constructor classes

LHD 2.0: A text mining approach to typing entities in knowledge graphs

Inference attacks mean that a user infers (or tries to infer) the result of an unauthorized query execution using only authorized queries to the user. We say that a query q is secure against inference attacks by a user u if there exists no database instance for which u can infer the result of q. The security problem against inference attacks has been formalized under a model of object-oriented databases called method schemas. It is known that the technique of type inference is useful for deciding the security. However, the relationship of type inferability and decidability of the security has not been examined.

10 - Defining Facets

Intermittent Hypoxic Exposure (IHE) may attenuate negative affects of rapid ascent to high altitudes. Currently, there is little data to quantitatively or systematically determine the potential benefit IHE may provide to unacclimatized people living near sea level (SL) upon rapid ascent to high altitudes. Physical and intellectual demands may be intense during the first few days of high altitude exposure if people are expected to perform well immediately upon ascent to high altitude (e.g. military personnel making tactical decisions or mountaineers, safeguarding the lives of expeditionary members). PURPOSE: To determine the effect of IHE on cognitive performance decrement upon subsequent exposure to 4300 m. METHODS: On day 1, 12 informed healthy female and male volunteers (M ±SEM: 20.2 ±0.3 yr) were exposed to a simulated altitude of 4300 m while resting in a normobaric hypoxic chamber for 4 hours. During d2-4, subjects remained at 3600 m for 3h (IHE; n=6) or at SL as control subjects (SL; n=6). On d5 all subjects repeated exposure to 4300 m for 4h. Volunteers completed the Automated Neuropsychological Assessment Metrics (ANAM, a battery of cognitive skills tests) 5-7 times during familiarization and once again at the beginning of and once after each altitude exposure. Test modules known to be sensitive to altitude were utilized for the ANAM battery. Included modules are the Stanford Sleepiness Scale; Mood Scale-R; Simple Reaction Time; Running Memory Continuous Performance; Logical Reasoning-Symbolic; Code Substitution Learning: Immediate and Delayed Memory; Matching to Sample; and 4-Choice Reaction Time. RESULTS: Differences were found only for the 4-Choice Reaction Time module. There was no MRT difference between groups prior to altitude exposure on d1 or d5. All subjects increased MRT (IHE: 618.0±14.3 to 678.3±22.9 ms; P=0.023; SL: 639.5±28.2 to 713.4±36.5 ms; P=0.038) after 4h of altitude exposure on d1. SL controls increased MRT on d5 (576.3±5.1 to 682.7±20.8 ms; P=0.003) while IHE subjects had no change (567.2±29.0 to 596.5±25.9 ms; P=0.348). CONCLUSION: IHE for 1d at 4300m for 4h and 3d at 3600 m ameliorates the negative alterations in MRT seen after a subsequent 4h exposure to 4300 m. Supported by: The Borgenicht Program; Jeffress Memorial Trust; and The Foundation for Aging Studies and Exercise Science Research

Atomicity is a fundamental correctness property in multithreaded programs. A method is atomic if, for every execution, there is an equivalent serial execution in which the actions of the method are not interleaved with actions of other threads. Atomic methods are amenable to sequential reasoning, which significantly facilitates subsequent analysis and verification. This article presents a type system for specifying and verifying the atomicity of methods in multithreaded Java programs using a synthesis of Lipton's theory of reduction and type systems for race detection. The type system supports guarded, write-guarded, and unguarded fields, as well as thread-local data, parameterized classes and methods, and protected locks. We also present an algorithm for verifying atomicity via type inference. We have applied our type checker and type inference tools to a number of commonly used Java library classes and programs. These tools were able to verify the vast majority of methods in these benchmarks as atomic, indicating that atomicity is a widespread methodology for multithreaded programming. In addition, reported atomicity violations revealed some subtle errors in the synchronization disciplines of these programs.

Healthcare organizations face unknown changes in the coming decades. How healthcare reform unfolds will depend on a unique collaboration between government and industry. On one hand, healthcare is a social good and benefits from a strong government hand in regulation. The Patient Protection and Affordable Care Act (PPACA) starts to address healthcare’s problems, but is only one step of a series of coming changes. On the other hand, healthcare also faces the issues typical of any free market industry, including zero-sum competition, focus on episodes rather than the full cycle of care, comingled care models, and so on. This article summarizes two free-market frameworks for healthcare reform by Christensen and Porter. These provide a straw man with which to consider the direction and extent of industry change beyond PPACA. This comparison suggests healthcare will need additional business model innovation and new forms of competitive structure. Building on this analysis, we suggest seven dimensions along which healthcare leaders could prepare their organizations now in order to thrive through and beyond PPACA. These provide a conceptual foundation for further scholarly and practitioner research into the roles healthcare management will play in industry reform.

We study the type system introduced by Boyapati and Rinard in their paper “A Parameterized Type System for Race-Free Java Programs” and try to infer the type annotations (“lock types”) needed by their type checker to show that a program is free of race conditions. Boyapati and Rinard automatically generate some of these annotations using default types and static inference of lock types for local variables, but in practice, the programmer still needs to annotate on the order of 1 in every 25 lines of code. We use run-time techniques, based on the lockset algorithm, in conjunction with some static analysis to automatically infer most or all of the annotations.