Jonathan Leamon

Title: Detecting Deadlock in Semaphores from Code
Abstract: In this paper, we present several algorithms for determining whether a program that uses semaphores would be susceptible to race conditions or deadlock along with an analysis of their usefulness. We also present a program that implements these algorithms. Called SafeSet, the program reads a description of a set of processes written in a controlled version of pseudocode and analyzes the set to determine if it is safe. Since a semaphore in code can be used to stand in for any resource that can cause a process to block, the algorithms presented here for analyzing programs for safeness can also be usefully applied in the more general context of sharing any scarce computer resource among multiple processes.

Sean Gillispie '04, Dan Mevorach '03, and Max Montgelas '03

Title:Asynchronous Exception Handling in Python
Abstract:

Monte Brown '03

Title:Cellular Automata Operating System
Abstract: Cellular automata consist of an n-dimensional grid of cells, each with a finite set of values. The values of these cells evolve synchronously in discrete time steps according to simple rules. Models of this type have been found useful in a myriad of applications, particularly in modeling complex natural systems containing components that interact locally.

Computation of cellular automata is usually done using computer simulations that run on an existing operating system. While this approach works, it does not take full advantage of the parallel, local, and homogeneous nature of cellular automata. Cellular Automata Operating System (CAOS) is an operating system specifically designed to process cellular automata efficiently on a parallel system. Parallel systems can process cellular automata in linear time by applying rules synchronously. CAOS is controlled using a shell interface that interprets commands to create grids of cells, apply rules to them, and observe the results of the computation. Files of commands can be run, allowing programs to be written that run cellular automata. The system supports automata of any dimension and neighborhood size. CAOS thus allows efficient processing of cellular automata using a highly adaptable interface.

Nora Au '03, Evan Hiller '03, Alex Timofeyev '04, and Tom White '04

Title:The NEAT Shell: a Command Line Interpreter for Windows XP
Abstract: The Microsoft Windows XP operating system is currently one of the most heavily used operating systems in the world. Unlike UNIX, it has only a small variety of shells that run on it. The development of additional shells allows users to run Microsoft-compatible software without having to learn new shell commands for the Microsoft front-end. This project is fraught with difficulties, but serves to illustrate many of the different design choices made when constructing Windows applications.

Christopher Cyll '04

Title:IP over Audio
Abstract: Modern sound cards are capable of producing and receiving high resolution audio signals. This high resolution can be exploited to transmit and receive data encoded as PCM audio. This paper describes the implementation of a library and program suite capable of communi- cating data through the air using only two sound cards, speakers, and a microphone. It also discusses an attempt to build a PPP network connection over this communication channel.

Stephen Winslow '04

Title:Design and Implementation of the CryptFS File System
Abstract: Many of the methods of storing data currently implemented for the Linux operating system base the security of their data around the UNIX file permissions provided via the Virtual Filesystem. While file permission-based security works fine to protect data from other users on the system, it depends on the physical security of the machine. If an intruder can get physical access to a machine and remove its hard disk or other storage media, he can bypass any software-based security restrictions by reading the disk byte-by-byte, since common filesystems such as ext2 store data blocks in plaintext on the volume. In this paper, I describe the design and implementation of a new filesystem named CryptFS, which encrypts data before writing it to disk to reduce the risk of an intruder gaining access to sensitive files by removing a physical volume. I also discuss some of the roadblocks I encountered in working with the Linux kernel source code, and some advice for other beginning kernel programmers.

Evan Gee '04 and Israel Mirsky '03

Title:State-Dependent Peer to Peer Application Development: StoneFace Poker
Abstract: While essentially stateless peer to peer applications like file sharers are becoming ubiquituous, state based peer to peer applications, especially applications with security considerations, have yet to be explored. Construction of a viable state-based peer-to-peer application, here a poker game, is accomplished, and the game's peer to peer importance is emphasized by its ease of use and playability in a real environment. However, security issues are considerable and non-trivial. In addition, the client-server hosting model is here reexamined with an eye towards construction of a comparable peer to peer model, and modularity in the new structure proves to be a challenge that, though not insurmountable, exceeds the bounds of the proposed project.