Constantly nurturing my creative expertise in computing and technical topics.
I'm a self-starter, capable of adapting and learning anything very quickly.
As a hobbyist, my leisure activities often enhance my performance at work.
Digital Design Lab — microcontrollers and circuits
Operating Systems — application interfaces, process scheduling, memory mapping
Computer Architecture — Pentium-like architecture, pipelines, C ↔︎ assembly
Staff Software Engineer
ESO Analytics presents visualizations of EMS data from an OLAP database.
It uses AngularJS and HighCharts to display line and bar graphs as well as
tabular drill-through reports.
I came in the last 6 months of this project and made several aspects performant and
compatible with many more browsers.
Patient Outcomes is an AngularJS app for displaying HL7 outcome information recieved from a hospital.
The outcome information is linked to EMS records to present a more complete picture of the continuum of care.
It includes a view tracking system to remember which EMS providers had viewed each
The report viewer is a mobile capable split view that renders the outcome information and the PCR side-by-side
using Mozilla's PDFJS.
EHR is the flagship application of the company.
It is used to document EMS patient encounters in the field.
It uses AngularJS and has a host of complex custom controls and input formats that I implemented such
Several modal types — shelf, dialog, and (Texas) toaster dialogs for branching input contexts.
A 3D anatomical family of models that can be intertially rotated with RXJS and marked with injuries and ailments.
Searchable single and multi-select panels.
A vitals capturing system with animated face pain scale.
A quick-entry treatment, assessment, and alert system with dynamically generated lightning effect using a 2 dimensional midpoint displacement algorithm.
This would later become the seed for the ESO Angular Core controls project.
I wrote a majority of the front-end including the 3D anatomical family, vitals capture, lightning effect, and many of the custom controls.
This is an administrative console for self-service management of all the application at the company.
It was completely rewritten using a site-map strategy with a fuzzy search index. This application
uses the core component framework, ESO Angular Core, developed in AngularJS.
ESO Fire Incidents
Next to EHR, this is the second most complex front-end application in the company. The most interesting
aspect of this app is dynamic validation on every front-end value change. The number of rules potentially
run on a keystroke can be hundreds and a full validation set in the thousands. All the rules are run
using an injection technique for the data, each being a pure function. The rules are run in a web worker
so that there is no performance effect on the UI thread while the user interacts with the application.
This application was the first to use the AngularJS core component framework, ESO Angular Core, distilled from EHR.
ESO Fire Inspections
Used for fire inspections of any kind of property such as a restaurant, apartment complex, etc.
The most interesting aspect of this application was a massive set of fire codes downloaded to the front-end
and indexed for fuzzy searching within a trie data structure. This application uses AngularJS and ESO Angular Core.
This application is a way for fire and EMS organizations to document community events and
operational activities at their stations. It uses Angular 10 and the associated ESO Core framework.
ESO Login and Identity Service
This is a complete rewrite of the log-in experience to accomodate SSO and two-factor authentication.
I wrote all the front-end and web flows. It uses Angular 10 and ESO Core.
ESO Patient Tracker
This application is used at the hospital to see incoming EMS patients. It is also used from the hospital
perspective to associate patient outcomes at the hospital with ePCR records.
ESO Angular Core
This is a complete custom component framework for ESO applications written using AngularJS. Components include
text, number, and date inputs and calendar pickers with custom validation, many modal types, masked inputs,
single and multi-select components with search indexing, a signature input component using RXJS, and many others.
I also wrote a documentation generator using the same generation framework as the AngularJS project, dgeni.
ESO Core is a port and evolution of the ESO Angular Core framework but using Angular 10+ and very idiomatic
Angular. Any web developer familiar with Angular can use Core easily as it implements Control Value Accessor
and other appropriate interfaces for input control types.
Senior Front-end Engineer
Internal Developer API Portal
This portal was a way to aggregate the many sources of internal API documentation at the company.
A database aggregated many forms of API documentation into an abstract form and a Node
backend generated a unified view of all of the documents as well as links back to original
I was the sole front-end developer for this project.
3rd Party JS Suite
This was a POC that I created for the purpose of making 3rd party applications at PayPal
easy to create, deploy, and test. It integrated EasyXDM for more advanced cross domain
communication on a 3rd party merchant site through several early pre-CORS cross domain
PayPal Identity — Log In with PayPal
The PayPal Identity project was a system to provide not only PayPal log in to 3rd parties,
but also a risk system that could identify fraud. The original notion of this is to
bring a verified financial element to federated identity. Merchants using PayPal as an
identity provider would know that authenticated users weren't fraudulent and had valid
financial instruments protected by PayPal in order to shop.
I did the user interfaces for the log in and verification web flows, the
training material and demos of developer APIs and implementation of the product.
Adaptive Payment is a PayPal payments platform that enables a consumer to craft
many complex payment scenarios such as parallel and chained payments through an API.
It allows merchants and contractors to split payments to be fulfilled
in parallel with configurable amounts for each recipient. It also supports chained
payments for scenarios like subcontracting.
My job was to supply the web flows and email content which explained and guided end-users through
these more complex payment flow processes. Progressive enhancement was used so that all web flows
right-to-left support for support in Israel.
a suite of Bash scripts to navigate a complex development environment topology.
Manageability Firmware Developer
Superdome 2 Onboard Administrator
Created a before-its-time web application for system management on the HP Integrity Superdome 2.
The Superdome 2 is a high-end cellular blade system with configurable electrically isolated partitioning.
This machine was completely new and the interface was developed alongside the hardware and firmware.
A small single-board computer manages the entire system of up to two cabinets with 16 blades.
The computer is an embedded linux computer built around a PowerPC system on chip.
This computer and the web application is known commercially as the Onboard Administrator (OA).
Much of the mid-tier portions of this project were outsourced.
I organized the work and was effectively the project manager for the entirety of the web management interface.
The development environment was Linux x86 where C and C++ code was cross compiled to PowerPC.
This predates the use of MVC web frameworks and supported browsers back to IE6.
The web client uses XHR and communicates with a C-based gSOAP binary through CGI.
This C binary communicates with various system management firmware Linux applications to retrieve
health statuses, general information, cooling status, thermal data, and configuration data for
all of the components.
This SOAP binary also provides the interface with commands used to change system settings and configuration.
I developed a mock application in C for the SOAP interface that also managed client user sessions.
The mock application allowed the web UI to be developed ahead of all of the system monitoring and configuration firmware application.
This application used a Perl SOAP deserializer called Expat to manipulate data into interesting XML responses used to unit test and debug the "DHTML" web client.
I devised an embedded test application within the product itself which intercepted polled system events (XHR long polling).
It presented an editor in the browser where the XML could be modified before resuming the subscribed code that consumed responses.
Surprisingly, this product was not assigned a designer.
I created the photographic representations of all the server components complete with
dynamic device presence and health indicators (images of devices, blinking LEDs, status icons, etc).
The visualization represented exactly what a technician would see when they approached the machine
in the datacenter.
Firmware Test Engineer
Superdome 2 Management Firmware Test Infrastructure
Used Perl and MySQL to design, implement, and maintain a test infrastructure which supported other test developers.
Designed and implemented a MySQL schema for test log storage and result analytics web applications.
Database design was optomized to 4th normal form using knowledge and techniques from Database in Depth by CJ Date.
Date was a protegé of the father of the relational model, EF Codd.
Database was tuned using diagnostic tools and techniques like MyTop, query cache monitoring, and cache sizing modifications.
Test results, metrics displays, and triage data were presented and edited from small web applications.
System Validation Test Engineer
System Validation Test
Wrote test code using TCL/Expect, shell and Perl to perform a variety tests on HP SuperDome products.
Automation included functional and stress tests.
Configuration inventory, programmatic configuration, and state discovery was used on tests and reused in
several groups for other testing and development by QA and hardware design engineers.
Tests were performed at system management firmware, OS interface firmware, and OS levels.
Tests at the OS level were performed on HPUX, Linux, and Open VMS Operating Systems.
Manual tests were performed on Datacenter and Enterprise versions of Windows.
Q — System Validation Test Orchestrator
Rewrote most of an internal test queuing and launching TCL/TK GUI utility.
Created a web (Perl) based front end for jenny,
a pairwise set generation tools to aid combinatorial test planning.
Land or Die! (2013)
A Lunar Lander game done for One Game a Month. The idea was to mimick vector graphics similar
to the original Atari arcade game. This one is in color and features randomly generated terrain.
WASD controls with Q and E to strafe left and right respectively.
Play Game: digitalicarus.com/lander View Source: github.com/digitalicarus/lander
A raycasting proof of concept using a technique used in Wolfenstein 3d and Catacombs 3d.
I was inspired by the
and Lodev tutorials.
I wanted to use the original techniques instead of OpenGL/WebGL so this uses the
2D canvas context.
This also uses the field of view and user rotation configuration to precalculate trig tables, which
makes the texture lookup quite fast.
Play Demo: digitalicarus.com/caster View Source: github.com/digitalicarus/caster
As I explored browser-based games I sought out others locally.
I wanted to share and explore with other people. I started a group called Austin Web Games.
Shortly into the endeaver, after two meetups, I realized that there was a lot of interest but
not a lot of people actively exploring making browser-based games.
So, I hosted a workshop where I explained how simple game loops and physics worked. I supplied
the most minimal pure JS platforming game that I could.
The plan was to have everyone fork the repo and make some creative changes. People seemed
happy and had a lot of fun. There were a couple father-son teams too.
Play Game: digitalicarus.com/lilgame View Source: github.com/digitalicarus/lilgame
I wanted to make a talk that was inspiring and wouldn't be stuck to the particular place and time in
The theme of the talk is to look at old tech and techniques to get inspired. In it I describe my
travels through older tech books to learn interesting techniques to apply in modern languages and
contexts. I encourage listeners to examine old algorithms and techniques to expand their minds,
have fun, or apply an old technique to a new problem or context.
implementation of Microsoft Office's famous Clippy assistant to remind myself and watchers of the
presentation of the notes I had made for each slide. The slide window minimizes for live demos.
See Slides: digitalicarus.com/thunderplains2013 View Source: github.com/digitalicarus/thunderplains2013
I wrote chapters 4 through 10 and my very good friend wrote an excellent forward.
It was early days of React and the ecosystem was very volitile.
I rewrote many portions many times as the APIs and idiomatic usage shifted.