Defining Projects

When asked to describe myself, I often like to let my work speak for itself. It is highly impractical to chronologically list every project I've worked on for nearly four decades. Many of them are boring, 'pay the bills' projects and about 40% of my self-employed work has been for NDA clients.

I believe it's better to choose a list of defining projects over the years that best describe my value proposition; a proposition that has been proven over multiple decades and multiple technology stacks. This list is weighted more heavily towards recent work in the modern web.

ASSEMBLER

I spent a dozen years in the high-performance computing industry, five of which were devoted to assembly-language math libraries for supercomputers. Signal and image processing applications were a huge part of this industry. The Fast Fourier Transform is one of the most important algorithms in this space, and the most difficult to implement on a vector processor, especially with an interleaved memory system. I wrote two versions of the one-dimensional FFT using a constant-geometry algorithm before finally having six months to devote to solving memory issues with this algorithm. The final work produced a 2X performance increase for large FFT's and was published in the Journal of Supercomputing,

https://link.springer.com/article/10.1007/BF00156677

FORTRAN

My Fortran experience spans the entire gamut from Fortran 66 to Fortran 90. I really liked the array syntax and my favorite project was an implementation of a 2D difference method for the Maspar massively parallel computer. The compiler used a cut-and-stack algorithm for mapping multi-dimensional arrays onto a 2D grid of processors. This one was fun because it involved both performance tuning and visualization. The work became one of the most popular demos on the Maspar platform.

JAVASCRIPT/DHTML

This was a really fun time in my career. I started working with HTML in 1995 and followed the transition from Mocha to LiveScript to JavaScript to Dynamic HTML. One of the most fulfilling projects of this time was a set of DHTML learning games I created for the Texas Council for the Humanities Resource Center.

After the death of Flex, native JavaScript made a comeback and I did a few notable projects in ES5. My favorite was for Ateliers Underlabs Inc. I helped this client deliver a critical mobile application on-time that required ability to optimally route passengers through an airport.  This system included the ability to accommodate known obstacles by modeling them as polygonal boundaries. I also developed a custom Javascript A* library to compute the optimal routing along with line-polygon intersection tests.

C/C++

In all honesty, C++/STL is my favorite language of all time. My C++ work was divided largely into two areas. The first was writing Operations Research solvers for the Sabre Research Group. I also developed plugins for 3DX Max.

My favorite C++ project (for Sabre) involved debugging the assembly of large-scale models into the packed sparse storage scheme used for solvers such as CPLEX (now ILOG). Matrices in these models are very large (over 1M decision variables is common along with several hundred-thousand constraints). Fortunately, the matrices are extremely sparse and are defined in packed storage for transfer to a solver.

Engineers often envision models in a two-dimensional format arranged in row and column blocks. The packed storage scheme consists of multiple one-dimensional arrays. Finding bugs using traditional debuggers is practically impossible. Since bugs manifest themselves on relatively small problems, I wrote an addition to the solver library that allowed the original two-dimensional model to be output to DHTML. We were able to use IE 4 as a cross-platform (NT/Unix) sparse matrix visualizer. This enabled problems to be quickly diagnosed and fixed that would have otherwise been nearly impossible to isolate.

FLASH/FLEX/ACTIONSCRIPT

Flash/ActionScript was my first opportunity to engage with the full breadth of my background in numerical analysis and computational geometry on the front end. Some of the best projects include,

Express Jet Route Arcs: Dynamically draw route arcs (quadratic Bezier curves) from a list of origins to a list of destinations. Created a simple physics model to auto-space the arcs. This project earned me the moniker 'The Algorithmist' from my client.

Senet Learning Game: A re-creation of the ancient Egyptian game of Senet (a forerunner of modern backgammon). Created a 3D (iso) game board and pieces and authored a student-favorable playing strategy. This game was a very satisfying mix of programming and 3D graphics/animation. Due to budget issues, I had to do the voiceover for the spirit of King Tut :)

AZ Dept. of Education, Freethrows Learning Game: Wrote the 'math engine' that generated problems from a pre-defined template list and student information. Generating a problem was actually an exercise in mixed-integer constraint programming. A set of heuristics was used to select a concrete example problem, i.e. 2 + _ = 5 that satisfied a constraint set. Constraints included range limits, select from a collection, etc. The math engine also had to solve the problem in order to verify the student's answer. Math problems up to eighth grade were supported. I also wrote the equation renderers.

ExploreLearning Gizmos: If one Gizmo stood out as my favorite, it would be Cannonball Clowns. This game involved shooting a clown out of a cannon, so you can imagine that I enjoyed the programmatic animation. The trajectory had to be computed based on the student's answer of a math problem. Sometimes, their answer was way too large and we had a very special animation just for that case ... think about putting the clown in orbit :)

Some other work is summarized here in my old blog,

https://algorithmist.wordpress.com/2011/03/07/recent-work-xml-function-graphing-engine/

https://algorithmist.wordpress.com/2012/03/14/graphing-freeform-functions-and-derivative/

https://algorithmist.wordpress.com/2011/12/19/recent-work-measuring-volume/

ANGULAR/TYPESCRIPT

I began working with Angular and Typescript as soon as the first public alpha became available in late spring 2015. This is probably the closest environment to what I enjoyed back in the day with Flex and ActionScript. Some of my more notable projects include,

Ng-conf Angular Champion: Selected as an Angular Champion by ng-conf. 

