Portfolio

This is a quick summary and portfolio of some of the more interesting projects I’ve been a part of or solely responsible for, most recent first.

iOS GLKit Muckery (Personal Project)

This is a quick little iOS application I created to play around with two iOS frameworks I hadn’t used before. GLKit, and UIRecognizer. It’s a simple cube written using GLKit that includes textures, lighting and gestural control. Tap to toggle texture, double tap to toggle lighting, pinch to zoom in/out, drag to rotate the cube on the X and Y axes, and rotate with two fingers to change the texture. iOS 5+, and code will be available here in a couple of weeks when I get a chance to post it to GitHub.

Auroral Resources Toolkit (NOAA)

I am the lead developer on this ongoing project, tasked with providing data, metadata and visualizations to the auroral science community. An entirely new UI was created for this project, with the intent of reusing it later in other projects. The back end utilized existing RESTful web services from the SPIDR project (below), as well as its databases. Lots of additional middleware (new services, formats etc.) was created for this project however, in addition to the new web application UI. This project is a collaboration between NOAA and The Russian Academy of Science Space Research Institute. The back end is MySQL, the middleware is all JavaEE deployed on Tomcat, and the new front end is JavaScript. For the UI, I used a lesser known JavaScript application framework called QooxDoo (Qx), which panned out extremely well on this project. It incorporates things like URL shortening for the sake of sharing a workspace, and even has a Google App Engine cloud caching proxy prototype. The cloud variant obtains data from SPIDR, caches it for 24 hours using memcached, and displays it normally to a visiting user. Not all of the widgets function through the GAE prototype as it wasn’t possible to develop it beyond a technology demonstration/prototype. The entire project is open source, and is hosted on Google Code. I was solely responsible for the UI and large portions of the middleware.

Command and Data Handling CubeSatellite Firmware (University of Colorado)

As an independent study project as part of my Computer Science Masters program, I led a software team which was responsible for developing the command and data handling portion of a CubeSat’s flight software. This software is responsible for gathering data from a variety of sensors (voltage, temperature, etc.) and the science instrument, and both storing it, and responding to commands to send it to the ground as the satellite orbits Earth. MSP430 embedded development, with copious amounts of SPI and I2C shenanigans. All final development was done in C, although some prototype work was done on the Arduino platform.

Space Physics Interactive Data Resource (SPIDR) (NOAA)

I am the lead developer and primary maintainer of SPIDR at NOAA/NGDC, and responsible for the application soup to nuts. It’s a JavaEE application deployed on Tomcat, and uses MySQL as a back end. The Application began as a front end, but over the years has evolved into more of a middleware application providing web service access to data stored in databases and robotic tape libraries. Many of the enhancements I’ve been responsible for focus on the middleware and web services layer, very few front end improvements have been made to the application. SPIDR houses a variety of space weather related data and metadata including time series and imagery granules, and provides data set specific front ends for accessing each. The web services layer includes everything in its API from image plotting capabilities to granule retrieval and asynchronous time series streaming. SPIDR is an open source project available on SourceForge.

RealTime Ionosonde Visualisation (NOAA)

This is a small ongoing project for which I was the lead software developer, and collaborated with internal scientists to provide a visualization of the latency and measurements of their incoming real-time data. It was a smaller project, but resulted in an interesting visualization and separation between web application and behind the scenes resource generation. The front end is HTML and JavaScript. The back end which generates a KML and plots is done behind the scenes entirely server side. A map tile server provided by another group within NOAA was used for the map’s base layer. Since the front end is entirely JavaScript, it’s statically hosted by Apache HTTPd. It provides direct access to live measurements, as well as recent historical trends and imagery. The code base includes a comprehensive set of unit tests via jslint, and a few basic automated UI tests via Selenium.

Ionospheric Inventory (NOAA)

