Joe Lapp's CV

STRONG SKILLS

• Problem Solving – I thrive on analytic challenges and have accumulated many problem solving strategies over the years.
• Java (25 years) – I have a deep understanding of the language, but I've spent much of the past 12 years mainly doing low-level Android programming for high-performance gesture processing. I've done little Java in the past 2 years, so I'd need a quick brush-up.
• TypeScript (5 years) – The first 3 years of TypeScript were mostly Node.js CLI programming, but this last year has been all web and Electron app development in TypeScript.
• JavaScript/Node.js (8 years) – I started with JQuery but eventually developed CLI tools and an Express website. The website was for my now-defunct business, Instar Earth, LLC. This past year I've used Node.js on the backend for both an Electron JS app and a web portal for biological data analysis.
• Svelte (1 year) – I've been developing in Svelte for the past year—an Electron app and an Express-backed SPA website. Svelte is easy, though its idioms do have a learning curve.
• SQL – I'm efficient with most SQL, but I can slow be at anything sophisticated, such as recursive queries. Experienced with PostgreSQL and MySQL. I've grown fond of Kysely.
• HTML & CSS (7+ years) – I've been getting up to speed on HTML5 and have gotten pretty good at CSS over the past year, but there are still times CSS has me pulling my hair out.
• Electron JS (1 year) – I developed a front-end to the complex Specify 6 database using Svelte and TypeScript. My Electron Affinity library extends Electron.
• Specification Writing (25 years) – This is one of my stronger skills, as I have a reputation for writing unambiguous, thorough specs. My process yields deep understanding, usually revealing previously unknown issues with the subject technology.
• Instructional Writing – I don't have a lot of experience with this, but my piece on Flutter Provider was very well received. I'm also a natural teacher, so I'm sure I could pull it off again.
• UML (25+ years) – I've been using Unified Modelling Language since it evolved from the Booch technique. I use it to help me understand problems, to explore possible solutions, to discuss software design with others, and to document solutions.

LESSER SKILLS

• Python/Pyright (1 year) – I wrote a Python program to generate reports and provide corrective/transformative output for over 3 decades of hand-maintained specimen data. The effort included fuzzy-matching similar names as well as hierarchically organizing name variants. Used Pyright for static type checking.
• Rust – I spent about a month learning Rust, reading several books, and working exercises. Rust looks especially promising for writing WASM when I need high performance in the browser or Node.js. See my exercises on Exercism.io.
• JavaFX – I've wrote two JavaFX programs for my Computer Science degree, the larger of which is here.
• TornadoFX/Kotlin – I wrote one small TornadoFX/Kotlin program to experiment with animations for teaching my gesture system.
• Flutter/Dart – I spent several months learning Flutter/Dart app development. I did not complete any apps, but I did publish this article documenting some of what I learned.

FORMER SKILLS

• XML Standards – I participated in the development of several XML standards, most notably XQL and XPath.
• COMPUSEC Security – In the process of evaluating the Novell Netware network file system for whether it satisfied NSA-mandated security policies, I became a bit of an expert on computer systems security.
• C and C++ – In the 1990s, I spent about 3 years developing in C and about another 3 years developing in C++, mostly embedded systems and communications protocols.
• Embedded Systems – In the 1990s, I maintained embedded Navy ship communications software and developed embedded code for NSA-contracted communications devices.
• 6502 & 68000 Assembly – In the 1980s, I wrote graphics routines in 6520 assembly, and I wrote math libraries and a printer plotting program in 68000 assembly. The program used the library to plot vector graphics over multiple pages of a tractor-feed printer.

SOFT SKILLS

• Active Listening – I learned active listening in training for a crisis hotline. This is the skill of ensuring that the speaker feels understood and that the listener actually understands. I find it helpful one-on-one, in small groups, and in leadership roles.
• Teaching/Mentoring – I love to teach and mentor. I've been doing this for 20 years as part of my educational outreach on spiders, including mentoring students on spider taxonomy. I've also taught web development to children and mentored a business partner in software design. Everyone loves my encouraging style.
• Public Speaking – I nervously delivered talks at XML conferences in the late 1990s but have since regularly given talks on spiders to audiences of up to 100 people. I've learned how to convey passion for the subject and get people laughing.

