Combining Static and Dynamic Typing in Ruby

Abstract

Many popular scripting languages such as Ruby, Python, and Perl are

dynamically typed. Dynamic typing provides many advantages such as

terse, flexible code and the ability to use highly dynamic language

constructs, such as an eval method that evaluates a string as

program text. However these dynamic features have traditionally

obstructed static analyses leaving the programmer without the benefits

of static typing, including early error detection and the

documentation provided by type annotations.

In this dissertation, we present Diamondback Ruby (DRuby), a tool that

blends static and dynamic typing for Ruby. DRuby provides a type

language that is rich enough to precisely type Ruby code, without

unneeded complexity. DRuby uses static type inference to

automatically discover type errors in Ruby programs and provides a

type annotation language that serves as verified documentation of a

method's behavior. When necessary, these annotations can be checked

dynamically using runtime contracts. This allows statically and

dynamically checked code to safely coexist, and any runtime errors are

properly blamed on dynamic code. To handle dynamic features such as

eval, DRuby includes a novel dynamic analysis and

transformation that gathers per-application profiles of dynamic

feature usage via a program's test suite. Based on these profiles,

DRuby transforms the program before applying its type inference

algorithm, enforcing type safety for dynamic constructs. By

leveraging a program's test suite, our technique gives the programmer

an easy to understand trade-off: the more dynamic features covered by

their tests, the more static checking is achieved.

We evaluated DRuby on a benchmark suite of sample Ruby programs. We

found that our profile-guided analysis and type inference algorithms

worked well, discovering several previously unknown type errors.

Furthermore, our results give us insight into what kind of Ruby code

programmers ``want'' to write but is not easily amenable to

traditional static typing. This dissertation shows that it is

possible to effectively integrate static typing into Ruby without

losing the feel of a dynamic language.