text: abstract interpretation). on the other hand, we find source to source transformation
  techniques such as partial evaluation [mogensen and sestoft 1997] and more general
  techniques based on the unfold and fold or on the replacement operation.
  unfold/fold transformation techniques were first introduced for functional programs in [burstall and darlington 1977], and then adapted to logic programming
  (lp) both for program synthesis [clark and sickel 1977; hogger 1981], and for program specialization and optimization [komorowski 1982]. tamaki and sato [1984]
  proposed a general framework for the unfold/fold transformation of logic programs,
  which has remained in the years the main historical reference of the field, and has
  later been extended to constraint logic programming (clp) in [maher 1993; etalle
  and gabbrielli 1996; bensaou and guessarian 1998] (for an overview of the subject,
  see the survey by pettorossi and proietti [1994]). as shown by a number of applications, these techniques provide a powerful methodology for the development and
  optimization of large programs, and can be regarded as the basic transformations
  techniques, which might be further adapted to be used for partial evaluation.
  despite a large literature in the field of declarative sequential languages, unfold/fold transformation sequences have hardly been applied to concurrent languages. notable exceptions are the papers of ueda and fukurawa [1988], sahlin
  [1995], and of de francesco and santone [1996] (their relations with this paper are
  discussed in section 7). also when considering partial evaluation we find only very
  few recent attempts [hosoya et al. 1996; marinescu and goldberg 1997; gengler
  and martel 1997] to apply it in the field of concurrent languages.
  this situation is partially due to the fact that the non-determinism and the
  synchronization mechanisms present in concurrent languages substantially complicate their semantics, thus complicating also the definition of correct transformation
  systems. nevertheless these transformation techniques can be very useful also for
  concurrent languages, since they allow further optimizations related to the simplification of synchronization and communication mechanisms.
  in this paper we introduce a transformation system for concurrent constraint
  programming (ccp) [saraswat 1989; saraswat and rinard 1990; saraswat et al.
  1991]. this paradigm derives from replacing the store-as-valuation concept of von
  neumann computing by the store-as-constraint model: its computational model
  is based on a global store, which consists of the conjunction of all constraints established until that moment and expresses some partial information on the values
  of the variables involved in the computation. concurrent processes synchronize
  and communicate asynchronously via the store by using elementary actions (ask
  and tell) which can be expressed in a logical form (essentially implication and conjunction [boer et al. 1997]). on one hand, ccp enjoys a clean logical semantics,
  avoiding many of the complications arising in the concurrent imperative setting;
  as argued in the position paper [etalle and gabbrieli 1998] this aspect is of great
  help in the development of effective transformation tools. on the other hand,
  acm transactions on programming languages and systems, vol. tbd, no. tdb, month year.