SUPERPOWERS

• Writing clear, unambiguous documentation and specifications – My approach to writing yields clear, unambiguous, complete documentation and specifications. I do this by being meticulously honest, requiring constant awareness of what I do and do not truly understand. For example, I once write a specification for a new technology called the B2B Flow Language, and the primary developer responsible for implementing it was shocked to have been able to do so having to ask only one question, yielding a solution that worked.
• Elucidating design flaws and limits through specification writing – I'm able to write technical specifications in such a way that the process reveals the contradictions, flaws, and limits of the originally conceived design. I try to be meticulously honest about every statement and logical conclusion. I enjoy the challenge. The results are specifications for functionality that works within the limits I define and doesn't work—or doesn't necessarily work—outside those limits. Also, asking me to "document what we did" clarifies what you did and often results in changing what you do.
• Writing robust/efficient/high-performance code – I'm usually one of the few programmers on a project with a high degree of awareness of what goes on under the hood. This allows me to write robust, efficient code. Last I heard, Software AG had been unwilling to replace the XQL-capable parse-on-demand XML parser I wrote in Java. I wrote it in 2000, and they were still using it at least ten years later because it was performing better than more modern parsers. The parser executed XQL queries in a way that only parsed the specific data it needed from XML documents.
• Vulnerability analysis of source code (any amount) – I was hired to examine the source code for the Novell NetWare network file system and document its security policies. The code was old and convoluted and spanned thousands of files. I documented intricate policies and found multiple paths of vulnerability. Novell did not initially believe my reports of vulnerabilities, so I began sending them exploits that proved them. Similarly, within hours of looking at webMethods' existing source base, I noticed a vulnerable path and reported it. They opted not to address it, and two months later a client without access to the source managed to exploit it. I don't enjoy vulnerability analysis, but I seem to be good at it.

EXPERIENCE

• Now developing an open-source platform for collaboratively developing field guides and taxonomic keys, using TypeScript, SvelteKit, Node.js, Supabase, PostgreSQL, and Kysely. https://github.com/jtlapp/fieldzoo.
• Published a 4-part article on sharing TypeScript using monorepos.
• Published a 4-part article on sharing TypeScript using monorepos.
• Developed TypeBox Validators, providing TypeBox JSON Schema validators with lazy compilation, custom error messages, safe error handling, discriminated and heterogeneous unions.
• Developed Kysely Params, a utility for parameterizing compiled Kysely SQL queries.
• Developed Kysely Mapper, a flexible Kysely-based utility for mapping between tables and objects.
• Developed Kysely PG Client, a non-pooling single-connection Postgres dialect for Kysely, thoroughly tested.
• Developed Kysely Test Sync, a utility for running Kysely dialects/extensions against Kysely's test suite.
• Learned the basics of React and Next.js, but decided to proceed with SvelteKit for my next project.

• Developed an online research platform for biological collections data using TypeScript, Svelte, HTML/CSS, Node.js, and PostgreSQL. Includes data clustering, linear regression, chart.js graphs, and MapBox maps. https://caves.tacc.utexas.edu.
• Developed a desktop app for cleaning data in a Specify6 database using these same technologies plus Electron JS and MySQL.
• Cleaned/normalized ~30 years of hand-maintained data (~30,000 specimen records) using Python with Pylance/Pyright.
• Developed all repos at https://github.com/ut-entomology.
• Worked remotely in Austin, funded by a short-term grant.

• Developed and patented a real-time system for eyes-free gesturing on touchscreens. I wrote it in Java for Android employing multi-threaded state machines. I'm happy to show the code via screenshare.
• Developed several technologies for making it easy for non-experts to semantically mark up and query human-readable text. Work still in progress. Largely a design and specification effort.
• Wrote formal design specifications, UML models, and patents.
• Developed supporting technologies and side projects in Kotlin, JS, TypeScript, Node.js, Dart/Flutter.

• Part time work. I taught children ages 7 to 13 to develop websites with HTML and CSS and to program web pages in JavaScript.

• Developed semantic tagging tech in JS, Node.js, HTML, SQL.
• Mentored my business partner on UML and software design.

