Al's Game Programming Blog

new blog

2008-01-22T17:13:00.000-08:00

Well it's been almost 2 years since I posted on this blog. I've been busy! I intend to start posting again on my new blog. There are some articles already there. Take a look!

Tim Sweeney gives a presentation at POPL 2006

2006-02-05T13:18:00.000-08:00

Last month, Tim Sweeney of Epic Games (developers of the Unreal engine) gave a presentation titled, "The Next Mainstream Programming Language: A Game Developer's Perspective". Although I did not attend the POPL 2006 conference, I found reading the slides interesting. They can be opened with Open Office if you don't have Microsoft Powerpoint.On the opening slide, he argues that the programming

How const is const?

2005-11-13T18:33:00.000-08:00

Here is some straightforward C++ code:int a[5];The variable "a" is declared as being an array of 5 integers. This code is equivalent:const int n = 5;int a[n];The variable "n" is a compile-time constant and can be used interchangeably with the constant 5. The address of a global variable is also a compile-time constant. Therefore, this is valid C++ as well:int b;const int n = reinterpret_cast

Using Python to drive Google Desktop Search

2005-09-25T16:12:00.000-07:00

If you haven't tried Google Desktop Search yet I suggest you install it immediately. It extends the Google search engine to your hard drive so you can use it to search your files, emails, etc. I find it really useful for searching through source code. It's much faster than Visual Studio or Explorer's search because it uses some kind of clever keyword index.This weekend I decided to learn Python.

Virtual sizeof

2005-03-26T23:33:00.000-08:00

Do you ever wish you could do this:class Base{}; class Derived: public Base{ int x;}; Base *p = new Derived; size_t s = sizeof(*p); // s is sizeof(Derived)Of course it doesn't work because s becomes the size of Base rather than Derived. What you really want is a kind of "virtual sizeof". This is what I came up with:class Base{public: virtual size_t Size() const = 0;}; class Derived: public Base

I'm not dead

2005-03-26T22:50:00.000-08:00

It's been 3 weeks since my last post. I'm not dead. I've been busy working on various projects. None of them are in a state that I can post anything concrete. Last week I learned two scripting languages: Ruby and Lua. The first thing I noticed was how much more productive I was using a scripting language than C# or C++. I think it was mostly the dynamic typing and certain language features like

CDL prototype working

2005-03-05T19:23:00.000-08:00

I just got my prototype CDL metacompiler working. It can compile the CDL class definition I posted previously and it outputs all the automatically generated schema and C++ serialization code. It's not even close to being production ready but I have taken it far enough to satisfy myself that it would be feasible for a game project. It was pretty straightforward to get working: just 18 hours.I

Other applications for CDL

2005-02-27T18:52:00.000-08:00

My main justification for CDL to this point has been as a tool to automatically generate a schema from an annotated C++ class definition, together with additional automatically generated C++ code to support the binding of objects to binary data cooked with the schema. As I see things, the only viable alternative (using C++ at least) is to automatically generate C++ code from a hand-written schema

Another CDL example

2005-02-27T10:38:00.000-08:00

This is another example of CDL. I am posting it in response to Noel Llopis' comment on another thread. This is intended to demonstrate how CDL could allow the structure of the schema to differ from that of the member variables.// Orientation.cdl// Hand written annotated classCDL class Orientation{public: Orientation(): x(0), y(0), z(0), w(1) {} // Public API uses Euler angles float GetX()

Puma C++ transformation library

2005-02-20T17:58:00.000-08:00

Today I looked at Puma. Puma is a library for applying transformations to C++ programs. It can do C++ lexical analysis, parsing and semantic analysis. The library provides an API for examining and modifying C++ abstract syntax trees. To support program transformation, it also allows a modified syntax tree to be "unparsed" back into C++ source code, which can then be compiled using a C++

Schema from program or program from schema?

2005-02-15T22:00:00.000-08:00

One of the goals of my C++ metaprogramming system is that it should be possible to generate a schema for game data directly from an annotated C++ program. This schema is important because it decouples the game engine from the tools that are used to process the game's data.There seem to be three options here. The first option is the one I am currently investigating and also the motivation for my C

artefaktur C++ framework

2005-02-15T13:07:00.000-08:00

I found this existing C++ framework that supports reflection. Like my metaprogramming idea, this uses a C++ preprocessor to parse metadata out of C++ class definitions. I believe it focuses on using reflection to exploit metadata. I want to continue down the metaprogramming route. I think it fits better with C++.I also investigated C++0x. This is an attempt to standardize the next version of C++.

CDL use cases

2005-02-13T12:55:00.000-08:00

