Ray Tracer

Objective: write a ray tracing system that generates images from input sources using ray tracing algorithms. Define an input scheme, as well as choosing a mechanim for displaying the ray-traced image. The system must be able to have the following basic primitives defined in the system, as well as implementing a camera position, and (of course) at least a single light source.
Cube
Pyramid
Sphere

Recommendations: Look online for simple to complex ray-tracing algorithms. http://www.ece.eps.hw.ac.uk/~dml/cgonline/hyper00/raytrace/rayalg.html is one particular site. Implement algorithms alongside test cases for input primitives, and don't make any one system too complex. In the end, the system itself should simply compound environmental effects upon the tracing algorithm itself.

Chess with AI

Objective: write a chess game that allows a user to play a computer, forcing adherence to the rules of chess. The only requirements for the AI of the computer is that it can make plays in accordance with the rules. The most advanced AI would react to the human player's moves in accordance with known strategies in chess, learn from its mistakes, and retain its intelligence over games.
Recommendations: Implement the frontend first using an existing UI library (curses, qt, gtk), then concentrate on the computer player. There are a number of ways to approach the problem of intelligent responses. Start with a limited forward-thinking engine to contemplate and score possible moves. A very good test of the AI's skill would be to pit it against itself.

Real Time Strategy Game

Objective: Create a real time strategy game which involves at a minimum the following behaviors
  • resource mining
  • unit creation
  • combat system
And can incorporate a simplistic AI (the AI should *not* be the focus here) or multiplayer capabilities to drive opposition units.
Recommendations: Most RTS Games incorporate a tech ladder associated with roles that can be chosen. While you won't have enough time to create a full back story and a graphics suite, something simple can be used to illustrate a lot of strength under the hood. At least one person should be writing the graphics/interface code, while the rest of the team maps out unit/support behavior and features and implements to that effect. A clean I/O API for the game will make or break this project.

Database Engine

Objective: Create a new SQL database engine, which at a minimum must provide a way to define a table, insert data, remove data, and examine data. This can be done to a variety of degrees. The major decisions to be made are the following.
  • SQL Conformance - the PostgreSQL conformance site lists supported and unsupported features of the SQL99 standard, all topics of which are discussed inthe PostgreSQL documentation.
  • Persistence - in memory only/file based
  • Access - embedded only/socket oriented
  • Security and Authentication - users, passwords, grants, access control lists
  • Internal DB Structures - b-trees, internal tables, indices
  • Extensibility - functions, procedural language support, rules, triggers, views, user-defined data types, etc.

Recommendations: There are several distinct sections to the development of a database. One is the SQL interpreter. This is probably the largest portion of code in a modern database, since it involves translating arbitrarily complex SQL queries into the operations it must perform. I recommend looking at the SQL language subset supported by sqlite to get some idea of the grammars required to make such an parser work. Another section of development is a virtual machine which executes operations generated by the interpreter. Again, I recommend looking at the sqlite virtual machine tutorial for a guide as to how this should ideally work. The individual operations on a dataset should be defined explicitely here, and operations should be executed based on a ruleset. A clearly defined API between the interpreter and virtual machine will make development run smoothly and autonomously. Other distinct sections include code to handle connections if applicable, authentication mechanisms, data structure management, and a rule engine. Obviously, you should provide ways to interface with the database, be they through client librarys for a server-based DB or an API for an embedded database.

C to Whitespace Compiler

Objective: You've been hired by the innovative Macrohard corporation to build a compiler for their newest suite of stack-based processors. Their instruction codes are all coincidentally the whitespace characters in the ascii charset. While you have the engineers to blame for this, the company is offering you compensation in a popular soft drink to aid in your completion of this task as soon as possible. Your objective is to develop a compiler that will take the popular and often taken for granted C programming language and compile it into the machine code of this new processor, whose instruction set and behavior (also completely coincidentally) model that of the programming language 'Whitespace'

Recommendations: Use lex(1) and yacc(1) to make this a much more enjoyable task. Since both C and whitespace are stack-oriented languages, it should make the transition relatively simple. Your types are limited to a default unit size inside of whitespace, which should simplify the language somewhat. Data structures, function definitions and calls, pointers, and arithmetic are basic tenets of C, and should map easily to sets of whitespace instructions. You should include the operation in and out to allow for access to the I/O utilities of whitespace. Split your team up into two groups, one working on the C parser, and another working on the whitespace code generator.

Social Networking

Objective: Create the server and user side of a social site for true blue geeks. It should be a blogger at its core, but add playground tools for users to write small applets/programs that can generate output suitable for web browsers. The following is required
  • Relatively secure login creation
  • Support for at least one non-html non-module language that can be accessed by users to create small web parts
  • API for the site itself. Accessible items might include posts, comments, calendar, search tools
  • Documentation and tutorials

Recommendations: Use a language that is well suited for web output. You will need some sort of data backend, most often in similar implementations an SQL database. Prefashioned open source bloggers/forums are fine, but with the significant reduction in workload, your work on enhancements should be significant, and will be judged accordingly. Make it a productive free exchange for developers, and something you'd like to use.

GLSVG

Objective: Write an imlementation of the OpenGL 1.3 Standard with output to SVG. Required elements include:
  • All matrix functionality
  • All primitive rendering methods
  • Texture mapping
  • Display Lists
    Along with a couple of utility functions to be written for initialization (to replace glx, wgl, or glut routines) and buffer swapping (single buffered mechanisms for this would be very very difficult and are beyond the scope of this requirement). glsvgInit, glsvgSwapBuffers, and glsvgExit should be defined by you.

Recommendations: Since OpenGL is a C API at the core, this must conform to it at least on the surface. No part of this project can be external, so even the matrix math has to be of your own doing. Using other languages to speed up the development of linear algebra, list/stack tools and other things, but make sure you don't get mired in glue code. The final phase of this project, rendering your OpenGL scene to SVG should not be taken lightly, and you should focus on building a pathway from glBegin to svg output from the start, building the foundation for producing and testing output. libxml2 will be of great benefit to those attempting this project.

Project Design Tool

Objective: Create an GUI OO design tool that supports the following features at a minimum
  • Use Case Diagrams
  • Sequence Diagrams
  • Class Diagrams
Extended features could include code generation, batch testing tools, automatic management of code to reflect design updates, and versioning system hooks and tracking.
Recommendations: Pick a UI toolkit your group will be comfortable creating such a tool in (ie. QT, gtk, Java Swing), and create a unified interface that can contain the features you are looking to implement. Then split the functionality accross the different diagrams and the backend machine to drive it all. The tool should provide a similar interface to other satisfying tools in its genre (Rose, MagicDraw, Thorn, Gaphor). Use these as a reference point and add features that your team would find useful.