• Author regular (refereed) articles for the ng-conf blog. 
• Article summaries and links are available at https://www.dhirubhai.net/pulse/angular-champion-jim-armstrong

Drawing Library: Typescript library created for MuchosMedia (Scribblar application). Architecture decouples the mathematics of drawing geometric shapes and freeform strokes from Canvas rendering. Only one renderer is required for ALL strokes and ALL shapes. Written on top of Fabric JS, but could be easily re-used with Easel JS, Pixi JS, or SVG. Angular 11 demo available.

Time Series Analytics Suite: NDA client - Develop Angular (version 10) application to visualize time series data and perform analytics (including forecasting and outlier detection) on the supplied data. Exponential smoothing with Holt Winters was used (parameter estimation via Nelder Mead algorithm) and some light ML was applied to forecasting with TensorFlow. 

An article I wrote on using TensorFlow with Angular can be viewed here: https://medium.com/ngconf/getting-started-with-tensorflow-in-angular-36c0e9d26964

Angular Dashboard Framework: Served as Sr. Software Architect for short-term project at C Squared Technologies. Developed an Angular dashboard framework that supported arbitrary 2D dashboard layouts, driven by metadata. CubeJS could optionally be used, and dashboard visualization components could be built on top of any charting package usable inside Angular (ChartsJS, D3, etc). All Angular components were dynamically instantiated at runtime for maximum flexibility.

Grid Analytics Tool V3: Version 3 of the Grid Analytics Tool (for Southern California Edison)

• Authored Angular (version 8) charting directives (using AmCharts 3) to support advanced interactive visualization and editing tasks for utility power profiles.
• Overhauled profile editing components to add new functionality to the profile editor. 
• Created metadata-driven components to drive complex visualizations using data-driven methodology. 
• Developed (Leaflet) map overlays (SVG/Canvas) for map-based utility data visualization.

Container Store Closet Layout: My John Wick ‘Impossible Task.’ 

• Rewrote a Java back end that served as the ‘brain’ for performing closet layout entirely from scratch in Typescript. Java source was over 33K lines of code including third-party libraries. 
• Container Store was able to move this code to a Node back end and eventually offer multiple layout options via implementation as a FE library.

Interactive Sensor Placement Tool: Created for an engineering consulting firm specializing in the construction business. 

• Angular 6 application computes minimum wiring cost for specialized sensors placed on walls/ceilings. Allows min-cost to be adjusted in real time based on moving one or more sensors. 
• Solved k-clustering problem for cases of sensor aggregation and created auto-clustering algorithm.
• Sanitized demo is available here: https://github.com/theAlgorithmist/Angular-MST-Clustering

Grid Analytics Tool: Served as lead architect and developer for a massive Angular 5 enterprise project.

• State management with @ngrx/store.
• Added new utility profile visualization components using AmCharts 3.
• Developed filter-while-typing tree view.
• Created a time series transform component that allows series forward/inverse transformations to be implemented with a simple API. 
• Undo/Redo stack enabled unlimited undo & redo inside the profile edit section of the application.

Decision Tree Suite: A suite of tools for an NDA client built around a decision tree, sequencing engine, and a finite state machine.

• Enables implementation of complex logic from static code into metadata. 
• Toolset used in over half a dozen Angular projects, including GAT V3, listed above. For further information,

https://www.dhirubhai.net/pulse/typescript-decision-tree-jim-armstrong

https://www.dhirubhai.net/pulse/typescript-sequencing-engine-jim-armstrong

https://www.dhirubhai.net/pulse/reactive-data-driven-finite-state-machine-jim-armstrong

Hilti Scenario Designer: Angular 4 enterprise micro-application that allows fire stop layouts to be interactively designed and analyzed via a drag-and-drop interface.

• Analyzed layout for collisions and distance constraint violations and visually identified them during dragging.
• Enabled designer to automatically stack cables into a cable support or speed sleeve in a physically correct manner and adjust the height of the combined layout item if necessary.
• Developed layout save and import capability.
• Enabled layouts to be mathematically analyzed for feasibility against a general constraint set and in many cases automatically adjust layout to restore feasibility.
• Standalone demo available.

Hilti Range Designer: An Angular 4 visual tool designed to enable precise computations of ranges for x-y plots.

• Created single-quadrant Angular graphing component.
• Developed library to analyze polygonal input and compute range of acceptable y-values given an x-value (i.e. allowable pipe thickness as a function of diameter).
• Standalone demo available.

Angular Dev Toolkit: Comprehensive Typescript/Angular development library, scaffolded with Nx Dev Tools. For clients only.

More info: https://www.dhirubhai.net/pulse/angular-dev-toolkit-jim-armstrong

Essilor MyEyeDoctor Reporting Manager: Reporting micro-application developed for an existing Angular 4 application.

• Authored multiple displays for two-dimensional data with summary statistics.
• Developed interactive (Charts.js) stacked bar chart with drill-down capability.
• Created a Flux-Redux style architecture and library to enable data persistence across open/closed reports, drill-down level, and across routes in the application.

Typescript Rules Engine: A general-purpose rules engine written on top of the Typescript Math Toolkit Expression Engine. 

• Developed for a confidential (NDA) client and used to dynamically control dashboard display based on rules defined in JSON delivered from a server. Rule editing was controlled by a custom CMS, developed by the client.
• Newer version now available in my client-only Angular Dev Toolkit.