These are some use cases for my C++ metaprogramming framework. First some CDL:// Texture.h#ifndef GUARD_Texture_H#define GUARD_Texture_H #include "Object.h" // physical dependency on base class #include "StringPtr.h" // no physical dependency on referenced classes#include "ArrayPtr.h"#include "MipMapPtr.h" CDL class Texture: public Object{public: PROPERTY Ptr GetName() const; void

C++ metaprogramming framework

2005-02-13T11:14:00.000-08:00

In my previous post, I considered some ways of exploiting reflection in a C++ program. Specifically, I proposed the use of a C++ data definition language (DDL) from which metadata could be extracted in order to support reflection. In retrospect, I think the choice of the term DDL was a mistake. C++ classes are not just data after all. From now on I will use the term class definition language (CDL

C++ data definition language

2005-01-30T10:21:00.000-08:00

In a previous post, I said I would consider some alternative ways of taking advantage of the benefits of C# (primarily reflection) on game console platforms. Two approaches spring to mind. The first approach is to use an existing interpreted language with reflection support, such as Python. An interpreted language is appealing because, if the interpreter, debugger and other tools can be easily

Contact details

2005-01-29T13:27:00.000-08:00

In light of recent industry events, should anyone want to contact me directly over the next few weeks, I can be emailed at "apatrick at mail dot com".

First experience of test driven development

2005-01-22T15:31:00.000-08:00

I have been meaning to try Test Driven Development (TDD) for some time now. Until now I had been putting it off, mostly because I thought it would take quite a long time to learn and because I thought it would be a long time before I really "got it" and started seeing any real benefits. Having just written my first program using TDD, I am pleased to report that my learning time was almost nil and

Review of the benefits of C# for games programming

2005-01-16T16:41:00.000-08:00

I have just about reached the limits of what I can hope to achieve with my C# to C++ translator project. There is so much more I would like to do but it is getting to the stage where I cannot make significant progress in weekend time alone. I'm also extremely busy at work and have little energy left. Maybe I'll pick up where I left off in a few months.I did pretty well in the time available I

Code coverage analysis

2005-01-16T15:32:00.000-08:00

Code coverage analysis is a way of verifying that every code path in a program is exercised at least once by a collection of test cases. Consider this simplified example: public class MathUtils { public static int Sign(int x) { if (x<0) { return -1; } else if (x>0) { return 1; } else { return 0; } } } [TestFixture] class TestMathUtils

Mono class library licensing terms

2005-01-15T14:52:00.000-08:00

I just checked out the licensing terms of the Mono .NET class library. This is Mono's implementation of classes like System.String, System.Collections.ArrayList, etc. It is just C# source code so, using my C# to C++ translator, I will be able to translate it to C++ just like any other C# program. It is under the very unrestrictive MIT license. Specifically, it is allowable to use it in

C# memory manager for video games console platform

2005-01-15T13:03:00.000-08:00

In a previous post I described a fully automatic memory manager that was guaranteed not to leak memory. It was based on reference counting, weak references and compile time analysis. I plan to use this in the runtime for my C# to C++ translator. Now in this post I will look into a possible allocation strategy. When designing a memory manager, there is an important trade-off to be made between

Prototype pattern using reflection

2005-01-08T17:19:00.000-08:00

The prototype pattern is one of the originals described by the "Gang of Four" in their book "Design Patterns". The idea is that a class contains a virtual method that is overridden in each derived class to create a clone. Given a prototype object, it is then possible to create as many clones as needed by invoking the clone method. An application of this pattern in video games would be to

Automatically detect all memory leaks at compile time?

2005-01-08T11:58:00.000-08:00

Yesterday at work I spent a couple of hours tracking down a troublesome memory leak. Memory leaks are my third least favorite kind of bug (race conditions and dangling pointers are worse). They are also annoying because it is next to impossible to write unit tests that verify memory does not leak. If I refactor some code, how am I to know if I have introduced a memory leak? This leads me to my

Improving code turnaround time

2005-01-04T20:19:00.000-08:00

I have been using refactoring, as described in Martin Fowler's excellent book, for a couple of years now and found that it has improved my productivity and the quality of my code considerably. One of the basic requirements of refactoring is that you must be do it incrementally. That is, after each individual change, you must build and test your code, ideally using automated tests. I will call the

Diagnostics traces

2005-01-01T23:42:00.000-08:00

Here is a common and useful debugging technique: void foo(int a, double b) { printf("Enters %s/%d foo(%d, %f)", __FILE__, __LINE__, a, b); // do stuff printf("Exits %s/%d foo(%d, %f)", __FILE__, __LINE__, a, b); }Sometimes we need a picture of what the program is doing that cannot be determined by using debugging techniques like breakpoints or stepping through code. For example, we might

Euclid's algorithm

2005-01-01T16:59:00.000-08:00

Today I worked on making the code generated by my translator a little less verbose. My strategy was to try and reconstruct the original C# expressions by analyzing the stack operations carried out by the IL assembly. This turned out to be quite straightforward. The main complication was aliasing. Unlike Java byte-code, MSIL byte-code permits variables to be aliased. I worked around this by only

Java or C#?

2004-12-31T21:27:00.000-08:00

Now that I have successfully implemented prototype translators from both Java and C# to C++ (see my previous post), I have some thoughts on what would make a good language to use in combination with C++ for higher level game code. I am not proposing the replacement of C++. C++ is an excellent language for all kinds of games related problems. Rather, I am proposing using reflection oriented

It lives!

2004-12-31T18:28:00.000-08:00

I finally got my C# to C++ translator doing something useful! It's still early days but I successfully translated a C# program into C++. The C# program was this: class Program { static void Main(string[] args) { for (int i = 0; i != 10; ++i) { Console.WriteLine("Hello world!"); } } } I compiled this with the Microsoft C# compiler, which generated

Garbage collection for robust game code

2004-12-31T15:13:00.000-08:00

In this port, I considered the performance issues associated with garbage collection in game code. I came to the conclusion that it was inappropriate for use during gameplay because it would burn a considerable amount of CPU time and make the frame rate stutter. I also thought that it might be useful for detecting memory leaks during development. Now I think it might actually have wider

The key benefit of C# for game code

2004-12-28T19:55:00.000-08:00

I am a little unsatisfied with the answer I gave to a comment on my previous post. It was somewhat abstract and hand-wavy. So I thought a concrete example might be a good idea. The reason I am writing a C# to C++ translator prototype is because there is one feature missing from C++ that I think would be extremely beneficial for game development. That feature is the ability for a program to

.NET disassembler

2004-12-25T21:07:00.000-08:00

I made a lot of progress on my C# to C++ translator today. I have written a simple disassembler that loads the EXE and PDB for a .NET assembly and outputs all the interesting metadata, debug information (C# source line numbers and variable names) and IL assembly using the new .NET 2.0 reflection API. It was surprisingly easy, only 300 lines of code. All I need to do now is modify it to output C++

Powerpoint in powerpoint

2004-12-24T20:10:00.000-08:00

This blog post made me laugh. If you have ever had the misfortune of sitting through a poor powerpoint presentation, you will understand. The author presents the failings of powerpoint as a written form using the very form that he ridicules. Hilariously circular. But he does such a good job, I can only conclude that it is not the form itself at fault but its users.

Atom, RSS, feeds and feed aggregators

2004-12-24T11:51:00.000-08:00

What do these funny words mean? Last week I heard mention of the word "feed" in the context of the Internet in two different conversations. My brain, being trained to look out for this sort of thing, advised me that I should probably investigate further. I was pleasantly surprised to discover that the Internet continues to evolve in new and interesting ways. A feed is a simple thing. Most sites

C# 2.0 to C++ translator

2004-12-23T13:59:00.000-08:00

Generics are just one of the many new features of C# 2.0. Other notable additions are anonymous methods and iterators. C# has always had language features without direct C++ equivalents. But these latest additions, and the possibility of subtle differences between the semantics of C# generics and C++ templates, are giving me second thoughts about generating C++ by traversing a C# syntax tree. For

Visitor pattern through runtime code generation

2004-12-19T19:36:00.000-08:00

I admit this is a little silly. It could be described as overkill for implementing the visitor pattern. However, I thought it might be fun try out some of the .NET framework's runtime code generation facilities. Specifically, I found out how to instantiate generic methods by binding their generic parameters at runtime. Try and do that in C++! This implementation is based on the previous one,

Visitor pattern using reflection

2004-12-19T15:44:00.000-08:00

As I said in this post, I think reflection is one of the most powerful features of languages like Java and C#. By using reflection, I can eliminate all of the redundancy from the my simple implementation of the visitor pattern. Admittedly, there might be some performance issues if I make heavy use of it. Notice that there is absolutey no code needed in the modem classes to support their visitors

Revisiting the Visitor pattern

2004-12-19T13:43:00.000-08:00

The visitor pattern is a very useful technique. I intend to use it for implementing the various passes over the C# abstract syntax tree (AST) that my C# to C++ translator will need to make. One of the key benefits of the visitor pattern is that it gives you the effect of injecting new virtual functions into a class hierarchy without actually having to modify those classes. The big win for me is

C# to C++ translator

2004-12-18T13:34:00.000-08:00

I've had this idea running around my brain for a couple of years now. As you may have guessed from previous posts, I am not the world's biggest fan of C++. That has not always been the case. Let's start from the beginning... Some time ago (oh boy I can't quite remember exactly how long but I think it was about 13 years ago) I started to learn C++. Before that I had been using C. Then in a

Other games industry blogs

2004-12-18T11:47:00.000-08:00

I discovered this games industry blog. In addition to being interesting in its own right, it is also cool because it links to lots of other industry blogs. One thing I notice is very few of my fellow game developer bloggers are programmers. Well, I am going to do my best to change that! Expect more posts on the technical aspects of games development in the future. I also need to think about why

Progress bars and why they are awful

2004-12-16T21:10:00.000-08:00

The most interesting thing I can say about progress bars is that they start on the left and finish (eventually) on the right.

Brief analysis of "Salutation to the dawn"

2004-12-16T20:32:00.000-08:00

I posted this poem recently. I have been thinking about what it means to me. It focuses on a single day: "Look to this Day". Or alternatively, the time between "For Yesterday is but a Dream" and "Tomorrow is only a Vision". The metaphor, "For it is Life", means that life and today are the same. This is true in the sense that we experience life in the present. As we experience life, we are

What is failure?

2004-12-14T13:57:00.000-08:00

What does failure mean? A recent experience at work taught me that failure means different things to different people. Some people have a natural curiosity. They delight in discovering new things: in learning. They have no fixed goal, or at least, with every success or failure, their goals change. They are motivated simply by the desire to solve problems and to improve themselves and those

A poem I liked

2004-12-14T13:10:00.000-08:00

Salutation to the Dawn Listen to the Exhortation of the Dawn! Look to this Day! For it is Life, The very Life of Life. In its brief course lie all The verities and realities Of your Existence; The Bliss of Growth, The Glory of Action, The Splendor of Beauty; For Yesterday is but a Dream, And Tomorrow is only a Vision; But Today well lived makes every Yesterday a Dream of Happiness, And every

Hypocrisy

2004-12-12T23:31:00.000-08:00

Yesterday I said that "if it's not C++ then it must be a scripting language" was a false dichotomy. I think I am guilty of a false dichotomy, actually a "false trichotomy". I have been thinking in terms of "C++ and higher level languages". Of course it follows that there should be languages that are lower level than C++. So I am categorizing languages in terms of being C++, being lower level or

Critique of C++

2004-12-12T21:06:00.000-08:00

I read this critique of C++. I agree with some of it. I don't think anyone would argue that C++ is perfect. C++ has its problems. And this critique digs deep into every aspect of C++ that might be considered as a failing. However, it was very negative and the author is clearly a highly biased Eiffel advocate so I didn't take it terribly seriously.

Introspection kicks ass

2004-12-12T19:55:00.000-08:00

Roughly 5 years ago I experienced an epiphany. Until that point I had been using C++ for a few years and I was quite confident that although other languages, like Java, had some advantages over C++, they were pretty minor and the better performance of the resulting code made C++ the best language for my problem (writing games). The advantages of Java, as I viewed them then, were essentially these

Reinventing the wheel

2004-12-12T18:22:00.000-08:00

In thinking about using other languages in games, I can't help but consider inventing a new language tailor made for the higher level aspects of game development. This is exactly what Tim Sweeney did with UnrealScript for the Unreal engine. I have worked on a title that used the Unreal engine and it certainly improved programmer productivity for that project. But what worked for Epic might not

An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl

2004-12-12T17:19:00.000-08:00

If only it was that easy. But, in his paper, this fellow has attempted just that. It's really quite interesting but flawed. I don't want to spoil it for you but what basically happens is he specifies a simple problem and has 80 different programmers independently solve it using whatever language they want. Then he collates the results and analyzes them in terms of programmer productivity, program

Scripting and false dichotomy

2004-12-11T14:24:00.000-08:00

I read this article about scripting languages for games and I thought there was some useful content and some not so useful. Specifically, I found the the comparison of Lua, Ruby and Python quite interesting. But I don't think the author's experience of some of the other languages, or understanding of their problem domain, is insufficient to include them in the comparison. When discussing the

The state of the art

2004-12-05T16:01:00.000-08:00

Before delving too deeply into the potential possibilities of using higher-level languages in games, I'm going to attempt to analyze what the current state of the art is in this area. I'm not going to consider the exceptions like Humongous or Naughty Dog. I'm going to try and focus on which languages the majority of teams are using and where they are applying them. Obviously every team is going

Languages and there uses in video games

2004-12-01T12:12:00.000-08:00

The more I think about it, the more I think the time is right to start using higher-level languages for games. As an industry, we predominantly use C/C++ as our primary programming language. It is also common to see a scripting languages, such as Lua, used as a mechanism to allow technical designers to customize the behavior of game objects. But these are, on the whole, treated as second class

So I created a blog

2004-12-01T12:03:00.000-08:00

That is all.