Wednesday, February 7, 2007

DSLs and Computer Graphics

The use of Domain Specific Languages in Teaching Computer Graphics Courses

Gordon DuQuesnay

Analysis of Programming Languages, Assignment 1
Wessel Thomas
February, 2007


Domain Specific Languages (DSLs) are limited forms of computer language designed for a specific class of problems. This approach to programming has been used for some time, for instance, it is very common among LISP and Smalltalk programmers. In spite of their having been around since the dawn of programming they have only recently become a hot topic for discussion in the industry. In this paper I will examine a particular a subset of DSLs referred to as Internal DSLs (Fowler 2006), and how they can be implemented in the Ruby language. I will further show how they could be used in computer science courses such as the "Computer Graphics" course as taught at the University of Technology's School of Computing and Information Technology.

Problem Statement:

Computer Science courses often attempt to deliver very challenging, technically complex content. While some complexity is unavoidable the level of complexity in a course is often compounded by the need to also teach topics that introduce incidental complexity along with the core topic. For example consider the Computer Graphics course, the core complexity of this course involves the various algorithms for producing complex shapes in two and three dimensions by building upon graphic primitives, the most basic being the displaying of a single pixel. However, in addition to this the students must also master C++ and OpenGL, each of which introduce additional incidental complexity. The use of a DSL for graphics could allow the course to focus on the essentials of graphics without having to also concurrently deal with the complexities of C++ and OpenGL.

Research Questions:

  • How can DSLs help to reduce complexity?
  • What type of DSL would be best suited for use in the compter graphics course?
  • What language would be best for writing the DSL?

Literature Review:

How can DSLs help to reduce complexity?
In his paper No Silver Bullet, Brooks explains why he feels the software industry is unlikely to experience orders or magnitude increases in productivity. At the core of his argument is the idea that the complexity of any system can be divided into two parts, the essential and the accidental or incidental. The essential complexity is that which is inherent in the problem. The incidental complexity on the other hand is a function of the difficulty of adapting a general purpose language and platform to be able to solve that problem. Vanderburg asserts a third kind of complexity that arising from the dissonance due to mixing code addressing incidental and essential complexity and suggests DSLs as a way of minimizing this complexity.

What type of DSL would be best suited for use in the Compter Graphics course?
According to Freeze there are two ways to create a DSL. One is to invent a syntax from scratch, and build an interpreter or compiler (External DSL). The other is to tailor an existing general-purpose language by adding or changing methods, operators, and default actions (Internal DSL). The advantages of Internal DSLs as opposed to External make them well suited for use in computer science courses. In particular the speed of development would allow the lecturer to develop and modify the language as the course progresses tailoring the DSL as needed. The main disadvantage of Internal DSLs, that their syntax is constrained by the language they are written in(Fowler), is not insurmountable since the target users are programmers.

What language would be best for writing the DSL?
Internal DSLs, since they are limited by the syntax of their host language are best expressed in languages that have terse, flexible but expressive syntax. This makes dynamic, interpreted languages such as Ruby ideal (Fowler).


To illustrate the advantage of using a DSL for teaching graphics consider the following OpenGL program in c++:
#include <gl/glut.h>

const int width=640;
const int height=480;

void display(void)

void reshape(int w, int h)
glOrtho(-300.0, 300.0, -200.0, 200.0, -1.0, 1.0);

void main(int argc, char **argv)
glutInitWindowSize(width, height);
glutCreateWindow("Graphics Programming Basics");
Notice the complexity of even this simple program, also notice the mixing of the essential and incidental complexity. With words and symbols like "void", "int", "**", "}" and ";" which really have little to do with graphics sprinkled throughout the code. An internal DSL written in Ruby could reduce this complexity allowing the same program to be written like this:

window :title=>"Graphics Programming Basics", :width=>640, :height=>480
Ortho(-300, 300, -200, 200)
lineStrip do



Brooks, F (1986) No Silver Bullet: Essence and Accidents of Software Engineering. Retrieved February 7, 2007


Buck, J (2006) Writing Domain Specific Languages. Retrieved February 7, 2007

Web Site:

Deursen , A., Klint , P., Visser, J. (1998)Domain-Specific Languages:An Annotated Bibliography.

Retrieved February 7, 2007


Fowler, M. (2006). Introduction to Domain Specific Languages.
Retrieved February 4, 2007, from InfoQ Web Site:

Fowler, M. (2005). Language Workbenches: The Killer-App for Domain Specific Languages?

Retrieved Februery 7, 2007, from Martin Fowler's Bliki

Web Site:

Frecho, J. (2003) Domain-Specific Languages - An Overview. Retrieved February 7, 2007


Freeze, J (2006) Creating DSLs with Ruby. Retrieved February 7, 2007

Graham, P (1993) Programming Bottom Up. Retrieved February 7, 2007


Olsen, R (2006). Building a DSL in Ruby. Retrieved February 4, 2007,
from Russ Olsen's Weblog
Web Site:

Vanderburg, G (2006) Interviewed by Geoffrey Grosenbach. Retrieved February 7, 2007
from Rails Podcast
Web Site:

Wikipedia Article (2007) No Silver Bullet. Retrieved February 7, 2007


No comments: