Hi, I'm John, and this is my site on the WWW. I'm a hacker by trade and hobby, currently working as a freelancer. I love big cities, weird tech history, and javascript. If you need someone with software design experience for a project, I can help you get it done. Feel free to contact me about business, or my prior work, via the contact info on this site or my resume.
Demonstration of an application that gives teachers realtime metrics and visualizations of classroom attention. I consulted on the concept and provided guidance on using React Native to build the clientside application.
This was the final deliverable for a computer architecture class. We were asked to design an IOT product that would solve a specific problem, and the greatest threat to any Monterey Bay student in 2018 was finding a parking spot on-time for class.
We acknowledged the fact that all the university parking lots were in open-air and had proximity to the school's WiFi. Therefore, we created an IOT-connected sensor to detect open parking spaces, and report needed parking spaces to students. This device only requires WiFi access points to operate, and can be placed at the end of any parking spot. All the software needed can be run in on-demand compute services for a minimal cost. I ended up providing the IOT glue for the device, the frontend webapp, and orchestrated the backend services to demonstrate sending parking updates to students.
Check it out here.
A poster I co-authored demonstrating a novel gesture sensor, built from an array of bend resistors.
I implemented a recognizer using a Long-Short Term Memory Recurrent Neural Network, it achieved accuracy surpassing the competing Myo sensor for the same set of gestures. I also wrote drivers for the sensor itself using the Arudino toolkit and python serial IO libraries.
There’s a commentary section that follows the list, read it for purpose/background on this article. If you have suggestions, please contact me or send a github PR for this page.
The following sections highlight ideas that make it simpler to create and inspect software systems.
Roy Fielding’s disseration on the design of networked applications and RESTful architecture. Gives context to the design of modern hypermedia systems, HTTP, the web and applications we build on top of it.
Library that implements a modern hypermedia client in any web browser, rather than writing a different one every time you make a webapp.
REPLs aren’t just about evaluating code interactively, they’re a well-defined entrypoint for the programmer to modify and inspect a system. The ceremony is well-organized and specifically tailored to this purpose, you send data to the program, the program evaluates it, and you get data back. Also see the linked talk by Nada Amin, which evaluates this concept from the perspective of implementing languages.
Cosmo is a gargantuan effort to create a C library that can target multiple platforms at once in a single binary. It has one abstraction over the system layer that largely emulates the amd64 ABI for Linux, meaning that most applications made for Linux can run natively on any major operating system. It also bundles necessary functions for common tasks like HTTP servers or multimedia manipulation. Redbean is a small application server linked against cosmo that provides the equivalent of a full LAMP stack in one program, one executable file that is your entire application, with its code and database state.
Forth is a very small programming language, phrased more as an abstract stack machine. The machine executes words, which are procedures that manipulate data on a shared stack. Typically the machine is defined in terms of primitive words, implemented in native machine code. Forth metacompilers allow for this abstract machine to be defined in Forth itself, creating a very tight loop for designing other Forth systems.
From Frank Sergeant. Essentially describes a generic protocol for a machine code monitor over a serial port. Using only peek, poke, and essentially a CALL instruction, a full Forth machine can be implemented on the target from any programming language.
Well-executed attempts at creating a cohesive software development system
Self was the breeding ground for what eventually became the JVM platform and Javascript’s prototypal object system. It was a pioneer in language VM implementation, aiming to create an entire development environment and runtime in the same programming language.
A complete 3D and compositing solution all running on a Symbolics Lisp Machine. Later became the software basis for SGI and its many licensed development kits.
Common Lisp implementation written in itself, build process can almost skip a C compiler.
A complete operating system implemented in a Pascal-like language. All interactions with the system are done thru rich text documents that can embed programs and various objects. Running code is as simple as clicking a hyperlink.
A core component of Japan’s TRON computer platform, was meant to be a programming environment working on the scale of the web. All resources were presented as inspectable objects, much like Smalltalk. These could represent simple data, hypermedia documents, remote machines, or collections of other objects.
A complete Forth system for DOS that can recompile itself. Includes facilities for interactive development and debugging.
A Forth 2012 compliant system implemented in legible amd64 machine code. The interpreter bootstraps from a byte-delimited read-protocol, which defines the primitive Forth words directly in machine code. After startup, a full Forth system can be used to compile and run code interactively.
Forth implemented in x86 assembler, complete with inline documentation and diagrams explaining how it works.
And they’re right
This article is an annotated reading list that tracks tools for better understanding how software is made and run on machines. It will be loaded with a lot of my own wacky opinions of how bad software and computers are, since it is my main motivation for constantly looking for more of these materials.
More specifically, I want to understand why the engineering distance between a machine and the practical applications it performs is so inordinately large. We have excellent, high-level programming languages with appropriate primitives to build world-scale systems, but God forbid you want to talk to a graphics device and have it do a cool trick you just thought up, or create your own programming language, or any number of applications that involve negotiating with some platform.
Smalltalk, all the way back in the 1980s, did solve all the problems related to bootstrapping a complete programming system from bare metal, and you could inspect any layer of that solution with the same exact tools you use to write applications. Why can’t we do that today? Why can’t we create a closed abstraction of a machine that any platform or language can use?
I lay the blame with our development tools being inadequate for understanding a complete system as a whole, from hardware & platforms to the software that runs on them. Any programmer should be able to spend an afternoon in any programming language and be able to have a small kernel program that can file your taxes and send HTTP requests on nearly anything that can run code. However, we often get stuck in what is the right language not for the application we are making, but rather how this language can eventually target some CPU, operating system, VM hypervisor, container framework, web browser, game console, and so on. Even when you do have merely adequate tools for development, they often grow legs and run far away from your language of choice, ask you to suffer hours of tutorials or documentation that doesn’t generalize, or bring all their 50+ year old friends to give you some light reading.
Considering our platform is a fine problem to have, but in the end it shouldn’t be something that restricts our ability to use the right tool for the problem we’re trying to solve. Platforms offer us primitives to run code, languages arrange those primitives into useful tools for solving problems. Programming languages should offer us the ability to solve both our application and platform-related problems in a generic way. Despite this, we settle for worse is better and have bespoke, cryptic and non-portable solutions for abstracting over platforms. See the demand for win32 emulation, Valve basically adopting the WINE project, the C programming language being unable to die, and the success of Docker for evidence of platforms being more than platforms.
Even the conceptual machines we build on top of the real ones don’t make our programs easier to comprehend. Often they ignore years of research work, or they haphazardly cherry pick features for some particular reason (often not good reasons) to the detriment of the overall system being transparent to the person who works with it.
I enjoy masochistically pretending I can do something about all of this, so I spend a lot of time messing with compilers and other such tools to see how we can simplify the process of making great applications. This list documents some of the resources I’ve collected to gain some insight on this issue and prior attempts at making better tools for software development.
Here's some of my other work from the web:
Working demonstration of multiple LeapMotion infrared trackers being used on one PC. This work was intended for an interactive projection surface, and would allow multiple people to manually interact with applications displayed on the glass.
This was achieved using SystemD-Nspawn process containers in linux, as the Leap driver at the time did not allow for multiple controllers to be connected to one machine. I used the process isolation provided by SystemD to filter the USB identifiers of the controllers in each container, so that only one controller was seen per container instance. Since the Leap driver is exposed via websocket, this allows for an application to use multiple controllers at once.
A local construction company in LA needed a new website to exhibit their previous work. Their old site was predicated mostly on SEO content, without much for human visitors to see. I took some queues from other contractor portfolios and made a gallery page which expands to show the summaries of the jobs.
Over the past few years, the Los Angeles Music Center has installed an IP camera system and signboard monitors to create altered reflections of their plaza space. yU+co has taken this system and used it to apply style-transferred projections and other effects to those passing by.
I was contracted to provide a simple scheduling mediator for the different effects used by the system, and allow for creating detailed schedules for the week, by day, hour, scene and various controls for duration and immediate scheduling. This allows the operators to control the central touchdesigner application externally, and save persistent schedules that can be swapped for different times of the year, all from a simple web application.
An experimental social network that allows you to anonymously create 'beacons' on a shared map. The beacons can tell others what you're up to or things going on in the area, through text and/or images. You can click on these beacons all over the map, or you can view them as a feed with more details.