Andrew Trusty

I went west this summer for an amazing internship at Google. I worked on the Google Base development team as a software engineering intern. I did some really interesting work with my host Deepak Lachwani and some other really cool Googlers on a generic image quality classification system for internal use. That is about all I can say about my professional activities there given their ‘loose lips sink ships’ policy of external communication. Overall, it was a really challenging and rewarding environment though, especially since I went in thinking I was working in Java and then I had to learn C++ during my first few weeks.

But being there in the middle of Silicon Valley on Google’s main campus, it really felt like you were at the center of the technological wonderland. In every direction, you see buildings with the logos of the technology giants and at their feet they are surrounded by dozens of startups, familiar and unfamiliar. There is a noticeable energy and excitement exuding from the people working there. At Google, the concentration of intelligent, capable, and driven people was amazing. And at the rate they are hiring, you can and sometimes do meet a few new and interesting people every day at one of the many amazing cafés. I met a lot of other interesting people from all over the world, interns and full-timers and non-Googlers, whom I hope to keep up with.

Continue reading…

I started working with a new research group in the Cognitive Computing Lab under Ashwin Ram this semester. The project I am working on is concentrated on using Case Based Reasoning techniques to easily develop AI opponents in video games. We are using Wargus, an open-source mod which allows you to play Warcraft 2 using the open-source Stratagus game engine, as the platform for our CBR research.

My contribution to the project was to develop a map classification system for Warcraft 2 maps which would provide additional features for the CBR engine. The system is a joint project between my Pattern Recognition class professor Jim Rehg and the CCL researchers Santi Ontañón and Manish Mehta. It was also a good starter project for getting more familiar with the architecture of their system since I plan on continuing to work with the group for my senior research project.

Continue reading…

Or more aptly: ML from 0 to 60 in one semester. The semester long compiler project in the Compilers and Interpreters course was arguably the largest, most structured, and diverse programming experience I have had. The course was taught by Richard LeBlanc based on the course as taught by Olin Shivers. The textbook which defined the Tiger language we were compiling was Andrew Appel’s Modern Compiler Implementation in ML.

The project was done in groups of two and we built out the compiler at the grueling pace of about one module every two weeks. We started with the lexer and parser which we built using ML-Lex and ML-Yacc respectively. We then proceeded to do type checking, translation to intermediate representation, instruction selection (MIPS), and data-flow analysis among other things. In the week before our finals, we managed to cap it all off with a serviceable register allocator.

At the end of the semester, it was an extremely satisfying experience to see our Tiger factorial code be compiled into working MIPS instructions and to watch it run. Looking back, it seems to be something of a miracle that we started from scratch and were able to put together such a system in an unfamiliar language in one semester.

I just finished a semester of research under Tucker Balch developing software to run on the Georgia Tech entry into the DARPA Urban Challenge. The goal of the DARPA Urban Challenge is to build an autonomous automobile which can navigate an urban environment as a human would. It was very interesting and challenging work with alot of other very motivated undergraduate and graduate students working to build out the platform to drive the Sting Racing team automobile. The students worked in a variety of teams concentrating on specific areas including Visual Odometry, Learning by Example, Pose Estimation, Health Monitoring, and Laser Scan Matching.

I worked in the Learn by Example team where we sought to use instance based learning to associate image-action pairs. Our team developed and tested a variety of different approaches for learning actions from images and efficiently matching to images in image databases. For my part, I implemented a smaller component of our teams overall architecture involving pre-processing of the images obtained from cameras mounted on the automobile.

I spent a lot of time researching different image classification techniques. At first, I was actually attempting to provide a very detailed classification of each image by labeling areas of the image as one of six classes: pavement, white lines, yellow lines, buildings, plants, sky. Given the real-time constraints and the high error of this approach I decided to modify my goal. After playing with a few other ideas and getting feedback from my teammates I decided to cut the number of classes down to two in order to effectively create an image mask identifying the road in the images. In this way my piece served to reduce the amount of data that needed to be processed by our other approaches.

My basic approach was inspired by a paper by Bischof, Schneider, and Pinz. The idea is to use a neural network to classify pixels of an image based only on the data available at each pixel. I used the Weka Machine Learning toolkit to train and test my neural networks. The image above shows the results of a six, three, and two class classification with each class represented by a color overlaying the original image. By the end of the semester I was able to develop a functional component that when given a camera image was able to output an accurate mask identifying the road in the image in real-time. I hope to be able to do future work on this component in order to enable it to learn online using the laser sensor data, parallelize the code to run on multi-processor systems, and output a confidence measure for the image masks.

A lot of people delay fulfilling the Technical Communication requirement at Georgia Tech. I was one of those people. I have since realized that many of the skills I learned would have been tremendously useful earlier in my college career as I was searching for internships and interning. I now feel much more confident writing proposals, reports, resumes, and organizing information in general. Much of this was due to the professor, Jennifer Wunder, who always kept the class attentive with intriguing anecdotes from her husband’s and father’s businesses.

For the final project in Technical Communication Practices, my group opted to do a seasonally appropriate guide on wrapping presents. I took on the web design component of the project and rendered our final manual into a beautiful collection of HTML pages. A link to the guide is below; note that the Google Ads are a new addition in which I am experimenting with actually making money from the internet.

An Illustrated Step-By-Step Guide to Wrapping Presents

Before this semester, I always thought I knew enough about networking and that taking the networking class would just bore me with details of various internet protocols. But, networking is a cornerstone of modern Computer Science and my peers who had taken the class had no negative feedback so I decided to brave my way through the class in hopes of expanding my understanding of networking. As the semester is almost over and I have just completed our final project I have realized how wrong I was. My previous experience with the Java Sockets API didn’t quite prepare me for what was going on under the hood. The C Sockets API is much less forgiving as are all things in C. I now have a much stronger grasp on the mechanics of networking and I know the details of all the modern networking protocols.

The final project for Networking I taught by Mostafa Ammar and Russell Clark involved designing and implementing a protocol for reliable file transfer over UDP sockets in C. I implemented the Go-Back-N ARQ protocol on top of UDP to provide reliability. Other than this my protocol is relatively straightforward. I created two separate applications, a client and a server. My implementation only supports one way transfer from the client to the server and only supports one client at a time. The minute details are available in the README in the below archive of the source. The code was developed on and should compile on standard Linux machines.

UDP File Transfer Source Code