Walker M. White

[ Game Design ]   [ Other Teaching ]   [ Research ]   [ Vitae ]

The Game Design Initiative at Cornell

As Director for the Game Design Initiative at Cornell, I am responsible for the undergraduate minor in game design at Cornell. This minor is composed of several classes spread across multiple departments. I acts as a liaison between these various departments. I also teach the two core courses in game design and architecture.

CS/INFO 3152: Introduction to Game Design

This is course is an introduction to the design and development of computer games from a software-engineering perspective. It is open to all students at the sophomore and junior level, assuming that they have some minimum background in programming and/or design.

While the course does cover classic game-development concepts like graphics, physics, and AI, these are not the primary focus of the course. Many of these subsystems can be delegated to third party libraries. The challenge for students at this level is figuring out how to come up with a game idea, and create a complex, integrated piece of software implementing that idea.

The course is structured as an agile development project with playable deliverables every two weeks. I have developed several custom design documents and processes to help students through the development process. One of the things I have noticed is that there is a disconnect between how designers think about mechanics (as actions that take place over multiple animation frames) and how programmers implement them (as actions and interactions limited to a single animation frame). A large part of the design vocabulary for this class is bridging this gap.

The course website is available by clicking on the header above. Anyone is welcome to make use of the lecture notes or labs. The example design documents, however, are restricted to Cornell faculty and students. This is because of restrictions on sharing student work. For anyone interested in seeing sample design documents, I can make a few examples available upon request.

CS/INFO 4152: Advanced Topics in Game Design

The advanced topics courses is intended to be a capstone experience for students later in their undergraduate career. In addition to the introductory course CS/INFO 3152, students are expected to have taken a senior-level course related to game development, such as advanced graphics, AI, or networking. Students are expected to integrate those advanced concepts into a game that is substantially more complex that the one developed in CS/INFO 3152.

The exact nature of the games in this course have varied over the years. For many years this course focused on 3D games, but the recent focus has been on mobile games. I have found that the constraints imposed by the mobile platform result in much more innovative games. Indeed, some of the games in this course have been featured at independent game festivals.

This course is primarily discussion and critique, and so there are a lot less custom materials for this course. However, there are lectures unique to the mobile platform, such as monetization or memory management. Again, these are available from the link above.

CS/INFO 4999: Independent Study

Every semester I accept students for independent study through a competitive process. Students interested in developing a game for an independent study must first have taken CS/INFO 3152. The students must submit a concept document and initial gameplay specification following the format for that course. The best design documents for that semester are chosen for independent study. Some these projects are available to view at the GDIAC webpage.

Career Advising

As director of GDIAC, I am often the point of contact for the various game design studios that recruit from Cornell. Cornell has a good record of placement at major game studios such as Electronic Arts, Valve, Bungie, Zenimax, and the like. We also have several students who have chosen to create their own start-ups, particularly in the mobile space.

Other Teaching Interests

In addition to the game design courses, I have several other interests in education, both within and outside Cornell.

CS 1110: Introduction to Computing in Python

In the semesters that I am not teaching the game design courses, I teach the introductory CS course at Cornell. I was responsible for moving this course from Java to Python. This move was very successful, in that it lowered the barrier of entry for students who had never programmed before. Through the use of Kivy, we were able to retain a lot of the graphics-centric assignments from our Java course, but simplify them tremendously.

Assignments and course materials are available from the link above. Solutions are available to instructors upon request.

Inquiry-Based Learning

Before coming to Cornell, I was an assistant professor of mathematics and computer science at the University of Dallas. During my time there I developed extensive experience in inquiry-based learning in mathematics, sometimes known as the Moore Method. I have several theorem sequences (available on request) suitable for "bridge courses", which introduce students to the concept of proof. One is designed for mathematics majors, while another, on synthetic geometry, is geared towards humanities majors.

I apply a lot of these techniques in my game design courses, particularly in the more discussion-based CS/INFO 4152. Before taking over the game design curriculum at Cornell, I applied these techniques to computer science in my course CS 305: Problem Solving in Computer Science.

Research Interests

I am a mathematical logician by training. My original thesis work was in computable model theory. From this work I moved onto the design of high-level languages for databases and information systems. More recently, I have combined my professional research in databases and query languages with my hobbies in gaming and game design.

The following is an overview of my most recent research projects.

Data-Driven Games

Computer games are becoming increasingly data-driven, meaning that the the game content is separated from the game code. Just as database queries retrieve data declaratively, game designers want to specify the behavior of nonplayer characters (NPCs) through rules and specifications. However, as with databases, the expressiveness of this behavior comes at the price of performance. In the Cornell data-driven games project, we are developing a language framework that allows designers to specify complex character behavior, without worrying about how to implement it efficiently [WDKGR07].

