Abstraction of control and syntax in Schem

This dissertation covers four related language design and implementation topics within the context of the programming language Scheme.;The first part of this dissertation describes a convenient and efficient procedural interface that allows the definition and use of procedures with optional and indefinite numbers of arguments without the need for a language-dependent data structure in which to store the arguments. This interface solves many problems inherent in the use of lists to store indefinite numbers of arguments. A natural multiple return value extension is also presented.;Traditional continuations are not useful in the presence of concurrency, because the notion of the rest of the computation represented by a continuation does not in general make sense. The second part of this dissertation presents a new type of continuation that may be used to control tree-structured concurrency. Process continuations allow nonlocal exits from arbitrary subtrees of a process tree and allow the capture of arbitrary subtrees as composable continuations for later use. Even in the absence of concurrency, the precise control achievable with process continuations makes them more useful than traditional continuations.;The syntactic theories of control and state are conservative extensions of the $lambdasb{v}$-calculus for equational reasoning about imperative programming facilities in higher-order languages. Unlike the simple $lambdasb{v}$-calculus, the extended theories are mixtures of equivalence relations and compatible congruence relations on the term language, significantly complicating the reasoning process. The third part of this dissertation develops fully compatible equational theories of the same imperative higher-order programming languages. The new theories subsume the original calculi and satisfy the usual Church-Rosser and Standardization Theorems. With the new calculi, equation reasoning about imperative programs becomes as simple as reasoning about functional programs.;Naive program transformations can result in the inadvertent capture of identifiers due to interactions among existing and introduced bindings and references. Furthermore, transformed programs may have little resemblance to the original programs, complicating correlation of source and object code. The fourth part of this dissertation introduces a new approach to implementing syntactic transformations and a new representation for syntactic expressions. It allows the programmer to define program transformations using an unrestricted, general-purpose language, while helping the programmer avoid capturing problems and maintaining a correlation between the original and transformed code.