This was a small, quick project in collaboration with a science group at NOAA. I was the sole middleware and front end developer, but the science team created and populated the databases. The task was to visualize a database based catalog of data in a tabular color-coded form. It provides two form based query mechanisms, a quick and advanced variant, and allows an interested data customer to determine what holdings are available for a particular query for which they desire data. It aggregates information from several databases to provide a single central view of available information. The front end is JavaScript and utilizes the Dojo toolkit. The middleware is a Ruby on Rails application which connects to Oracle and MySQL databases. In addition to the simple web application front end, it provides a web services layer that can be used directly as an API. Sample clients exist for Java, Ruby and Python.

Feature Detection of Nighttime Lights (NOAA)

Computer Vision has a lot of interesting potential applications, and this was a specific area where I did some investigation of CV algorithms. Further, because of the computationally intense nature of these data and algorithms, I also explored the possibility of using GPU (OpenCL specifically) implementations of the same to cut down run time so the application could be used as part of the group’s regular work flow. The Earth Observation Group uses nighttime lights data to put out a variety of products and services, and the faster and more accurately they can do that the better. These products are used to estimate GDP, observe gas flaring, aide disaster response, etc. The more interesting algorithms were the GPU based SURF, and normal MSER Blob detector. MSER yielded a topography of light intensity rather handily. These are some grabs from a presentation I gave that explained the project and work I did, and specifically several of the algorithms.

3D WebGL Earth Project (Personal Project)

This is a quick application written in JavaScript using WebGL to play around with WebGL
a bit. I added points of interest, a nighttime lights texture and daily automatic grabs of cloud data
for the cloud texture. It’s a modified version of an existing WebGL demo, designed to show everywhere I’ve been in the world.

Simple 3D OpenGL Game Project (Personal Project)

I wanted to start getting some exposure to OpenGL, and decided to implement a simple little shooting game to do so. This project was a relatively small and quick, but fun exercise. It’s written in Python, and utilizes PyGame for its foundation. All graphics are OpenGL. This was a small personal project, so was entirely done by me soup to nuts, textures, sounds, code etc. Nothing too fancy, but there were some interesting things I learned in creating it. One was hit detection, which I ended doing by using an invisible color layer, wherein each object is colored uniquely, and prior to doing the full rendering the color at the crosshair’s center is sampled to determine if an object is underneath. If so, the object in question has been “hit”. PyGame and OpenGL have picking and hit detection mechanisms, but they’re more complex and difficult to use and implement. Seeing as I only intended to have a handful of objects rendered, my method worked extremely well, and efficiently. This small project’s code and resources are all available on google code.

qBAC – quick blood alcohol concentration estimator (Personal Project)

This is a simple iPhone application I did a while back. It’s actually a rather unusual app for me, seeing as I myself am a teetotaler… It was the first App I published to the App Store, and while it didn’t make me rich, it continues to pay for my yearly Apple Developer fees with the modest revenue it generates. It’s a quick and simple blood alcohol concentration estimator that allows you to modify various parameters of that equation and immediately see the results. As it’s an iPhone application, it is written in Objective-C, and makes use of the iOS SDK.

Forward (Personal Project)

Forward is a simple iPhone application that uses portions of the private API to modify call forwarding settings. The default system utility iOS provides is burried and takes a long time to ferret out and enable/disable. I wanted something quick and easy. Since it uses the private API, this application is not/cannot be hosted on the App Store. It includes a menubar icon that indicates forwarding status, and provides a single step toggle to enact any changes and modify the number to which forwarding takes place. I had plans at one point to have the application automatically forward based on locations. For example, forward to an office line when in the proximity of your office, a home line when in proximity of your home etc… I opted to leave the app as is however, rather than trying to host it on the Cydia store (Jailbreak/unofficial store), and pursue other applications that were more viable on the official App Store.

Swarm (Personal Project)

