I have not been looking at partial evaluation for a very long time. There is
much stuff in code optimization techniques for compilers that can fit
that framework when properly presented. Thing often become relevant
when you start looking at them the right way. But people in
optimizing compilers may not try to emphasize the partial evaluation
view when partial evaluation is no longer fashionable. Each time has
its own buzzwords to get grant money and publications accepted.
So I would suggest a good look at code optimization (unless that is
dead too).
I answered recently to a question about compilers, and mentioned
partial evaluation as an important issue to understand the nature of
the compiling process. I doubt much you will find anything new there, but
just in case ...
Partial evaluation and formal languages
Another thing in that area is not well known (afaik), though it may be seen
more as an intellectual curiosity than as an important technical view.
It is a bit post-1993 (in Lang 1995 actually). This concerns parsing. You may
view a grammar $G$ (for example a context-free grammar, but this
applies to many other kinds of syntactic formalisms) as something that computes a parse tree
for a string $w$, given an appropriate grammar interpreter (the CYK
algorithm is a simple example). Actually, in the case of ambiguous
languages, you do not get a single parse-tree but a whole collection
forming a parse-forest. There is a condensed form for parse-forest
that shares subtrees that are common to several parse-trees, in
different ways. With appropriate sharing structures, this
shared-parse-forest is actually nothing but another grammar $G_w$. This
grammar $G_w$ is a specialization of the original grammars to the string
parsed.
What that means is that $G_w$ is is a grammar that generates only the
string $w$
being parsed, but does it with precisely the same parse trees as the
original grammars, up to a homomorphic renaming of some non-terminals.
So the original grammar $G$ has been specialized to a grammar $G_w$
generating the singleton subset $\{w\}$ of the language of $G$.
This is moderately exciting. The more interesting aspect is that the
technique works for other subsets of the original language. If you
take any regular set $R$, its intersection with the language $L(G)$ is
a context-free language (assuming we are working with CF grammars).
Exactly the same techniques can be used to parse the whole regular
set, represented by a FSA, to produce another grammar $G_R$, which is
a specialisation of $G$ for the intersection of the CF language
$R\cap L(G)$. It is a specialization in the sense that for strings in that
intersection it produces exactly the same parse-trees, the same
ambiguities as the original grammar $G$, up to a renaming homomorphism
for non-terminals.
So the idea is that you can partially evaluate a grammar when you have
some information about what should be parsed, information which is
specified by a finite state automaton. This can then be extended to
various games people play with grammars, such as attaching attributes
or feature structures. But then one would enter more traditional
partial evaluation.
These techniques have actual use in natural language processing, but
could be used for programming languages too.
I have various pointers accessible following links from this answer which present an example of application in NLP amongst too many other things (but the question was a bit wide).