Combining Static and Dynamic Typing in Ruby
Combining Static and Dynamic Typing in Ruby
Files
Publication or External Link
Date
2009
Authors
Furr, Michael
Advisor
Foster, Jeffrey S
Citation
DRUM DOI
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.