• Sold my webMethods stock and moved to Austin to explore life outside of programming. I found a love for spiders, but I could not keep myself away from software design and development.
• Continued exploring solutions—in Java—to problems I had not yet solved during my time at webMethods.
• Wrote open-source extensions for Expression Engine in PHP.

• Co-invented and patented semantically labeled RPC under the moniker XML-RPC (e.g., Ajax, SOAP, JSON-RPC).
• Co-invented and co-authored XML Query Langauge (XQL).
• Co-invented and authored webMethods B2B Flow Language.
• Wrote a high-performing XQL-capable parse-on-demand XML parser in Java, which the company was still using at least a decade after I left because it continued to outperform newer XML parsers.
• Served as W3C representative and technical liaison to Microsoft.
• Hired as the 9th salaried employee after posting this email to xml-dev in 1997 (now archived, no SSL cert).

• Developed embedded communications protocols in C and C++.
• Hacked Novell NetWare from source code to reverse engineer security policies and discover/prove security vulnerabilities.

• Helped maintain several hundred thousand lines of C and Pascal.
• Wrote embedded C hot-loaded into Navy ships for the Gulf War.

• Automated voltage calibration tests in HP Basic.
• Worked part-time while not in school.

VOLUNTEER WORK

• I teach adults and children about spiders, holding classes and leading spider walks for many schools, parks, and organizations.
• I became an expert on North American crab spider taxonomy and have discovered several new species of spiders, one of which—Misumessus lappi—is named after me.

• I trained to be a hotline counselor, learned active listening skills, took calls on shifts, and assisted with training new counselors.

PUBLICATIONS

• A simple way to virtually eliminate two classes of runtime errors using nominal types.

• An introduction to sharing TypeScript code and configuration across a monorepo using pnpm and either Nx or Turborepo.

• An overview of how I implemented Electron Affinity, a library for using RPC to conduct IPC in the Electron JS cross-platform framework.

• An in-depth look at how the Flutter Provider reactive state management library works, including its UML design pattern.
• Well-received by the community, with 1.6K claps and climbing.

• This is the technology that seeded W3C XPath. I wrote the appendix of the specification (and implemented the technology).

• I wrote chapter 8, "Supply Chain Integration," and chapter 38, "WIDL and XML RPC," explaining the technologies webMethods used for B2B integration.

• I revised the chapter on Thomisidae (crab spiders) for the 2nd Edition, largely rewriting the dichotomous key.

PATENTS

• Calibrated Finger-Mapped Gesture Systems – Division 2
  US 11086502 B2 – Issued Aug 10, 2021

• Finger-Mapped Character Entry Systems – Division 1
  US 10082950 B2 – Issued Sep 25, 2018

• XML Remote Procedure Call (XML-RPC) – Division 2
  US 11002089 – Issued Aug 25, 2015

• Integration Server Supporting Multiple Receiving Channels
  US 8650320 B1 – Issued Feb 11, 2014

• XML Remote Procedure Call (XML-RPC) – Division 1
  US 7028312 B1 – Issued Apr 11, 2006

PUBLIC PROJECTS

• A platform for conducting research on Texas cave invertebrates, in part using classical machine learning to make predictions.
• I received a WGU "Capstone Excellence Award" for the predictive portion of the platform, which I developed for my BSCS capstone.

• A library for utility for parameterizing compiled Kysely queries.

• A flexible Kysely-based utility for mapping between tables and objects.

• TypeBox JSON Schema validators with lazy compilation, custom error messages, safe error handling, discriminated and heterogeneous unions.

• A library for using RPC to conduct IPC in the Electron JS cross-platform framework. See my write-up for JS in Plain English.

• A desktop mini-CRM that hits a MySQL database. This was a project for C195 at WGU and is my only publicly-available Java source at the moment. (But see private project below.)

• A minimalist library for working with GIFs in JavaScript, apparently the first JS library for GIFs. I now only minimally maintain this. Written in plain JS for a private TypeScript app.

• A test runner for tap that selectively runs subtests. Written in pre-classes JavaScript. Makes sophisticated use of Node.js.

PRIVATE PROJECTS

• A patented system for entering text into touchscreen devices that neither requires targeting the fingers to screen elements nor requires any use of the eyes at all. See this introductory video and this introductory article. The project spans multiple repos and many thousands of lines of Java, which I'm happy to show via Zoom.