Open Source

I work on open source projects, licensed with the Apache 2 license. I have primarily focused on developing libraries to assist in my project work. I will be focusing on more open source components & apps. Here are some notable projects:

rappstack

rappstack (reactive app stack) is an opinionated stack that emphasizes:

• reactive programming
• general purpose contexts
• tiny browser bundles
• performance

The tech stack includes:

bunjs ElysiaJS SQLite DrizzleORM TailwindCSS ctx-core rmemo relementjs relysjs hyopjs

rmemo

rmemo is a tiny no-fluff reactive state management library. The primitive is a reactive memo. A reactive signal is a reactive memo that has a public setter property. rmemo includes memosig, lock_memosig, & a rich api for your reactive state management needs. Features include:

• memo_
• signal_
• memosig_
• lock_memosig_
• general purpose contexts with ctx-core/be
• autosubscriptions
• async support
• a terse & focused api
• performance
• reactive state management library with the smallest full featured bundle size
• integration with garbage collector via WeakRef

relementjs

Isomorphic ui rendering & state management on the browser & server. The smallest reactive UI library on the browser & server. relementjs scales large & small with tree-shakable modules for rendering, reactivity, contexts, & hydration.

rebuildjs

Simple hackable alternative to vite for Multi-Page Apps.

This library provides esbuild functions for dev & production environments. It forms a core for an app server stack.

relysjs

Reactive web app server. Focuses on MPAs with simple server middleware & browser build api. Uses a rebuildjs core with Bunjs, Elysia, ESBuild, rmemo, & ctx-core

@rebuildjs/tailwindcss

Tailwindcss plugin for rebuildjs.

hyopjs

Hypermedia Operation or Hydration Operation. Tiny library (starting at 61 B) to hydrate operations in the hyop attribute. Remove bloat from hydration & JS payloads. Use standalone or with other Hypermedia libraries like HTMX...Hydration as Hypermedia.

ctx-core

Over 100 general purpose libraries to assist work creating libraries & apps. Development on ctx-core began in 2016 & continues today^[1].

Motivation

After maintaining several applications, I ran into the issues of:

• creating & iterating on features
• extracting code to reuse
• time to refactor code
• time to upgrade software
• gluing together small libraries & snippets
• composing app feature libraries

Existing solutions such as frameworks or libraries bring speed to get started. They come with the maintenance burden of:

• large payload size & memory usage
• extending the underlying software to fulfill requirements
• time to upgrade the application with the underlying libraries
• domain language mismatch between the library/framework

There are usually small libraries & code snippets. Gluing these small libraries & snippets together. With a naming convention that utilizes unique, immutable, & composable names. Results in a codebase when you could find all usages of an entity or concept by doing a project-wide search. Rename refactorings are more accurate & comprehensive due to the uniqueness of names. Composable naming allows one to understand the context & full description of the entity.

I use ctx-core to maintain software with:

• an accessible domain model
• a flat architecture
• reactive programming

Usage

ctx-core uses dependency-injection of a ctx & "beings". A "being" is a function created with the be_ factory function. The flat architecture reduces incidental complexity. To manage complex domains, nested architecture provides scoping. I created the Tag Vector Convention while working on ctx-core. Tag Vector encodes tags joined by vectors. Tag Vector express data structure shapes & complex domains within a flat architecture.

I use ctx-core along with rmemo to manage reactive state on the server & the browser. In my work, I favor rmemo to render components on the server & browser. ctx-core also supports reactive state with Nano Stores, solidjs signals, & svelte stores.

Nano Stores

I learned about Nano Stores via astrojs. NanoStores was a natural replacement of I svelte stores to support global reactive state. NanoStores is agnostic to component libraries, such as solidjs. I contributed a fix^[2] to diamond dependency bugs. This fix uses a breadth first queuing algorithm.

sveltejs

I contributed the breadth first queuing algorithm to svelte stores^[3].

backbone-signal

A rich Signal & Slots (Reactive Programming) api on Backbone Models. It is composable, allows you to encapsulate loader logic, and have fine grained control over listening to change events.

I started using global state management with Backbone.js while Lead Developer at honk.com. I created backbone-signal to add global state management to Backbone.js. I used this across different projects including Rundavoo.

jasmine_flow

Flow testing for Jasmine.

At Rundavoo, I created jasmine-flow. Jasmine-flow facilitates linear flow testing...saving effort in maintaining automated tests. This was hard-learned from maintaining various large apps while at honk.com & Pivotal Labs.

rr

RR is a test double framework for Ruby that features a rich selection of double techniques and a terse syntax.

I released RR back in 2008. RR features a terse api to for a high signal to syntax noise ratio. Which allows a read & write friendly automated testing. I used global state management to manage complex data interactions. I stopped development when I moved to full-stack Javascript development. Sutou Kouhei began maintaining this project in 2015.

rspec

I was an early core maintainer on the rspec team. Rspec was the first DSL (Domain Specific Language) implementation of BDD (Behavioral Driven Development). Key contributions include the first known implementation of nested describe & context statements^[4]. Nested describes were controversial at that time. Criticism included adding to the complexity & inhibit readability of the specs. Nesting describe & context enabled contextual nesting with separate usage of beforeEach & afterEach. I championed the idea & delivered the implementation. I integrated Rspec with Test::Unit. Worked on the initial mock implementation. Worked on the Ruby on Rails integration.

Desert

Desert is a Rails plugin framework. Desert allowed plugins to share models, views, controllers, helpers, routes, and migrations. Applications used these plugins.

Reusability doesn’t come at the cost of extensibility. Desert made it easy to extend the functionality of a plugin - both in your application and in other plugins.

Mixin classes in with your own or other plugins’ classes. This allows you to make full featured composable components.

Jelly

Jelly is an unobtrusive Javascript framework for jQuery and Ruby on Rails. Jelly provides a set of conventions and tools to organize your AJAX and client-side code. While keeping Javascript out of your views and markup. Jelly is the glue between your Rails controllers and jQuery events.

Jelly encourages and enables unit testing your Javascript code. While using a Javascript testing framework such as Jasmine or Screw Unit. Jelly allows testing AJAX and client-side events separate from your Rails app.

Polonium

Selenium test runner & helpers for Rails. Featured a set of wait_for helpers to keep the tests in sync with the application.

unison

Reactive in-memory relational caching library which syncs with upstream relational databases. Written in Ruby.

Screw Unit

Screw.Unit is a Behavior-Driven Testing Framework for Javascript. It features nested describes. Its goals are to provide:

• a DSL for elegant, readable, organized specs;
• an interactive runner that can execute focused specs and describes;
• and brief, extensible source-code.

Generic Query Analyzer

A query analyzer using ADO.NET. I built this tool to run SQL queries on the MS Access CRM MS Excel database. Used by @ The Corporate Counsel. Written with C#, ADO.NET, Winforms.

PHP Object Oriented Framework

The PHP Object Oriented Framework is a framework library to build components in PHP. POOF was an alternative to using the Smarty Template Engine. Poof encapsulated html rendering in components.