Selected Course Projects


The following is a showcase of selected, final, active-learning course projects.

Edited by: S. Perugini.
Euclidean Rhythm Music Sequencer using Actors in Python

A Maze Game in Lua

An Alpha-Beta Heuristic Implementation of Tic-Tac-Toe in Haskell

Multingenium: Multithreaded Distributed Computing in Go

Graphs Algorithms in PROLOG

Euclidean Rhythm Music Sequencer using Actors in Python

Daniel P. Prince

Abstract
A real-time sequencer that implements the Euclidean Rhythm Algorithm is created for creative generation of drum sequences by musicians or producers. The Actor model of concurrency is used to simplify the communication required for interactivity and musical timing. Generator comprehensions and higher-order functions are used for simplification. The resulting application sends Musical Instrument Digital Interface data interactively to another application for sound generation.

Final
paper and presentation.

A Maze Game in Lua

Tyler C. Tamburlin

Abstract
The system presented is a Maze game which is built in the Lua programming language. The user enters the dimensions of the maze which they desire to be generated, and solves the generated maze through keyboard inputs. There are two versions of the game: an entirely text-based version built only with Lua, thereby, allowing it to be run more generally on systems with only Lua installed, and a graphical version which utilizes the LOVE2D engine in concert with Lua. To generate the maze, the system uses a backtracking method.

Final
paper and presentation.

An Alpha-Beta Heuristic Implementation of Tic-Tac-Toe in Haskell

Stephen G. Korenewych

Abstract
There are nearly twenty thousand board combinations and several hundred thousand unique move combinations in the game of tic-tac-toe. Evaluating each one is an arduous and largely unnecessary process. Using lazy evaluation and higher-order functions however, we can quickly and easily construct and evaluate only the necessary parts of the game tree. In particular, we generate a large game tree structure through a series of recursive, higher-order functions, using lazy evaluation to limit the scope of the search space, making it more manageable. We use an alpha-beta heuristic to evaluate and decide on the best move to make at any given board state.

Final
paper.

Multingenium: Multithreaded Distributed Computing in Go

Joseph J. Perme

Abstract
Distributed computing is becoming increasingly important in an ever-connected world. By means of our ever-available interconnectedness known as the Internet, the computing power of many machines can be leveraged for problem solving. This project enhances a multithreaded echo server in Go to enable clients to send messages to the server, which, upon receipt, the server broadcasts to all connected clients, save for the original sender. An interpreter for a language called Multingenium (an example of a portmanteau word created from the Latin for `many brains') was implemented so that clients could send Multingenium commands to the server, which then leveraged the computing power of the clients to execute the command.

Final
paper and presentation.

Graph Algorithms in PROLOG

Adam C. Volk

Abstract
We consider a PROLOG implementation of a directed graph data structure and how to solve multiple graph-theoretic problems using it. PROLOG belongs to the declarative paradigm of programming languages. Unlike imperative languages in which the programmer specifies how to solve a problem, in a declarative language, the programmer specifies what they what to find, and the system uses a search built into the language.

Final
paper and presentation.
Return Home