Computer Graphics II Projects

During my last year as a software engineering undergrad I took a graduate-level course in advanced computer graphics using OpenGL. Each student was required to implement a ray tracer from scratch in order to render a scene similar to Turner Whitted's classic example of transmissive and reflective spheres. A record of my progress is posted on the LiveJournal (tag: raytracer) I kept for the class. The image to the right was the final product.

My personal research project during the class was to implement a particle system from scratch to animate realistic looking fire. I applied a texture map to each particle to give it shape and definition detail. Also, the texture map was necessary to provide the alpha channel used for alpha blending. Various system parameters can be modified in real time to give the particle system the appearance of a lava lamp or even multi-colored fireworks.

The project details are posted on my LiveJournal (tag: openfire). I named the project OpenFire because the source code is available free of charge to the open source community. If modified, all I ask is that I be credited in the source code comments.

Resources:

• Research paper on simulating fire in computer graphics (DOC)
• OpenFire top-level report (DOC)
• OpenFire users guide (DOC)
• OpenFire technical document (DOC)
• OpenFire presentation (KEY ZIP)
• OpenFire source code (ZIP)

I also dabbled in a little bit of Pixar's Renderman technology. There was a student competition to see who could create the most interesting image. I won second place for my abstract rendition of a woman's head and brain! Check it out on my LiveJournal (tag: renderman).

Bachelors Senior Design Project: GridShell

My software engineering capstone project at the Rochester Institute of Technology involved developing a command-line shell to allow easy access to distributed computing environments, namely grid resources such as the TeraGrid. The project was part of a development effort put forth by the RIT Center for Advancing the Study of CyberInfrastructure (CASCI).

GridShell was one of many projects spearheaded by Cyberaide, a community of researchers and organizations interested in advancing cyberinfrastructure to promote collaboration between individuals and providing them with the computing power necessary to deploy and execute processor-intensive programs for scientific research.

The GridShell provides uniform syntax and semantics for creating, submitting, managing, and checking the status of tasks deployed to local and remote Unix resources. It simplifies workflow management by allowing users to execute tasks sequentially or in parallel and allowing users to specify dependancies between those tasks, which places a constraint on their order of execution.

Additionally, users can create scripts in Python to specify task order execution, which is useful for more complex jobs. This is because the GridShell front end is implemented in Python and can execute Python code natively in the command-line interpreter (CLI). Specifically, the CLI is based on the IPython environment. In turn JPype is used to establish a functional language binding between the Python front end and Java back end.

Java was chosen as the back end language in order to leverage existing web service technologies written in Java and utilize other Java utilities. Ultimately, our goal was to provide multiple interfaces to the underlying GridShell task management framework, including the traditional terminal interface as well as a web interface, MATLAB interface, Ruby interface, etc. For the web framework we decided to use a deployable Apache Axis2 web server with Rampart security.

Resources:

• Poster
• Technical paper (DOC)
• Demo notes (TXT)
• Demo 1
• Demo 2
• Demo 3

Finite State Process Autocoder

As a software engineering undergrad who was part of the honors program at RIT, I was required to complete an independent study. At the time I was taking a course in concurrent systems and was making extensive use of the Labelled Transition System Analyzer (LTSA), a concurrent system modeling tool which uses Finite State Process (FSP) algebra notation to represent component behavior.

Once a system is specified in FSP notation, the LTSA can parse and compile the FSP notation to generate a graphical Labeled Transition System (LTS) model. The LTSA also provides a means to “animate” the system by performing discrete or shared process behaviors one at a time and stepping through the states of the system. Under the hood, the LTSA generates and stores an internal state machine representation of the system.

One of the major difficulties encountered by software engineers who use the LTSA is deciding how to translate the FSP system representation into an executable implementation. A common practice is to use the LTSA as a system design tool and to deviate from the FSP during the implementation phase in order to create a custom-tailored system from the ground up. The major disadvantage is that the implemented system may no longer exhibit the same behavior as the FSP and therefore will need to undergo an entirely separate, and more complex, verification process.

Clearly, it is advantageous if the system implementation reflects the original FSP design. At the time when I was conducting my independent study there was no widely accepted procedure for converting the FSP into source code. I began developing the an automatic code generation backend called the FSP Autocoder to use the LTSA to parse FSP notation and perform semantic analysis to produce code stubs for primitive concurrent objects.

Before I could begin working on the compiler aspect of the autocoder, I needed to design a “universal” (i.e. widely applicable) concurrent system architecture that could be traced back to the FSP system representation and vice-versa. I considered many approaches, such as employing a state machine architecture, rendezvousing threads in conjunction with a round-robin thread scheduler, and using a Communicating Sequential Processes (CSP) library.