Tilt, touch, outlast, and win. Swarm is a simple game I created to utilize touch events and the accelerometer in iOS devices. If you’ve seen the old XWindows (not sure how far back beyond that it goes even) screen saver, then it’ll look familiar, that’s where I got the idea. This game was first sold in 2008 on the AppStore, but I took it down in 2010 due to a complaint made by a Canadian game company regarding the name. They had an identically named game in development at the time (but not yet for sale), and put a take down request in with Apple. They didn’t contact me directly first, but no matter, I responded to them directly and said I’d take the game down in exchange for withdrawing the notice with Apple, which they did. Being a lone developer, I didn’t feel like dealing with Apple or these folks, and opted to make it all go away quickly and easily. However, the way trademark law works in the United States, I technically was in the right and could have fought back. According to the law in the US, the first item FOR SALE has rights to the name. It doesn’t matter that their game had been in development before 2008, my app WAS for sale from 2008 – 2010, and in fact was for sale 3 years prior to theirs ever hitting the market. Oh well, like I said, no point fighting that over a game that wasn’t generating much income anyway. Similarly to my other iOS work, all Objective-C, iOS SDK, and again I did everything soup to nuts on this one.

CoconutMonkeySoftware (Personal Project)

CoconutMonkeySoftware is a sole proprietorship I started to do 2 things. Sell iPhone applications, and provide software consulting services. It has been successful on both fronts. I personally published the two applications listed above to Apple’s AppStore, and have consulted on over a dozen for a variety of companies, and have consulted beyond iOS projects on a variety of software projects under the CoconutMonkeySoftware banner. I managed to muster some friends to the cause as well, an artist friend in particular who helped make some of the App Icons. As a part time entrepreneurial effort, it has been extremely rewarding on many levels.

irudite.com (Personal Project)

irudite.com serves two purposes for me. It’s both a technology demonstration and a photo print site, from which archive quality photo prints can be purchased. The photos available are more for demonstration purposes than anything, the site is really around still to serve as a tech demo. The base of the site is Magento eCommerce, which has been modified to support AJAX calls behind the scenes to dramatically improve the user experience. Namely, without my software changes, a user would browse the gallery, click add to cart, be taken to another page, and have to navigate back to the gallery. With my AJAX additions, a user simply makes their selection within the gallery, chooses ‘Add to Cart’, and it happens behind the scenes letting them know it’s in process however. This was the big addition, but there were other minor changes and additions as well. I did this one soup to nuts, hosting, certificate purchase, site maintenance etc. The modifications to Magento are all PHP, the back end is MySQL, and of course a fair bit of markup and CSS for the site itself. I posted a few print-like photos I’ve taken over the years just to show the technology. I live it up as a tech demo and talking point. All site imagery and design were me as well.

Jpeekaboo (Personal Project)

I am a big advocate of using some piece of software which is always at ones immediate disposal for quick text copy + paste and note taking. For a long time I used Apple’s Stickies to serve this need for myself. Over time, Stickies wasn’t sufficient because it was tied to a single computer, and I needed something that worked and synced across several. So, I created this application. It’s a sticky note that pins to either side of the screen, and auto-hides when it loses UI focus. It syncs with Amazon S3, and can be used on any platform that supports Java. It includes a menu bar/system event box icon that allows for configuration. Another interesting aspect of this application is that I created a build setup that generates binaries for all the major platforms. Source code and binaries are available here.

PWSideNote (Personal Project)

TBD…

Robotic Tape Libraries SL500, SL3000, SL8500 (Sun Microsystems, Inc.)

My role on these hardware products was also more a design verification role, as it related to integrating them as a component of intelligent archive software utilizing solid state disk, spinning disk, and tape cohesively. I created a wide range of integration tests that interacted with and drove the libraries to do certain things. These included simple movement and typical use cases, to automated long term performance testing. Some of the by products and results of the tests were incorporated into the firmware by the library firmware team. The robotic tape library firmware is Java and runs on embedded Linux. I made and loaded custom builds to accomplish some of the goals involved in the integration work for the archive software stack. Working with the robots was rather amusing, especially setting up and performing my automated performance tests, which really got the libraries jumping. My integration tests ran against all three model tiers, the SL500, SL3000 and SL8500, each in varying configurations therein. The archive software I was a part of doesn’t have any GUI or screenshots available, so showing the pieces related to it are all that can be done.

