Remembering Paul Hudak

Share

Paul
HudakRenowned computer
scientist Paul Hudak, one of the designers of the Haskell programming
language, died of leukemia this week. There’s been an outpouring of
reactions from people Paul’s life and work has touched. Paul was my
Ph.D. adviser at Yale in the 1990s. He supervised my work, paid for my
education, and created an environment that enabled me to learn from some
of the brightest minds in the world. Paul was an influential figure in
the advancement of functional programming. Functional programming
advocates a declarative style, as opposed to procedural or imperative
style, of programming. For example, instead of writing
result = 0; for (i=0; i<n; i++) result += a[i]; you write
result = sum(a[0:n]). In many cases, the declarative style is easier
to understand and more elegant. Because the declarative style focuses on
what, rather than how to perform the computation, it enables
programmers to worry less about implementation details and gives
compilers more freedom to produce optimized code. One of the strongest
influences of functional programming came from Lambda Calculus, a
mathematical construct formulated by Alonzo Church in the 1930s. Lambda
Calculus has had a huge impact on programming languages even though it
was created before computers were invented. Lambda Calculus introduced
modern programming constructs such as variable bindings, function
definitions, function calls, and recursion. Alan Turing, who studied as
a Ph.D. student under Alonzo Church, proved that Lambda Calculus and
Turing Machine were equivalent in computability. It is therefore
comforting to know that, in theory, whatever a computer can do, we can
write a program for it. In 1977, around the time Paul was starting his
own Ph.D. research, functional programming got a tremendous boost when
John Backus presented his Turing Award lecture titled “Can Programming
be Liberated from the von Neumann Style?” Backus argued conventional
languages designed for sequential “word-at-a-time” processing were too
complex and could no longer keep up with advances in computers. Backus
favored functional style programming which possessed stronger
mathematical properties. The Backus lecture had a strong impact because
it represented a radical departure from his early work in leading the
development of FORTRAN and in participating in the design of ALGOL 60,
the major “von Neumann style” languages of its day. Functional
programming research took off in the 1980s. Researchers from all over
the world created numerous functional programming languages. The
proliferation of languages became a problem. Many of these languages
were similar enough to be understandable by humans. But researchers
could not collaborate on the implementation or run each other’s
programs. In 1987, Paul Hudak and a group of prominent researchers came
together and created Haskell as a common research and education language
for functional programming. As far as I can remember, Paul always
emphasized other people’s contributions to the Haskell language. There’s
no doubt, however, Paul was a major driving force behind Haskell. This
is just the type of leader Paul was. He painted the vision and gathered
the resources. He would create an environment for others to thrive. He
attracted a remarkable group of world-class researchers at Yale Haskell
Group. I made great friends like Rajiv Mirani. I was fortunate to get to
know researchers like John Peterson, Charles Consel, Martin Odersky, and
Mark Jones. Mark Jones, in particular, developed a variant of Haskell
called Gofer. Gofer’s rich type system enabled me to complete my Ph.D.
thesis work on monad transformers. I decided to pursue a Ph.D. in Yale
Haskell Group largely motivated by Paul’s vision that we could make
programmers more efficient by designing better programming languages.
Paul believed programming languages should be expressive enough to make
programmers productive, yet still retain the simplicity so programs
would be easy to understand. He had a favorite saying “the most
important things in programming are abstraction, abstraction,
abstraction,” which meant a well-written program should be clean and
simple to understand with details abstracted away in modules and
libraries. Paul believed compilers should help programmers write correct
code by catching as many mistakes as possible before a program ever
runs. By the time I completed my Ph.D. program, however, we found it
difficult to get the larger world to share the same view. The computing
industry in the late 1990s and early 2000s turned out to be very
different from what functional programming researchers had anticipated.
There were several reasons for this. First, the von Neumann style
computers kept getting better. When I worked on the Haskell compiler,
computers ran at 25MHZ. CPU speed would grow to over 3GHZ in less than
10 years. The miraculous growth of the conventional computing model made
benefits compilers could get from functional programming irrelevant.
Second, the tremendous profit derived from Y2K and Internet build-out
enabled companies to employ industry-scale programming, where armies of
coders built complex systems. One of the last piece of advice Paul gave
me was to accept a job in Silicon Valley working on the then-nascent
non-functional language Java, instead of pursuing a research career on
the East Coast. Like many others, I have witnessed with surprise the
rising interest in programming language design and functional
programming in recent years. No doubt this has to do with the slowing
growth of CPU clock-rate and the growth in multi-core and multi-node
computing. Functional programming frees developers from worrying about
low-level optimization and scheduling, and enables developers to focus
on solving problems at large scale. A more fundamental reason for the
resurgence of functional programming, I believe, lies in the fact
programming has become less of an industrial-scale effort and more of a
small-scale art form. The simplicity and elegance of functional
programming strike a chord with developers. Building on the rich
foundational capabilities nicely abstracted away in web services, open
source modules, and third-party libraries, developers can create
application or infrastructure software quickly and disrupt incumbent
vendors working with outdated practices. I have not kept in touch with
Paul in recent years. But I can imagine it must be incredibly rewarding
for Paul to see the impact of his work and see how the programming model
he worked so hard to advance is finally becoming accepted.

(Visited 1 times, 1 visits today)