• [ZWSBDGW11] T. Zou, G. Wang, M. Salles, D. Bindel, A. Demers, J. Gehrke, and W. White.
  Making Time-stepped Applications Tick in the Cloud.
  In Proc. of the 2011 ACM Symposium on Cloud Computing (SOCC 2011).
• [CSSYGDW11] T. Cao, M. Salles, B. Sowell, Y. Yue, J. Gehrke, A. Demers, and W. White.
  Fast Checkpoint Recovery Algorithms for Frequently Consistent Applications.
  In Proc. of the 2011 ACM SIGMOD Conf. on Management of Data (SIGMOD 2011).
• [WSSWCDGW10] G. Wang, M. Salles, B. Sowell, X. Wang, T. Cao, A. Demers, J. Gehrke and W. White.
  Behavioral Simulations in MapReduce.
  In Proc. of the 2010 Conf. on Very Large Databases (VLDB 2010).
• [SCSDGKW09] M. Salles, T. Cao, B. Sowell, A. Demers, J. Gehrke, C. Koch, and W. White.
  An Evaluation of Checkpoint Recovery for Massively Multiplayer Online Games.
  In Proc. of the 2009 Conf. on Very Large Databases (VLDB 2009).
• [GDGUW09] N. Gupta, A. Demers, J. Gehrke, P. Unterbrunner, and W. White.
  Scalability for Virtual Worlds.
  In Proc. of the 2009 Conf. on Data Engineering (ICDE 2009).
• [WSGD08] W. White, B. Sowell, J. Gehrke, and A. Demers.
  Declarative Processing for Computer Games.
  In Proc. of the 2008 ACM SIGGRAPH Sandbox Symposium (Sandbox 2008).
• [ADGGKLSSW08] R. Albright, A. Demers, J. Gehrke, N. Gupta, R. Keilty, H. Lee, G. Sadowski, B. Sowell, and W. White.
  SGL: A Scalable Language for Data Driven Games (Demonstration Paper).
  In Proc. of the 2008 ACM SIGMOD Conf. on Management of Data (SIGMOD 2008).
  (Note: Given the long lead time of SIGMOD, this paper describes an early version of the SGL language. There have been numerous changes since then; see the Sandbox paper above for a more definitive version of the SGL language.)
• [WCGGD07] W. White, C. Koch, N. Gupta, J. Gehrke, and A. Demers.
  Database Research Opportunities in Computer Games.
  In SIGMOD Record, September 2007.
• [WDKGR07] W. White, A. Demers, C. Koch, J. Gehrke, and R. Rajagopalan.
  Scaling Games to Epic Proportions. In Proc. of the 2007 ACM SIGMOD Conf. on Management of Data (SIGMOD 2007).
  (Slides from the SIGMOD presentation, with the illustration video)

Cayuga: Managing Data Streams

Cayuga is a highly scalable data stream processing system. It is intended to bridge the performance gap between general data stream management systems, such as STREAM, and publish/subscribe systems. The goal is to find a sweet spot where we can achieve both expressiveness and scalable implementation. My interest in this project has been in the design of a novel query languages with formal semantics [DGHRW06,DGPRSW07]. The design of this query language has lead to several interesting theoretical questions on the nature of time stamps in streams [WRGD06-TR].

• [DGHKRW07] A. Demers, J. Gehrke, M. Hong, C. Koch, M. Riedewald, and W. White.
  Massively Multi-Query Join Processing in Publish/Subscribe Systems.
  In Proc. of the 2007 ACM SIGMOD Conf. on Management of Data (SIGMOD 2007).
• [WRGD07] W. White, M. Riedewald, J. Gehrke, and A. Demers.
  What's "Next" in Event Processing?
  In Proc. of the 26th ACM SIGMOD-SIGACT-SIGART Symp. on Principles of Database Systems (PODS 2007).
• [DGPRSW07] A. Demers, J. Gehrke, B. Panda, M. Riedewald, V. Sharma and W. White.
  Cayuga: A General Purpose Event Monitoring System.
  In Proc. of 3rd Biennial Conf. on Innovative Data Systems Research (CIDR 2007).
• [DGHRW06] A. Demers, J. Gehrke, M. Hong, M. Riedewald, and W. White.
  Towards Expressive Publish/Subscribe Systems.
  In Proc. of the 2006 Conf. on Extending Database Technology (EDBT 2006), pages 627-644, 2006