Dynamic inference of static types for ruby

An, Jong-hoon; Chaudhuri, Avik; Foster, Jeffrey S.; Hicks, Michael

doi:10.1145/1926385.1926437

Cited by 39 publications

(22 citation statements)

References 21 publications

(14 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We also found that Hummingbird's performance overhead ranges from 19% to 469%, which is much better than prior approaches [18,27], and that caching is essential to achieving this performance. For one Rails app, we ran type checking on many prior versions, and we found a total of six type errors that had been introduced and then later fixed.…”

Section: Introductionmentioning

confidence: 67%

“…We think these are reasonable results for an early prototype that we have not spent much effort optimizing. Moreover, across all apps, the ratios are significantly better than prior systems that mix static and dynamic typing for Ruby [18,27], which report orders of magnitude slowdowns.…”

Section: Dynamic Typesmentioning

confidence: 83%

“…Finally, RubyDust [18] implements type inference for Ruby at run time. RubyDust works by wrapping objects to annotate them with type variables.…”

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Just-in-time static type checking for dynamic languages

Ren

Foster

2016

SIGPLAN Not.

Self Cite

View full text Add to dashboard Cite

Dynamic languages such as Ruby, Python, and JavaScript have many compelling benefits, but the lack of static types means subtle errors can remain latent in code for a long time. While many researchers have developed various systems to bring some of the benefits of static types to dynamic languages, prior approaches have trouble dealing with metaprogramming, which generates code as the program executes. In this paper, we propose Hummingbird, a new system that uses a novel technique, just-in-time static type checking, to type check Ruby code even in the presence of metaprogramming. In Hummingbird, method type signatures are gathered dynamically at run-time, as those methods are created. When a method is called, Hummingbird statically type checks the method body against current type signatures. Thus, Hummingbird provides thorough static checks on a per-method basis, while also allowing arbitrarily complex metaprogramming. For performance, Hummingbird memoizes the static type checking pass, invalidating cached checks only if necessary. We formalize Hummingbird using a core, Ruby-like language and prove it sound. To evaluate Hummingbird, we applied it to six apps, including three that use Ruby on Rails, a powerful framework that relies heavily on metaprogramming. We found that all apps typecheck successfully using Hummingbird, and that Hummingbird's performance overhead is reasonable. We applied Hummingbird to earlier versions of one Rails app and found several type errors that had been introduced and then fixed. Lastly, we demonstrate using Hummingbird in Rails development mode to typecheck an app as live updates are applied to it.

show abstract

Section: Introductionmentioning

confidence: 67%

Section: Dynamic Typesmentioning

confidence: 83%

See 1 more Smart Citation

Just-in-time static type checking for dynamic languages

Ren

Foster

2016

SIGPLAN Not.

Self Cite

View full text Add to dashboard Cite

show abstract

“…RubyDust [1] uses a constraint-based analysis at run-time to infer type information. In contrast to the simple type contracts we infer for RDL, RubyDust types are structural, e.g., RubyDust can infer that a method accepts any object with a to s method, something that led to one category of imprecision in contract inference in Figure 11.…”

Section: Related Workmentioning

confidence: 99%

Contracts for domain-specific languages in Ruby

2014

Self Cite

View full text Add to dashboard Cite

This paper concerns object-oriented embedded DSLs, which are popular in the Ruby community but have received little attention in the research literature. Ruby DSLs implement language keywords as implicit method calls to self; language structure is enforced by adjusting which object is bound to self in different scopes. While Ruby DSLs are powerful and elegant, they suffer from a lack of specification. In this paper, we introduce contracts for Ruby DSLs, which allow us to attribute blame appropriately when there are inconsistencies between an implementation and client. We formalize Ruby DSL contract checking in DSL, a core calculus that uses premethods with instance evaluation to enforce contracts. We then describe RDL, an implementation of Ruby DSL contracts. Finally, we present two tools that automatically infer RDL contracts: TypeInfer infers simple, type-like contracts based on observed method calls, and DSLInfer infers DSL keyword scopes and nesting by generating and testing candidate DSL usages based on initial examples. The type contracts generated by TypeInfer work well enough, though they are limited in precision by the small number of tests, while DSLInfer finds almost all DSL structure. Our goal is to help users understand a DSL from example programs.

show abstract

“…Recent innovations include: a type analysis that relies on an abstract domain that is highly tuned for JavaScript [24]; various static type inference algorithms [9,15] and hybrid type inference algorithms [8], including those that prevent access to undefined fields [33], enable program optimizations [21,27], or are suitable for IDEs [28]; static analyses to secure the Web [17][18][19]; alias analyses for JavaScript [23,30] and Python [16]; an analysis to support JavaScript refactoring [13]; and analysis frameworks for dynamic languages [7,26]. All these techniques are orthogonal to type refinement.…”

Section: Related Workmentioning

confidence: 99%

Type refinement for static analysis of JavaScript

Kashyap

Sarracino

Wagner

et al. 2013

Proceedings of the 9th Symposium on Dynamic Languages

View full text Add to dashboard Cite

Static analysis of JavaScript has proven useful for a variety of purposes, including optimization, error checking, security auditing, program refactoring, and more. We propose a technique called type refinement that can improve the precision of such static analyses for JavaScript without any discernible performance impact. Refinement is a known technique that uses the conditions in branch guards to refine the analysis information propagated along each branch path. The key insight of this paper is to recognize that JavaScript semantics include many implicit conditional checks on types, and that performing type refinement on these implicit checks provides significant benefit for analysis precision.To demonstrate the effectiveness of type refinement, we implement a static analysis tool for reporting potential type-errors in JavaScript programs. We provide an extensive empirical evaluation of type refinement using a benchmark suite containing a variety of JavaScript application domains, ranging from the standard performance benchmark suites (Sunspider and Octane), to open-source JavaScript applications, to machine-generated JavaScript via Emscripten. We show that type refinement can significantly improve analysis precision by up to 86% without affecting the performance of the analysis.

show abstract

Dynamic inference of static types for ruby

Cited by 39 publications

References 21 publications

Just-in-time static type checking for dynamic languages

Just-in-time static type checking for dynamic languages

Contracts for domain-specific languages in Ruby

Type refinement for static analysis of JavaScript

Contact Info

Product

Resources

About