Steve MacDonald

Assistant Professor
David R. Cheriton School of Computer Science
University of Waterloo

Steve MacDonald UW logo

Contact Information
Postal address:
School of Computer Science
University of Waterloo
200 University Avenue West
Waterloo, Ontario, CANADA
N2L 3G1

E-mail:
stevem@uwaterloo.ca
Office:
Davis Centre 2516

Phone:
(519) 888-4567 ext. 36242

Fax:
(519) 885-1208
Biographical Data
Ph.D. in Computing Science, University of Alberta, 2001.
Thesis title: From Patterns to Frameworks to Parallel Programs
Supervisors: Duane Szafron and Jonathan Schaeffer
M.Sc. in Computing Science, University of Alberta, 1995.
Thesis title: An Object-Oriented Run-Time System for Parallel Programming
Supervisors: Duane Szafron and Jonathan Schaeffer
B.Math. in Computer Science with Electrical Engineering Electives, University of Waterloo, 1993.
Teaching
Current Courses Previous Courses

Fall 2008
CS 134 - Principles of Computer Science
Class: Tuesdays and Thursdays
10:00 - 11:20 AM - MC 2035
Office hours: Thursdays 1:30 - 3:00 PM or by appointment

Winter 2007
CS 842 - Topics in Aspect-Oriented Programming

Fall 2005, Fall 2006
CS 133 - Developing Programming Principles

Winter 2005
CS 350 - Operating Systems

Fall 2004
CS 842 - Topics in the Java Language and Virtual Machine

Fall 2002, Fall 2003, Spring 2005, Spring 2007, Winter 2008
CS 454/654 - Distributed Systems

Spring 2003
CS 854 - Topics in Pattern-based Parallel Programming Systems

Research
Current Research
I am currently a member of the Programming Languages Group at the University of Waterloo. However, different aspects of my work and interests overlap with the Software Engineering and Shoshin Distributed Systems groups. That doesn't really say a lot, though. More specifically, I have interests in the following areas:
  • Testing and debugging of concurrent software Given the rise of multicore computers and the increase in concurrent software (particularly concurrent commercial software, like Adobe Photoshop and Norton Antivirus), testing and debugging will be essential for developers to produce high-quality software. My new research has focused on adding program analysis to improve model checking and other dynamic testing tools. Lately, we've begun to explore combining static and dynamic analysis methods to improve the testing process.
  • Pattern-based programming systems and tools Most of the work I've done in this area has been in the context of parallel programming (see my previous research below for details). Most work in this area has concentrated on using patterns to write programs, through language support or (in my case) code generation. Some potential research may include the following:
    • I am always interested in finding new patterns (in different problem domains) that can be incorporated into a pattern-based programming system.
    • Something I would like to explore is how to use pattern information in other tools for different phases of application development. With pattern information, we know a lot about the structure of a program and the kind of problem it is attempting to solve. With this information, it should be possible to augment profilers and visualization tools to provide feedback tailored to the specific pattern rather than general feedback. A compiler could use this information to identify the computationally expensive parts of a program rather than having to discover this itself. It can then dedicate more time to optimizing this code.
  • Improving the Java Virtual Machine Since my work is now usually done in Java, I'm interested in improving the virtual machine. This has two aspects. The first aspect is to improve performance. One example topic in this area is to reduce the locking overhead in object allocation, which can dramatically impact the performance of a multi-threaded program. The second aspect is to introduce features that make it easier to write or maintain code, specifically object-oriented frameworks. There are a number of possibilities, some including the use of aspect-oriented programming, covariance, and contravariance.
  • Operating Systems and Distributed Systems I haven't actually done much active research in these areas, but I'm willing to consider topics in them.
Previous Research
I was a member of the Software Systems Group at the University of Alberta, working on pattern-based parallel programming systems. The two projects I was involved in were Enterprise (during my M.Sc.) and CO2P3S (during my Ph.D.).
Publications
Publications by date.
Graduate Students

Current Students

  • Jun Chen
    Degree: PhD
    Co-supervisor: Peter Buhr
    Topic: Testing and Debugging of Concurrent Software
  • Steve Hanov
    Degree: MMath
    Topic: To be determined
  • Nathan Zhang
    Degree: MMath
    Topic: To be determined

Former Students

Software
CO2P3S: CO2P3S supports the rapid creation of parallel programs based on design patterns, object-oriented frameworks, and several layers of user-accessible abstractions. At the first layer, you start writing a program by specifying its structure using a set of supported design pattern templates. These templates are a parameterized representation of an underlying design pattern. The parameters allow you to customize the pattern structure to tailor it to your specific application. Once you have provided a full pattern description, the templates are used to generate parallel object-oriented framework code (multi-threaded Java code usually, though there's been work on distributed memory patterns as well) that implements the selected pattern structure. The framework code encapsulates all of the communication, synchronization, and concurrency management. You simply insert sequential application code into the framework to complete a program. Lower layers open up the implementation of the frameworks so that you can remove performance bottlenecks or implement pattern variations that are not addressed by the pattern template parameters.
MethodThread Class for Java: This is a subclass of the Thread class that uses reflection to allow a thread to execute any public method on an object rather than only the run() method of a Runnable object. You can also get return values from the method and examine any exceptions that were thrown. In addition, a class is provided that extends the capabilities of the getMethod() method in the Class class to allow subclasses in the parameter types argument (rather than requiring the types to be an exact match). This class is also archived at (among other places) CGIScriptsOnline.com, ScriptSearch, and FindAScript.com.
Goofiness
Anagrams of "Steve MacDonald"
  • doves dent a clam,
  • a vest-clad demon,
  • demon laced vats,
  • a celt adds venom,
  • Tom addles Vance,
  • Tom led advances,
  • Cam addles no vet,
  • vend as cold meat,
  • Dave's mental cod,
  • a damn svelte cod,
  • odd mental caves,
  • Ed tends clam ova,
and my favourite,
  • a calm, vented sod.

Last updated: Monday May 19, 2008 16:33