Streamline Library Console (Sun Microsystems, Inc.)

I contributed to this application more in a design verification role, as it related to the needs to interact with the robotic tape library products that the archive software team I was a part of needed to integrate. It’s a Java Swing application that serves as the administrative application for configuration and managing an SL500, SL3000, or SL8500 robotic tape library. My software team collaborated closely with the software team responsible for this product, and interacted to add new features and fix bugs. On a regular basis I was creating custom builds of the software to prototype the features my team needed, and providing feedback on bugs and improvements to the team responsible for the codebase.

VerbalAssistant (VerbalWorld, Inc.)

While at VerbalWorld, I was the senior software engineer responsible for creating a VoIP SaaS platform from the ground up. I did so using a variety of open source software, custom in house software, and glued it all together to create a speech enabled VoIP platform. This platform was used to create several product offerings for sale. These projects ran the gamut, JavaSE, PHP, C, MySQL (cluster engine), and a large number of open source projects include Asterisk. Machine to Machine interfaces were utilized to provision and order phone numbers on behalf of users, accomplished by way of SOAP web services and APIs provided by major telcos. The Asterisk AGI interface was used to tie into a OO Perl application framework I created for the applications to easily be built and modified. The products ranged from things like VerbalAssistant (think Google Voice to a real estate application for realtors to include automated descriptions of their listings. VerbalAssistant provided a web based interface to configure each user’s service as they saw fit, which then immediately responded in the voice application. For example, it can be configured to act as an gateway office PBX, with speech enabled call routing for employees in an office. Or, as a simple call screener for a single user that greets unknown callers with a prompt and some questions, or passes known callers straight through.

JTrack3D Fork (LASP)

The JTrack3D fork was a project I personally pursued at LASP. The codebase was available via request through NASA’s Marshall Space Flight Center, and I went through the months-long formal process of obtaining code and permission to modify it. The project originally showed a variety of Earth orbiting entities, I tailored it to LASP’s needs by adding ground stations, the day-night terminator, orbit information, automatically updating TLEs (two line elements, basically satellite position information). I added new features like the diagnostic graphics as well. It was used as an internal tool by the operations team to visualize the satellites orbits and information during day to day operations. The application is 100% Java, and I implemented a fully cross platform build setup for it that created executables for Windows, Mac, Linux and Solaris on each build. LASP at the time had people actively using Windows and OS X on laptops and workstations and Solaris for operations. The project was interesting for a lot of reasons, but one of the more interesting aspects was the math involved in defining the day night terminator. Additionally, it animates the orbiting bodies, it is not a static view, but one which updates in real time relatively accurately. The project was originally a web accessible Java applet, so in addition to my modifications I converted it to a desktop application.

Operations and Science Instrument Support – Planning and Scheduling (OASIS-PS) (LASP)

This application was originally a legacy project written in Ada. Myself and several members of the project team were tasked with implementing the existing functionality, in addition to a large range of new features in Java. This application comprised most of my software effort while at LASP, and was on the order of 500,000 lines of Java at the time I left LASP. The software looks at a variety of values relating to a satellite orbiting Earth, and decides how best to schedule the satellite’s maneuvers and science instrument measurements to maximize science return. For example, if Earth is obscuring visibility of the moon at the current point in the orbit, the software would not schedule an observation of an instrument looking at the moon at that time, and would perhaps position the satellite so it’s pointing away from Earth at a particular star or stars at that time instead. This schedule is then output in a satellite specific format so that it can be uploaded to the satellite and loaded into the satellite’s schedule of things to execute, typically every few days or in some cases up to a week. The entire application was implemented in Java, and has a Swing based GUI. The back end is a Sybase database. This application is still used by several satellite missions to take various inputs, process them, intelligently decide the best way to maximize science, and output a satellite specific loadable execution plan. The user interface displays the automatically/algorithmically generated plan, which is fully draggable/droppable by the operator for fine tuning.