I'm a software engineer in New York, NY, where I live with my wife,
Caitlin, and son, Patrick.
I work at Interboro Labs, where I'm responsible for taking applications through their full
life cycle: from conception & design, to implementation, to release and continuous improvement. My current development work is focused on Android,
for which I use Java and C++ (Android NDK). I am also a
in the MET Computer Science Department at
Prior to moving to New York, I worked as a Graduate Assistant at
Boston University's Metropolitan College Department of Computer Science
(see our paper
presented at the 2015 ACM Conference on Learning at Scale),
and as an application developer, business analyst, and fund accountant in Boston's financial services industry.
The Canfield Ant Simulator simulates a colony of ants, with a focus on the ants' search for food. Ants lay pheromone trails to notify other ants about food, as in the real world. Over time, this gives the ants the appearance of having a higher-level coordinating intelligence that is instructing all ants according to group goals, though in reality each ant is fully in control of itself, and does not have any direct communication with other ants.
The project involved the creation of the following components:
World Creator: random map generator
Navigation Graph, with nodes & edges. Ants may lay pheromone trails on edges.
123 C++ unit tests (Microsoft CppUnitTestFramework), 23 Java unit tests (JUnit), and 3 integration test applications, in addition to the final simulation
The project was created as part of the BU MET CS 664 Artificial Intelligence course.
See the github page for more information, including the code, binaries, documentation and the pdf of a presentation I gave.
The application was implemented in C++, and used the following libraries: SFML, Boost, Poco
Bubolo is a real-time multiplayer network game inspired by the 1987 game Bolo. It was initially developed over a period of approximately three months for the BU MET CS 673: Software Engineering course with a team consisting of 9 computer science and computer engineering students who had widely varying backgrounds.
High-level design uses the well-known Model-View-Controller pattern
Game entities are controlled by Controllers and observed by Sprites. Entities have no knowledge of either Sprites or Controllers.
Simple AI, collision detection, efficient 2D graphics, audio, user input, allows for n network players
The network system makes use of the Command pattern to send actions to other players. This worked well, since we used TCP, which guarantees packet delivery and order. Typically, UDP is preferred for fast-paced games, but TCP provided very good performance when combined with extensive use of dead reckoning (client-side movement interpolation to reduce perceived latency).
Implemented using an Agile development methodology coupled with a strict code review process. This resulted in a well-designed, extensible, maintainable and reliable system.
364 unit tests + 13 integration test applications + 2 end-of-sprint test applications
The following systems were designed and/or implemented by me:
The MVC relationship between the Graphics System <-> the World/Model System <-> and the Controllers [Design]
Graphics system [Design; Primary implementer]
Network system [Design & Implementation]
Controller system [Design; Partial implementation]
Audio system [Design & Implementation]
In-game UI Screens (i.e., those inside the OpenGL window) [Design & Implementation]
The algorithms were implemented in Java. Two applications were created:
The first application enables the user to set a number of variables and generate a heightmap, rendered in 2D, using the diamond-square algorithm.
The map can be edited by using the dropping particles (Particle Deposition), which increase the height of the target area and surrounding areas.
Once the user is happy with the results, the heightmap can be exported as a grayscale image. This application uses the libgdx library.
The second application processes the grayscale heightmap and renders a 3d world, which the user can explore in real time. This application uses jMonkeyEngine.
Latency & State Consistency in Networked Real-Time Games
This project was created as part of the CSCI E-72 Computer Graphics course that I took in Fall 2013. This is a first person game prototype, with an indoor and outdoor area. It has the following features:
Textures & lighting
User interaction, such as opening doors and shooting projectiles
Moveable camera with mouse look (though pointer lock wasn't implemented)
Zone-based system to reduce cost of collision detection and to turn particle systems on or off