Learning projects and exercises - working through books, courses, and coding challenges.
a2ui-poc (2025-12-25)
The project delivers an AI-powered knowledge exploration agent that emits structured A2UI protocol messages to drive interactive surfaces for user queries. It is built in TypeScript with Bun tooling and depends on @ai-sdk/anthropic, ai, hono, and zod for AI integration, routing, and schema handling. The KnowledgeAgent streams Anthropic output, strips Markdown fences, and parses newline-delimited JSON to yield UI updates using the A2UI message builders.
claude-web (2025-12-25)
This project runs a Claude web service that authenticates via GitHub and brokers agent sessions by streaming Docker container output to browser clients. The backend is written in TypeScript with Bun WebSockets, the Hono framework, Prisma, dockerode, jose, ws, and zod. An AgentProxy class relays NDJSON logs from container streams to WebSocket clients while token helpers XOR-encrypt stored GitHub access tokens with the JWT secret.
Exercism (2025-03-23)
No description available.
diy-react (2024-12-24)
This personal monorepo aggregates active packages, learning projects, and archived work into one workspace dedicated to ongoing experiments and tooling (README.md:1). It standardizes development with a Bun-managed TypeScript toolchain, using commands like bun install, bun run build, bun run test, and bun run typecheck to manage dependencies, builds, and quality gates (README.md:56). The scripts/run-package-script.ts automation enumerates every package beneath packages/* to execute requested scripts while honoring skip lists, giving the repo a consistent, centralized way to run tasks across the workspace (README.md:34).
vscode-extension (2024-12-24)
This project is a VS Code extension named test that activates to expose a test.helloWorld command which greets the user with an information message (src/extension.ts). It is implemented in TypeScript on top of the VS Code extensibility API with build tooling managed through the esbuild-based pipeline configured in esbuild.js and tsconfig.json. The extension architecture registers the command during activation and disposes it via context.subscriptions, ensuring lifecycle cleanup within the VS Code host.
advent-of-code (2024-08-30)
This personal monorepo consolidates active projects such as the clauderon session manager for AI coding agents, spanning tooling, docs, and archived work (README.md:1, packages/clauderon/Cargo.toml:1). It uses a Bun-managed TypeScript workspace with shared scripts and Tauri integrations alongside Rust crates that pull in Tokio, Axum, SQLx, Ratatui, WebAuthn, and gRPC support to deliver async services, terminal UIs, and desktop capabilities (package.json:1, packages/clauderon/Cargo.toml:13). A notable architecture detail is the repository-wide scripts/run-package-script.ts runner that orchestrates build, test, lint, and typecheck commands across every package directory to keep the multi-package structure consistent (scripts/run-package-script.ts:1).
category-theory-for-programmers (2024-08-30)
This monorepo consolidates active projects, experiments, and archived work under a single workspace with shared tooling. It runs on a Bun-managed TypeScript stack with repo-wide package.json:1, Lefthook hooks (lefthook.yml:1), a Dagger pipeline (dagger.json:1), and Tauri API dependencies that automate builds and desktop integrations. A notable capability is the automation script at scripts/run-package-script.ts:1, which enumerates packages and executes targeted scripts across the workspace while honoring skip lists for selective execution.
sicp (2024-08-30)
This monorepo centralizes the author’s active projects, learning experiments, and archived work under a shared Bun toolchain that exposes repository-wide build, test, and typecheck commands. It runs on Bun-managed TypeScript workspaces defined in package.json:1, integrating tooling such as Tauri APIs, Lefthook git hooks, and Dagger’s TypeScript SDK for automation. The repository relies on scripts/run-package-script.ts:1 to traverse every package directory and execute the requested script while honoring the SKIP_PACKAGES exclusion list, giving the workspace a consistent orchestration layer.
fastbook (2024-08-30)
This project is a fork of fastai/fastbook that captures the maintainer’s annotated progression through each fast.ai deep learning lesson in chapter-aligned Jupyter notebooks. It runs the notebooks with Python using fastai, PyTorch, and related tooling defined in environment.yml and requirements.txt, and can spin up in Google Colab through the badge in README.md. The repository organizes reusable helpers in utils.py and offers localized guides (README_es.md, README_id.md, README_zh.md) alongside chapter notebooks like 09_tabular.ipynb and 16_accel_sgd.ipynb.
mini-jam-98 (2024-08-30)
mini-jam-98 is a Rust game project for the Mini Jam 98 Empty challenge, structured as a Bevy-powered application. It uses the Bevy 0.6.0 engine with dynamic linking and the rand 0.8.4 crate to drive its entity-component systems. The codebase defines granular components for enemies, health, inventory, and multi-directional movement states, enabling a modular ECS architecture for gameplay logic.
maze-game (2024-08-30)
Maze is a console-based arcade game where you control an @ character with WASD to collect dots while evading ghosts. The codebase is a Java 8 Maven project that uses JLine for terminal rendering and Apache Commons Lang utilities. Its gameplay engine randomly instantiates MapObject subclasses for barriers, ghosts, and the player so each map and ghost configuration differs between runs.
programming-with-categories (2024-08-30)
This monorepo gathers personal projects for experimentation and archiving across languages such as TypeScript and Haskell, keeping active and historical work in one workspace. It uses Bun-managed workspaces defined in package.json, pulls in desktop-focused dependencies like @tauri-apps/api, and includes examples such as practice/programming-with-categories/main.hs. A notable capability is the custom Bun runner in scripts/run-package-script.ts that crawls each package’s manifest and executes shared build or test scripts across the entire workspace automatically.
rust-web-server (2024-08-30)
This project implements a multithreaded Rust HTTP server that listens on 127.0.0.1:8080 and serves basic requests with hard-coded configuration. It relies on Rust 2018 with only the standard library (for example std::net::TcpListener and a custom ThreadPool) to parse requests and craft responses. Notably, it uses a manually built thread pool to dispatch incoming TCP connections across worker threads for concurrency.
langchain (2024-08-30)
This project runs a LangChain-powered translation service that exposes a /chain HTTP endpoint for converting text into a target language. It is implemented in Python with FastAPI, LangChain Core, LangServe, the langchain-anthropic ChatAnthropic Claude 3 Sonnet model, StrOutputParser, and uvicorn. The app composes a ChatPromptTemplate → ChatAnthropic → StrOutputParser pipeline registered through LangServe while enabling LangSmith tracing and prompting for LangChain and Anthropic API credentials at startup.
leetcode (2024-08-30)
This Maven-based Java 21 LeetCode practice module collects algorithmic solutions such as balancing shared expenses, generating count-and-say sequences, and composing target-matching arithmetic expressions in src/main/java/sjer/red. It leverages Java standard library constructs like HashMap, PriorityQueue, and recursive depth-first search, with ExpressionAddOperators.solve maintaining operand state to enumerate every valid expression that meets a target value.
hson (2024-08-30)
No description available.
rust-guessing-game (2024-08-30)
This is a Rust command-line guessing game where the player guesses numbers between 0 and 20. It uses the Rust 2018 edition with the rand 0.8.3 crate and std::io to handle random target generation and user input. A notable detail is its use of thread_rng().gen_range(0..21) to cover the full range inclusively before comparing the player's guess to the target.
rust-grep (2024-08-30)
This project implements a grep-style command-line utility that scans files for lines containing a specified query. It is built in Rust (2018 edition) with only standard library components such as std::env and std::fs. Command-line parsing constructs a Config struct—including CASE_INSENSITIVE environment handling—that routes search operations through dedicated case-sensitive and case-insensitive functions.
jlox (2024-08-30)
This project implements the Lox programming language interpreter from Crafting Interpreters, providing both REPL and script execution entry points. It is built in Java with a Maven pom.xml, leveraging the com.shepherdjerred.jlox package and Java IO/NIO utilities to scan, parse, and evaluate source code. Expression classes in src/main/java/com/shepherdjerred/jlox/Expr.java use a visitor pattern consumed by Interpreter to centralize evaluation across the AST.
rust-os (2024-08-30)
This project is a bare-metal operating system written in Rust that targets x86_64 hardware. It relies on the bootloader, x86_64, lazy_static, spin, and uart_16550 crates to configure the kernel runtime, interrupt tables, and serial console. The architecture includes a custom serial-backed test runner and a double-fault handler that uses a dedicated interrupt stack table for resilience.
posit-academy (2024-08-30)
This project analyzes the 2020 R Community Survey, recreating milestone exercises that summarize and visualize respondent enjoyability scores, job categories, and related metrics. The codebase uses R Markdown with knitr plus tidyverse packages such as readr, dplyr, tidyr, and ggplot2 to load, transform, and plot the survey data. Extension reporting consolidates the weekly milestones into extension_4.Rmd, merging country-level metrics, paginated tables, and multiple visualization variants under a single html_document theme.
game (2024-08-30)
This Rust project builds a 2D space shooter where player and enemy ships move and fire missiles inside defined world bounds. It runs on Bevy 0.8.1 with Rapier2D 0.17.0 for ECS-based rendering and physics, including sprite bundle assets and collider components. The architecture schedules gameplay logic on a fixed 1/60-second timestep and tags entities with bounds-tracking components to clamp movement and despawn objects that leave the arena.
ostep-homework (2024-08-30)
This repository hosts the OSTEP homework suite that reinforces operating systems concepts through chapter-aligned exercises and simulators. The exercises rely on Python scripts such as cpu-intro/process-run.py alongside x86 assembly snippets in threads-locks/*.s to model CPU scheduling, virtualization, and synchronization scenarios. Each simulator supports repeatable experimentation by letting learners generate unlimited problem instances via random seeds and solve them automatically with the -c flag.
bevy-experiment (2024-08-30)
bevy-experiment renders a 2D tile-based scene and controllable sprite using the Bevy game engine. It uses Rust with Bevy 0.4, the bevy_tiled_prototype tiled-map plugin, and Bevy diagnostic plugins for frame-time reporting. Startup systems load the TMX world and sprite assets while runtime systems handle keyboard-driven character motion and zoomable camera control.
go-wiki (2024-08-30)
This project implements a file-backed wiki web server that lets users view, edit, and save pages via HTTP routes. It is built in Go using the standard library packages net/http, html/template, and regexp, with templates under html/ driving the UI. Pages persist as .txt files in pages/, and requests resolve page titles through regex-matched routes before rendering the appropriate template.
dns (2024-08-30)
This Rust project models DNS protocol data structures and currently emits a greeting when run. It uses the Rust 2021 toolchain with the packed_struct crate to define bit-precise DNS headers, questions, and related fields. By deriving PackedStruct for nested types such as Message and Header, it enables big-endian serialization of DNS components without manual byte handling.
learn-you-a-haskell-exercises (2024-08-30)
Learn You a Haskell Exercises is a Haskell Stack project that implements the book’s chapter exercises, providing concrete practice functions such as list utilities defined in practice/learn-you-a-haskell-exercises/src/StartingOut.hs:1. It builds with Stack against the Stackage LTS 18.0 snapshot and depends on base and random, with tests discovered by hspec-discover as configured in practice/learn-you-a-haskell-exercises/package.yaml:21-38 and practice/learn-you-a-haskell-exercises/test/Spec.hs:1. The source tree mirrors the book’s structure—modules like FunctorsApplicativeFunctorsAndMonoids.hs and AFistfulOfMonads.hs encapsulate chapter-specific solutions for targeted study (practice/learn-you-a-haskell-exercises/src/FunctorsApplicativeFunctorsAndMonoids.hs:1, practice/learn-you-a-haskell-exercises/src/AFistfulOfMonads.hs:1).