Programming with state, or imperative programming, offers ready
opportunities for information hiding.  Modeling this information
hiding in denotational models of programming languages has led two
diametrically opposite paradigms.

In one paradigm, which we dub the Scott-Strachey paradigm, commands
are modelled as (suitable) functions from states to states.  At the
outset, this paradigm loses all the information hiding implicit in
imperative programming.  Information hiding can be brought back ---
via the back door, so to speak --- by additional axiomatization of the
state-to-state functions, in terms of functor categories and
relational parametricity.  This approach is mathematically
sophisticated but its success is yet to be fully determined.

In another paradigm, which we dub the Milner-Hoare paradigm, the store
is represented as a collection of stateful ``objects'' (or ``agents''
or ``processes'').  Commands are interpreted as sequences of actions
on the storage objects (or ``events'' or ``labelled transitions'').
The states of the objects remain fully encapsulated, and only the
actions performed on them appear in the denotations.  This paradigm
directly and concretely represents the information hiding aspects of
imperative programs.  It has led to numerous fully abstract models:
the Reddy-McCusker model for Syntactic Control of Interference, the
games models for Idealized Algol and ML references, and the
pi-calculus models of Honda, Yoshida et al.  The point of note is not
so much that these models are fully abstract, but rather that they
capture information hiding (which is integral to the full abstraction
property.)

In this talk, we compare and contrast the two paradigms so that the
connections and differences between them become evident.