Gordon Plotkin
Call-by-name, call-by-value, and the lambda-calculus. 
Theoretical Computer Science 1,  1975, 125--159.

On the very last day of my first graduate course (December 1984), my PhD
advisor (Daniel Friedman, Indiana) handed out Plotkin's paper and said
something like "I think this is interesting but I haven't really absorbed
it yet." The next day I flew back to Germany for Christmas and read the
paper on the airplane. Needless to say, I didn't understand a word beyond
the introduction and put it away without a second thought.  Six months
later, Dan and I were trying to figure out how to create a lambda calculus
with a Scheme-inspired call/cc operator. Eventually, I recognized the
connection between our idea and the introduction to Plotkin's paper.  So, I
spent the next two months on the paper, using Barendregt's book as an
auxiliary reading. 

Plotkin's paper consists of two parts. The first part explains five aspects
of an operational model of a programming language: the abstract (virtual)
machine; the calculus (a "proof" system); the reduction system (another
"proof" system); the standard reduction relation (yet another one); and its
observational equivalence relation ("truth"). It does so with two small
examples: a functional language based on the call-by-name lambda calculus
and another one based on the call-by-value calculus. By designing a
calculus for a functional call-by-value language, Plotkin clarifies that
the conventional lambda call-by-name calculus does not play a canonical
role in programming languages. Instead, we should design and investigate
calculi and reduction systems for any given language if we want to prove
theorems about it.  The second part of Plotkin's paper is about the
relationship between the by-name and by-value languages.  Plotkin proves a
few things about this relationship but poses equally many, specific research
questions.

As I studied the paper, I began to see the first part of the paper as not
just a result but an implicit research program. Starting with my
dissertation research, I spent many years working out a new style of
semantics for programming languages (reductions based on evaluation
contexts), showing its applicability to a reasonably broad spectrum of
languages, and validating the usefulness of this style for many situations
(with Friedman, Hieb, Wright). I also worked on some of the open questions
in the second part of Plotkin's paper (with Flanagan and Sabry) though by
no means all of them. Because of my own personal success with this paper, I
have recommended it to many people over the past twenty years and I am
happy to see that the paper has found a large audience.