University of Minnesota
Software Engineering Center

You are here

Eric Van Wyk

Photo of Eric Van Wyk
Phone Number: 
Office Location: 
EE/CS 6-203

Ph.D. 1998, Computer Science, University of Iowa

M.S. 1991, Computer Science, University of Iowa

B.A. 1989, Mathematics and Computer Science, Luther College


Associate Professor Van Wyk's research focuses on programming languages, in particular extensible programming languages and compilers, applications of temporal logic, and algebraic compilers. In 2005 he was awarded a McKnight Land-Grant Professorship and the National Science Foundation's CAREER award in 2004.

He has authored or co-authored more than 25 publications, including journal and conference papers, articles and technical reports. Van Wyk has developed various software packages including the Silver attribute grammar specification and evaluation system, extensible specifications of Java 1.4 and ANSI C written in Silver, and various domain-specific language extensions for these Java and C specifications. He is a member of ACM, ACM SIGPLAN, IEEE, the IEEE Computer Society, and is involved in numerous conference committees. Van Wyk also does outreach, serving as a member of the St. Louis Park High School School Business and Information Technology Advisory Board.


In general, my research is on declarative specifications for programming language tools, such as compilers and optimizers, and the mechanisms for mapping these specifications into executable programs.

One area of interest is extendible programming languages and compiler designs that allow new language features to be imported into a language framework. These new features define their own syntax, semantics, and optimizations. In such a system, programmers do not choose which language to use for a particular task, but instead choose which set of language features to use and import these features into their programming environment thus creating a one-off language specific to their current problem domain.

Many program optimizations can be simply stated as rewrite rules but the data and control flow conditions which must be satisfied to safely apply the rules can be rather complex. I am interested in using temporal logic as a declarative specification language for these conditions since it is formal and concise. Also, temporal logic model checkers can automatically locate the points in a program flow graph where optimizations can be safely made.

I also work on algebraic compilers where programming languages are specified as Galois-connected syntax and semantic algebras and language translators are specified as (generalized) homomorphisms.

Recent Publications

Building Extensible Specifications and Implementations of Promela with AbleP

This paper describes how new language features can be seamlessly added to an extensible specification of Promela to provide new (domain-specific) notations and analyses to the engineer. This is accomplished using ableP, an extensible specification and implementation of Promela, the modeling language used by the SPIN model checker. Language extensions described here include an enhanced select-statement, a convenient tabular notation for boolean expressions, a notion of discrete time, and extended type checking.

Integrating attribute grammar and functional programming language features

While attribute grammars (AGs) have several features making them advantageous for specifying language processing tools, functional programming languages offer a myriad of features also well-suited for such tasks. Much other work shows the close relationship between these two approaches, often in the form of embedding AGs into lazy functional languages. This paper continues in this tradition, but in the other direction, by integrating various functional language features into AGs.

An Overview of XRobots: A Hierarchical State Machine-Based Language

This paper introduces a prototype domain-specific language for programming mobile robots that is based on hierarchical state machines. A novelty of this language is that states are treated as first class entities in the language and thus they can be passed as arguments to other parameterized states. The structure and behavior of the language is presented, along with an example program. Further work and language design challenges are also discussed.