What are staged functions (conceptually)?
To the best of my knowledge, the term staged computation was first used by Bill Scherlis in this paper.  Prior to that, the term "partial evaluation" was used for much the same concept, but the idea of staged computation is subtly different.  Both the ideas are related to Kleene's S-m-n theorem.

If you have a function $\phi(m,n)$ of two arguments, but you know one argument, say $m$, then you can perform some of the computation of the function right away using the knowledge of the first argument.  What you are then left with is a function $\phi_m(n)$ whose computations only depend on the second, unknown, argument.

The idea of partial evaluation is to compute the specialized function $\phi_m(n)$ automatically.  Given the code for the original function $\phi$, partial evaluation does static analysis to determine which bits of the code depend on $m$ and which bits depend on $n$, and transforms it to a function $\phi'$ which, given $m$, constructs $\phi_m$.  The second argument $n$ can then be fed to this specialized function.

The idea of staged computation is to think about the function $\phi'$ first.  It is called a "staged" function because it works in multiple stages.  Once we give it the first argument $m$, it constructs the code for the specialized function $\phi_m$.  This is the "first stage."  In the second stage, the second argument is provided to $\phi_m$ which does the rest of the job.

So, the job of partial evaluation is to transform the code for an ordinary function $\phi$ to a staged function $\phi'$.  Scherlis envisaged that this transformation could be done by more general mechanisms than the earlier partial evaluation methods.  The subject of "staged computation" now deals with issues such as:


How to define staged functions?
What programming languages and type systems should be used for defining staged functions?
What is the semantics of such languages?
How do we ensure the coherence and correctness of staged functions?
What techniques are useful for automatically or semi-automatically constructing staged functions?
How do we prove the correctness of such techniques?


Staged computation can be very important in practice.  In fact, every compiler is in effect a staged computation.  Given a source program, it constructs a translated and optimized target program, which can then take the actual input and calculate the result.  It is hard to write staged computation programs in practice because we have to juggle the multiple stages and make sure that the right things are done at the right time.  Everybody who has written a compiler has struggled with such issues.  It is also hard to write programs that write other programs, may they be machine language programs (compilers), SQL queries (database manipulations) or HTML/Server Pages/Javascript code (web applications) and myriads of other applications.  The researchers in staged computation aim to create good languages and tools that make it easier and safer to create such applications.