Resources:

• Technical paper (DOC)
• Presentation (PPT)

Work History Part 3: MITRE Corporation

Employer: MITRE Corporation

Location: Bedford, MA

Position: Network Software Engineer

Period: June 2007 – August 2007

MITRE Corporation is a not-for-profit organization that manages Federally Funded Research and Development Centers (FFRDCs). I worked for the Command and Control Center (C2C) as part of the Tactical Edge Solutions group.

I worked on the MIDS LVT 1 MultifunctionaI Information Distribution System (MIDS) Low Volume Terminal (LVT) radio developing an interface that would allow messages to be passed between the radio network and an application running on a host machine. One application was a situational awareness visualization.

Responsibilities and accomplishments:

• Implemented a gateway between military radio networks and the Global Information Grid using an enterprise service bus.
• Programmed a Java controller to exercise the MIDS Low Volume Terminal Platform D Ethernet interface.
• Configured terminals using time division multiple access communication method.

Work History Part 2: Excellus Blue Cross Blue Shield

Employer: Excellus Blue Cross Blue Shield

Location: Rochester, NY

Position: Java Technology Specialist

Period: June 2006 – November 2006

Excellus BCBS is New York State's largest nonprofit health plan. Their e-service production website provides a claims processing workflow used by patients, medical professionals, and insurance agents.

During my employment the website was relying on backend services implemented in a legacy COBOL architecture. Steps were being taken to replace the entire backend with a modernized J2EE event-driven architecture.

Responsibilities and accomplishments:

• Developed long-range service-oriented architecture goals for a legacy software system.
• Investigated and compared the benefits of utilizing modern software technologies such as J2EE and Apache Struts.
• Analyzed and implemented solutions for problems regarding the Excellus /Univera e-service production website.

Work History Part 1: Harris RF Communications

Employer: Harris RF Communications

Location: Rochester, NY

Position: Software / Firmware Engineer

Period: May 2005 - November 2005

Harris specializes in developing communications equipment for the DOD, including RF communications, SATCOM, and GPS networks.

I worked on maintaining and developing the FALCON II RF-5800H-MP HF/VHF manpack (MP) radio. Nowadays Harris is focusing on the development of the FALCON III series. The newest member is the FALCON III RF-7800M-MP multiband manpack radio.

Responsibilities and accomplishments:

• Analyzed and implemented solutions for problems regarding the FALCON II manpack radio state machine, radio programming interface, and front panel display.
• Wrote Visual Basic scripts to test radio to phone communication, UDP transmissions, and GPS synchronization.
• Analyzed and tested C++ code to remove memory leaks.

Hello World!

Now that I've finally completed my masters in computer science from the Rochester Institute of Technology Golisano College of Computer and Information Sciences, I figured it's a good idea to keep a record of all the cool projects I've worked on over the years. This blog will serve as a personal portfolio and more organized alternative to jotting down notes and how-to guides in miscellaneous text files.

Plus, this way I get to share my knowledge with the world - which will make me feel better knowing that others may benefit from the next 5-hour impromptu code-review session necessary to compile that must-have bin util in the latest version of Ubuntu. Yeah, all you geeks know what I'm talking about.

Like most CS geeks these days I know quite a bit about HTML and web programming, so I was faced with the decision to create my own website from scratch or to use a blogging site like this one (Blogger). Being the type of guy who likes to drive standard shift in a world where standards are quickly being phased out for automatics, I usually like to have as much control as possible over my craft (pun explained: craft as in my vehicle and craft as in my professional activities), but in this case I've decided to relinquish the reigns and go for the simple and easy solution. Besides I don't want to be distracted by the task of maintaining a website on top of everything else. Also, Blogger looks pretty (with the right settings).

As geeks we have an insatiable desire to know every intimate detail of a piece of technology, be it a car, iPhone, printer, Linux kernel, or web service. It's not enough to sit behind an interface and know how to use something; we want to know how it works! Sadly none of us has the time or energy to satisfy our every geek craving. We can't write all of our programs in assembly instead of C or spend our time reverse-engineering device drivers when something doesn't work the way we expect it to. We can't go through life with use strict; on all of the time; sometimes we have to take a more casual approach and accept things as they are. No one ever said that being a geek is easy!

Note that I intentionally changed the date of this post so that it's the oldest and appears first in the blog archive. The dates of other posts may have been changed to reflect a representative date when I completed a project or an employment period ended.