5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #29

Today’s Five

1. Neural Collapse

In overparameterized networks trained to zero loss, class representations converge late in training to a symmetric, maximally separated structure. The last-layer features and classifiers align into a simplex equiangular tight frame.

This geometric phenomenon appears universally across architectures.

Like students settling into evenly spaced seats by the end of class.

2. Grokking

In some tasks, especially small algorithmic ones, models memorize quickly but only later suddenly generalize. The jump from memorization to understanding can happen long after training loss reaches zero.

Weight decay and longer training appear necessary for this phase transition.

Like cramming facts for an exam, then later realizing you truly understand.

3. SAM (Sharpness-Aware Minimization)

Instead of minimizing loss at a single point, SAM minimizes loss under small weight perturbations, finding flatter regions. Flatter minima tend to generalize better than sharp ones.

The optimizer seeks robustness to parameter noise.

Like choosing a wide hilltop instead of balancing on a sharp peak.

4. Mechanistic Interpretability

Researchers analyze activations and internal circuits to understand how specific computations are implemented inside models. The goal is reverse-engineering neural networks into understandable components.

This reveals attention heads, induction heads, and other interpretable patterns.

Like mapping the wiring of an unknown machine to see how it works.

5. Self-Training Instability

When models train on their own generated data, feedback loops can amplify small errors over time. Each iteration compounds mistakes, causing distributional drift.

Careful filtering and external grounding help mitigate this.

Like copying a copy repeatedly until the meaning drifts.

Quick Reference

Short, accurate ML explainers. Follow for more.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #28

Today’s Five

1. Lottery Ticket Hypothesis

Large neural networks contain smaller subnetworks that, when trained from the right initialization, achieve similar performance. These “winning tickets” exist before training begins.

The key insight: you can find and train just the winning subnetwork.

Like finding a winning lottery ticket hidden among many losing ones.

2. Sparse Activation

Only a subset of neurons activate for each input, even in models with many parameters. This allows large capacity without using everything at once.

Mixture-of-experts architectures explicitly design for this pattern.

Like a library where only relevant books light up for each query.

3. Conditional Computation

The model dynamically activates only certain components depending on the input. Different inputs route to different experts or pathways.

This improves efficiency and scalability without proportional compute increase.

Like routing patients to the right specialist instead of seeing every doctor.

4. Inference Parallelism

Model execution can be split across multiple devices to reduce latency or increase throughput. Tensor parallelism splits layers; pipeline parallelism splits stages.

Essential for serving large models in production.

Like dividing a puzzle so multiple people work on it simultaneously.

5. Compute Optimality Hypothesis

Empirical scaling laws suggest performance improves when model size, data, and compute are balanced. Adding only one resource may not yield optimal gains.

Chinchilla showed many models were undertrained relative to their size.

Like baking a cake where proportions matter more than just adding extra ingredients.

Quick Reference

Short, accurate ML explainers. Follow for more.

The Layered Architecture

Layer by Layer

Layer 4: Core Weights (Bottom)

The foundation. Trained once, changed rarely.

Rule: Don’t touch this unless you have a very good reason.

Layer 3: Adapters (Parameter-Efficient Fine-Tuning (PEFT) / Low-Rank Adaptation (LoRA))

Modular skills that plug into the base.

Rule: Train adapters for validated, recurring patterns. Version them. Enable rollback.

Layer 2: External Memory

Facts, experiences, and retrieved knowledge.

Rule: Store experiences here first. Memory is cheap and safe.

Layer 1: Context Manager (Top)

The RLM-style interface that rebuilds focus each step.

Rule: Don’t drag context forward. Rebuild it.

The Feedback Loop

Logging

Capture everything the agent does:

• Prompts received
• Actions taken
• Tool calls made
• Errors encountered
• User signals

This is your training data.

Evaluation

Before any update reaches production:

Without evaluation, you’re updating blind.

Deployment

Updates should be:

• Modular: Can isolate and rollback
• Versioned: Know what changed when
• Staged: Test before full rollout
• Monitored: Track post-deployment metrics

The Error Flow

Where do errors go?

Error occurs
    ↓
Log it (immediate)
    ↓
Store in memory (same day)
    ↓
Pattern emerges over multiple occurrences
    ↓
Train adapter update (weekly/monthly)
    ↓
Validate update (before deployment)
    ↓
Deploy with rollback capability

Errors feed into memory first. Only validated, recurring improvements reach adapters. Core weights almost never change.

What This Architecture Achieves

Design Principles

1. Separate Storage from Reasoning

Facts belong in memory. Reasoning belongs in weights. Don’t blur them.

2. Separate Speed from Permanence

Fast learning (memory) is temporary. Slow learning (weights) is permanent. Match the update speed to the desired permanence.

3. Evaluate Before Consolidating

Every update to adapters or weights must be validated. Regressions are silent killers.

4. Enable Rollback

Version everything. If an update causes problems, you must be able to undo it.

5. Log Everything

You cannot improve what you cannot measure. Structured logging is the foundation of continuous learning.

The Big Picture

AI does not learn in one place.

It learns in layers:

• Permanent (weights)
• Modular (adapters)
• External (memory)
• Temporary (context)

Continuous learning is not constant weight updates.

It is careful coordination across time scales.

Continuous learning systems don’t constantly retrain. They carefully consolidate what works.

References

Series Summary

Continuous learning is layered coordination.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #27

Today’s Five

1. Elastic Weight Consolidation

Adding a penalty that discourages changing parameters important to previous tasks. Importance is estimated using Fisher information from prior training.

This helps models learn new tasks without catastrophic forgetting.

Like protecting well-worn neural pathways while building new ones.

2. Replay Buffers

Storing examples from earlier tasks and mixing them into new training. Past data is replayed alongside current examples during optimization.

This reinforces previous knowledge while learning new data.

Like reviewing old flashcards while studying new material.

3. Parameter Routing

Activating different subsets of model parameters depending on the task or input. Mixture-of-experts and conditional computation route inputs to specialized weights.

Enables specialization without fully separate models.

Like having different experts handle different questions.

4. Memory-Augmented Networks

Adding external memory modules that neural networks can read from and write to. The model learns to store and retrieve information during inference.

Extends beyond purely weight-based memory to explicit storage.

Like giving a calculator access to a notepad.

5. Model Editing

Targeted weight updates to modify specific behaviors without full retraining. Locate and adjust the parameters responsible for particular facts or behaviors.

Allows fast corrections and knowledge updates post-training.

Like editing a specific entry in an encyclopedia instead of rewriting the whole book.

Quick Reference

Short, accurate ML explainers. Follow for more.

The Continuous Learning Loop

The Core Tradeoff

You cannot maximize both simultaneously. The art is in the balance.

Approaches to Continuous Learning

1. Replay-Based Methods

Keep (or synthesize) some old data. Periodically retrain on old + new.

How it works:

• Store representative examples from each task
• Mix old data into new training batches
• Periodically consolidate

Recent work: FOREVER adapts replay timing using “model-centric time” (based on optimizer update magnitude) rather than fixed training steps.

2. Replay-Free Regularization

Constrain weight updates to avoid interference, without storing old data.

Efficient Lifelong Learning Algorithm (ELLA) (Jan 2026): Regularizes updates using subspace de-correlation. Reduces interference while allowing transfer.

Share (Feb 2026): Maintains a single evolving shared low-rank subspace. Integrates new tasks without storing many adapters.

3. Modular Adapters

Keep base model frozen. Train task-specific adapters. Merge or switch as needed.

Evolution:

1. Low-Rank Adaptation (LoRA): Individual adapters per task
2. Shared LoRA spaces: Adapters share subspace
3. Adapter banks: Library of skills to compose

4. Memory-First Learning

Store experiences in external memory. Only consolidate to weights what’s proven stable.

Pattern:

• New information → Memory (fast)
• Validated patterns → Adapters (slow)
• Fundamental capabilities → Weights (rare)

This separates the speed of learning from the permanence of changes.

The Practical Loop

A working continuous learning system:

1. Run agent (with Recursive Language Model (RLM) context management)
2. Collect traces: prompts, tool calls, outcomes, failures
3. Score outcomes: tests, static analysis, user signals
4. Cluster recurring failure patterns
5. Train lightweight updates (LoRA/adapters)
6. Validate retention (did old skills degrade?)
7. Deploy modular update (with rollback capability)

This is not real-time learning. It’s periodic consolidation.

Human analogy: Sleep. Process experiences, consolidate important patterns, prune noise.

Time Scales of Update

Most systems should:

• Update memory frequently
• Update adapters occasionally
• Update core weights rarely

Evaluation Is Critical

Continuous learning without continuous evaluation is dangerous.

Required:

• Retention tests (what got worse?)
• Forward transfer tests (what got better?)
• Regression detection
• Rollback capability

Without these, you’re flying blind.

References

Coming Next

In Part 7, we’ll put it all together: designing a practical continuous learning agent with layered architecture, logging, feedback loops, and safety.

Learn often in memory. Consolidate carefully in weights.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #26

Today’s Five

1. Data Augmentation

Creating additional training examples using label-preserving transformations. Rotate, flip, crop, or color-shift images without changing what they represent.

Effectively increases dataset size and improves generalization.

Like practicing piano pieces at different tempos to build flexibility.

2. Caching Strategies

Storing previous computation results to reduce repeated work and latency. Cache embeddings, KV states, or frequently requested outputs.

Essential for production inference at scale.

Like keeping frequently used books on your desk instead of the library.

3. Constitutional AI

Training models to follow explicit written principles alongside other alignment methods. The constitution provides clear rules for behavior.

Models critique and revise their own outputs against these principles.

Like giving someone written house rules instead of vague instructions.

4. Goodhart’s Law

When a measure becomes a target, it can stop being a good measure. Optimizing for a proxy metric can diverge from the true objective.

A core challenge in reward modeling and evaluation design.

Like studying only for the test instead of learning the subject.

5. Manifold Hypothesis

The idea that real-world data lies on lower-dimensional structures within high-dimensional space. Images of faces don’t fill all possible pixel combinations.

This structure is what representation learning exploits.

Like faces varying along a few key features instead of every pixel independently.

Quick Reference

Short, accurate ML explainers. Follow for more.

Since the initial music-pipe-rs post, the project has grown. There’s now a web demo with playable examples, a new seq stage for explicit note sequences, and multi-instrument arrangements that work in GarageBand.

Web Demo

The live demo showcases pre-built examples with playable audio:

Each tab shows the pipeline script alongside playable audio. See exactly what commands produce each result.

The seq Stage

The new seq stage allows explicit note sequences instead of algorithmic generation:

seed | seq "C4/4 D4/4 E4/4 F4/4 G4/2" | to-midi --out scale.mid

Notation: NOTE/DURATION where duration is in beats. Combine with other stages:

seed | seq "D5/4 C#5/8 R/4 B4/4" | transpose --semitones 5 | humanize | to-midi --out melody.mid

The R represents rests. This enables transcribing existing melodies or composing precise phrases.

Multi-Instrument Arrangements

The Baroque chamber piece demonstrates six-channel composition:

{
    seed 42 | seq "..." --ch 0 --patch 48;  # Strings melody
    seed 42 | seq "..." --ch 1 --patch 6;   # Harpsichord
    seed 42 | seq "..." --ch 2 --patch 74;  # Recorder
    # ... additional voices
} | humanize | to-midi --out baroque.mid

Each instrument gets its own channel and General MIDI patch. The same seed ensures timing coherence across parts.

GarageBand Integration

Import the MIDI files directly into GarageBand:

1. Generate arrangement: ./examples/trio-demo.sh
2. Open GarageBand, create new project
3. Drag the .mid file into the workspace
4. GarageBand creates tracks for each channel
5. Assign software instruments to taste

The demo includes a jazz trio arrangement:

• Piano: Bluesy melody with chords and swing
• Bass: Walking bass line with acoustic bass patch
• Drums: Hi-hat, snare, kick with dynamic variation

All generated from pipeline scripts.

Inspiration

This project was inspired by research into generative music tools and techniques:

The key insight from Opusmodus: algorithmic composition isn’t random music—it’s programmable composition. Motif transformation, rule systems, deterministic generation. music-pipe-rs brings these ideas to Unix pipes.

What’s Next

The pipeline architecture makes extension natural:

• More generators: Markov chains, L-systems, cellular automata
• More transforms: Inversion, retrograde, quantization
• Live mode: Real-time MIDI output with clock sync

Each new capability is just another stage in the pipeline.

Disclaimer

You are responsible for how you use generated audio. Ensure you have the appropriate rights and permissions for any commercial or public use. This tool generates MIDI data algorithmically—how you render and distribute the final audio is your responsibility.

Be aware that algorithmic composition can inadvertently produce sequences similar to existing copyrighted works. Whether you use this tool, AI generation, or compose by hand, you must verify that your output doesn’t infringe on existing copyrights before public release or commercial use. Protect yourself legally.

Lucy is getting an upgrade. I’m adding an X99 motherboard with an RTX 3090 to expand my AI cluster from 10% to 20% brain power.

Resource	Link
Video	Lucy 20% Upgrade
Previous	Lucy 10%

New Hardware: Queenbee

The cluster uses bee-themed naming. The new node is called queenbee:

New AI Capabilities

With queenbee online, Lucy gains several new abilities:

The Active Cluster

Currently active for AI workloads:

Together, they handle the full pipeline: generate images, animate them to video, add lip-synced speech, and produce the final output. See the full apiary inventory below.

Why Local AI?

Running AI locally means:

• Privacy - Data never leaves my network
• No API costs - Unlimited generations after hardware investment
• Customization - Full control over models and parameters
• Learning - Deep understanding of how these systems work

The 24GB of VRAM on the 3090 opens up models that wouldn’t fit on smaller cards. FLUX schnell produces high-quality images in seconds. VoxCPM creates natural-sounding speech that can clone voices from short audio samples.

Bee-Themed Host Names

The full apiary (current and planned nodes):

Notes: Some nodes pending upgrade or configuration. Workers may upgrade to 4x E5-4657L v2 (48C/96T). Honeycomb needs unbrick. K80 GPUs are old and difficult to configure (limited CUDA version support)—will be replaced with M40 GPUs.

Power and Control

Remote management is essential for a home datacenter. The HPE servers include iLO (Integrated Lights-Out) for out-of-band access to BIOS, diagnostics, monitoring, and power control—even when the OS is down.

The combination of iLO and smart outlets means I can remotely power-cycle any server, access its console, and monitor power draw—all from my phone or Home Assistant dashboard. The Bluetti stations primarily provide additional circuits so I can run more servers simultaneously—home electrical limits are a real constraint. More LFP power stations will be needed to power Lucy at 100%.

Networking

Each server has 3 or more NICs, segmented by purpose:

The 10G backbone is essential for moving multi-gigabyte model files between nodes. Loading a 70B parameter model over 1G would take forever—10G fiber makes it practical. The 2.5G network handles interactive work and smaller transfers (using USB NICs where needed), while the 1G management network stays isolated for out-of-band access.

Additional networking notes:

• WiFi 7 for wireless connectivity
• Managed switches with VLANs planned for better network segmentation
• Linux network bonding experiments to increase aggregate transfer rates
• Sneaker net - most servers have hot-swap SAS SSDs and hard drives, so physically moving drives between nodes is sometimes the fastest option for very large transfers

What’s Next

The 20% milestone is just a step. Future upgrades could include:

• Additional GPU nodes for parallel processing
• Larger language models for local inference
• Real-time video generation pipelines
• Integration with more specialized models

The bee hive keeps growing.

Building AI infrastructure one node at a time.

Large context windows are not a complete solution.

As context grows:

• Attention dilutes
• Errors compound
• Reasoning quality degrades

The Context Problem

Transformers have finite attention. With limited attention heads and capacity, the model cannot attend equally to everything. As tokens accumulate:

• Earlier instructions lose influence
• Patterns average toward generic responses
• Multi-step reasoning fails

This is context rot—not forgetting weights, but losing signal in noise.

In-Context Learning (ICL)

The model adapts temporarily via examples in the prompt.

ICL is powerful but ephemeral. It’s working memory, not learning.

Limitation: As context grows, ICL examples compete with other content for attention.

Recursive Language Models (RLM)

RLMs decompose reasoning into multiple passes. Instead of dragging entire context forward:

1. Query relevant memory
2. Retrieve what’s needed now
3. Execute tools
4. Evaluate results
5. Reconstruct focused context
6. Repeat

This treats context as a dynamic environment, not a static blob.

Why RLM Works

Traditional approach:

[System prompt + 50k tokens of history + query]

RLM approach:

[System prompt + retrieved relevant context + current query]

Each reasoning step starts fresh with focused attention.

Context Engineering Techniques

Tool Use as Context Management

Tools aren’t just for actions—they’re for state management.

Instead of keeping everything in context:

• Store in files, databases, or structured formats
• Query when needed
• Return focused results

This converts unbounded context into bounded queries.

The Agent Loop

Modern agents combine these ideas:

while not done:
    # 1. Assess current state
    relevant = retrieve_from_memory(query)

    # 2. Build focused context
    context = [system_prompt, relevant, current_task]

    # 3. Reason
    action = llm(context)

    # 4. Execute
    result = execute_tool(action)

    # 5. Update memory
    memory.store(result)

    # 6. Evaluate
    if goal_achieved(result):
        done = True

Each iteration rebuilds context. No rot accumulation.

Test-Time Adaptation

A related technique: temporarily update weights during inference.

This sits between ICL (no updates) and fine-tuning (permanent updates).

Key Insight

Context is not a static buffer. It’s a dynamic workspace.

Systems that treat context as “append everything” will rot. Systems that actively manage context stay coherent.

References

Coming Next

In Part 6, we’ll connect all of this to continuous learning: replay methods, subspace regularization, adapter evolution, and consolidation loops.

Rebuild focus instead of dragging baggage.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #25

Today’s Five

1. Label Smoothing

Replacing hard one-hot labels with softened target distributions during training. Instead of 100% confidence in one class, distribute small probability to other classes.

Reduces overconfidence and can improve generalization.

Like allowing small uncertainty instead of absolute certainty.

2. Miscalibration

When predicted confidence does not match observed accuracy. A model that says “90% confident” should be right 90% of the time.

Modern neural networks tend to be overconfident. Temperature scaling can help.

Like a forecast that sounds certain but is often wrong.

3. Representation Learning

Learning useful internal features automatically from raw data. Instead of hand-crafting features, the model discovers what matters.

The foundation of deep learning’s success across domains.

Like detecting edges before recognizing full objects.

4. Adversarial Examples

Inputs modified to cause incorrect predictions. Small, often imperceptible changes can flip model outputs.

A security concern and a window into model vulnerabilities.

Like subtle changes that fool a system without obvious differences.

5. Double Descent

Test error that decreases, increases, then decreases again as model capacity grows. The classical bias-variance tradeoff captures only the first part.

Modern overparameterized models operate in the second descent regime.

Like getting worse before getting better—twice.

Quick Reference

Short, accurate ML explainers. Follow for more.

Modern AI systems increasingly rely on external memory.

This shifts “learning” away from parameters.

The Memory Paradigm

Why External Memory?

Most “learning new facts” should not modify weights.

Weights are for generalization. They encode reasoning patterns, language structure, and capability.

Memory is for storage. It holds specific facts, documents, and experiences.

If you store everything in weights:

• You create interference
• You risk forgetting
• You must retrain

If you store facts in memory:

• No forgetting
• Fast updates
• Survives model upgrades

Retrieval-Augmented Generation (RAG)

Documents are embedded into vectors. At query time:

1. Embed the query
2. Search the vector database
3. Retrieve relevant documents
4. Inject into prompt
5. Generate grounded response

The model does not need to remember facts internally. It retrieves them on demand.

RAG Benefits

RAG Challenges

• Retrieval precision (wrong docs = bad answers)
• Latency (search takes time)
• Index maintenance
• Chunk boundaries

Cache-Augmented Generation (CAG)

Instead of retrieving from vector DB, cache previous context or KV states.

Use cases:

• Repeated knowledge tasks
• Multi-turn conversations
• Pre-computed context windows

Benefits over RAG:

• Often faster (no embedding + search)
• More deterministic
• Good for structured repeated workflows

Trade-offs:

• Less flexible
• Cache management complexity

Engram-Style Memory

Recent proposals (e.g., DeepSeek research) introduce conditional memory modules with direct indexing.

Instead of scanning long context or searching vectors:

• Memory slots indexed directly
• O(1) lookup instead of O(n) attention
• Separates static knowledge from dynamic reasoning

The goal: Constant-time memory access that doesn’t scale with context length.

This changes the compute story:

• Don’t waste attention on “known facts”
• Reserve compute for reasoning
• Avoid context rot

Model Editing

A related technique: surgically patch specific facts without full fine-tuning.

Example: The model says “The capital of Australia is Sydney.” You edit the specific association to “Canberra” without retraining.

Pros:

• Targeted fixes
• Fast

Cons:

• Side effects possible
• Consistency not guaranteed

The Key Distinction

When to Use What

References

Coming Next

In Part 5, we’ll examine context engineering and recursive reasoning: ICL, RLM, and techniques that prevent context rot during inference.

The brain stays stable. The notebook grows.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #24

Today’s Five

1. Warmup

Gradually increasing the learning rate at the start of training as part of a learning rate schedule. This helps stabilize early training when gradients can be noisy.

Warmup is especially important for large batch training.

Like stretching before a sprint instead of starting at full speed.

2. Data Leakage

When information unavailable at deployment accidentally influences model training. This creates artificially high validation scores that don’t reflect real-world performance.

Common sources include future data, preprocessing on full dataset, or duplicate samples.

Like memorizing test answers instead of learning the material.

3. Mode Collapse

When a generative model produces limited output diversity. The generator learns to produce only a few outputs that fool the discriminator.

A major challenge in GAN training that various architectures attempt to address.

Like a musician who only plays one song no matter the request.

4. Blue/Green Deployment

Maintaining two production environments and switching traffic between them. One serves live traffic while the other is updated and tested.

Enables instant rollback if problems occur.

Like having a backup stage ready so the show never stops.

5. Reward Hacking

When agents exploit reward functions in unintended ways. The agent optimizes the reward signal rather than the intended objective.

A key challenge in reinforcement learning and AI alignment.

Like gaming the grading rubric instead of learning the material.

Quick Reference

Short, accurate ML explainers. Follow for more.

Resource	Link
Live Demo	IBM 1130 System Emulator
Source	GitHub
Video	IBM 1130 System Emulator
IBM Docs	Functional Characteristics (GA26-5881)
More Docs	Bitsavers IBM 1130 Collection

The System

This isn’t just an assembly emulator—it’s a full system visualization:

Console Panel

The console panel recreates the physical operator interface with all indicator light groups documented in IBM’s Functional Characteristics manual.

Register Display (6 rows × 16 positions)

Right-Side Indicators

Beyond the register displays, the console shows:

• Operation Register (5 bits) - Binary op-code of current instruction
• Format/Tag Indicators - Long instruction format, index register selection
• Cycle Control (T0-T7) - Internal timing pulses for debugging
• Status Lights - Wait, Run, Fetch, Execute, Indirect Address

Control Panel Lights

Operator Controls

• 16-bit toggle switches for manual data entry
• 7-position speed knob - Single Step, SMC, INT RUN, RUN, SI, DISP, LOAD
• Lamp test to verify all indicators function
• Emergency stop button

Assembler Game

Learn the IBM 1130 instruction set interactively:

• Complete instruction set - LD, STO, LDX, STX, A, S, AND, OR, SLA, SRA, BSC, BSI, WAIT
• Memory-mapped index registers - XR1-3 at addresses 1, 2, 3 (historically accurate)
• Step-by-step execution with change highlighting
• Interactive examples covering arithmetic, indexing, shifts
• Progressive challenges with validation

Keypunch

The keypunch simulation supports two card types:

IBM 029 Text Cards

• Hollerith encoding - Standard character-to-punch mapping
• Visual card display - Watch holes appear as you type
• Multi-card decks - Manage multiple cards

IBM 1130 Object Deck (1442 Output)

• Binary card visualization - Machine code punch patterns
• Object deck format - Matches authentic assembler output
• No character printing - Pure binary data cards

The IBM 029 Keypunch produced human-readable text cards. For binary object decks (compiled programs), the IBM 1442 Card Read-Punch would create cards with arbitrary punch patterns that don’t map to characters.

Printer

The IBM 1131 Console Printer simulation:

• Greenbar paper rendering - Authentic line printer output
• Typewriter-style characters - Period-appropriate appearance
• Console output - System messages and program output

Technology

Planned Enhancements

This is a work in progress. Planned features include:

• Additional challenges (10 total)
• Code save/load functionality
• URL sharing of programs
• Breakpoints and memory watches
• Keyboard shortcuts
• Full 1442 Card Read-Punch integration

IBM Documentation References

Project Goals

This is an early proof-of-concept for trying out components that could be extended to produce a more realistic system of devices that could actually run programs. The modular architecture allows each peripheral (console, keypunch, printer) to be developed and refined independently.

A key goal is educational challenges that teach assembly language step by step. The assembler game provides progressive exercises that build understanding from basic load/store operations through arithmetic, indexing, and control flow.

Historical Significance

The IBM 1130 was the first computer for many programmers in the late 1960s and 1970s. Its clean architecture and accessible price point (~$32,000) made it ideal for education.

A Transitional Technology

The IBM 1130 arrived after mechanical calculators and vacuum tube computers, but before dense integrated circuits and microprocessors. This was a unique moment in computing history when machines were complex enough to be powerful, yet simple enough to be fully understood by one person.

The system shipped with complete schematics and diagnostic listings. A field engineer could use an oscilloscope to probe the pins on every transistor. The “integrated circuit” of the era was a small can with a 4×4 pin grid containing just two transistors, mounted on a pluggable card connected via a wire-wrapped backplane. When something failed, you could see it, touch it, and replace it.

Non-Volatile Core Memory

One remarkable feature: magnetic core memory was non-volatile. You could stop the system, power down overnight, come back in the morning, power up, and start your program exactly where it left off—without reloading from cards, tape, or disk.

Each bit was stored as the magnetic polarity of a tiny ferrite ring. No electricity required to maintain state. This made the 1130 remarkably resilient and practical for environments where power wasn’t guaranteed.

Notable fact: The Forth programming language was developed on the IBM 1130 by Charles Moore in the late 1960s.

Personal Experience

In the late 1970s, I worked as an IBM Customer Engineer maintaining a large number of IBM 1130 and 1800 systems used primarily by IBM manufacturing facilities in Kingston, Poughkeepsie, and East Fishkill, New York.

Field service on these machines was hands-on in ways that seem almost unimaginable today. I would often hand-assemble code on paper, converting mnemonics to binary, then enter machine code via the console toggle switches to create a small program. That program’s job? To punch another program onto a card.

I could then insert that punched card into a diagnostic deck to loop on an error condition while I used an oscilloscope and logic schematics to diagnose a failing circuit card. The blinking lights weren’t decoration—they were essential debugging tools that showed exactly what the CPU was doing at each moment.

This emulator recreates that experience: the same indicator lights, the same toggle switches, the same intimate connection between human and machine that made these systems so memorable to work with.

Experience 1960s computing in your browser. Work in progress.

Weight-based learning modifies the neural network itself.

It is slow. It is powerful. It is dangerous.

The Weight-Based Methods

Pretraining

This creates the base model.

It encodes language structure, reasoning patterns, and general world knowledge. The process:

• Trains on terabytes of text
• Uses self-supervised learning (predict next token)
• Runs for weeks or months
• Costs millions of dollars

This learning is rarely repeated for cost reasons. The result is a foundation that everything else builds upon.

Fine-Tuning

Fine-tuning adapts models for specific tasks.

Standard Fine-Tuning

Adjust some or all weights using task-specific data.

Pros:

• Can significantly change behavior
• Works with small datasets

Cons:

• Risk of catastrophic forgetting
• Expensive if you modify all weights
• Hard to undo

Supervised Fine-Tuning (SFT)

Train on instruction → response pairs.

This teaches the model to:

• Follow directions
• Produce helpful outputs
• Maintain conversation structure

Risk: Can reduce other capabilities if data is narrow.

Preference Optimization

Instead of “correct answers,” train from comparisons: preferred vs rejected responses.

Pros: Strong style/safety/helpfulness steering

Cons: Can drift (“over-align”), may conflict with domain competence

Parameter-Efficient Fine-Tuning (PEFT)

Instead of changing all weights, inject small trainable modules.

LoRA (Low-Rank Adaptation)

Insert small low-rank matrices into transformer layers. Only train these matrices.

Benefits:

• Faster training: Fewer parameters to update
• Modular: Can swap adapters
• Version control: Different adapters for different tasks
• Lower forgetting risk: Base weights frozen

Other PEFT Methods

• Prompt tuning: Learn soft prompts
• Prefix tuning: Prepend learned vectors
• Adapters: Small bottleneck layers
• IA³: Learned vectors that scale activations

Shared LoRA Subspaces

Multiple tasks share adapter subspaces to reduce interference.

Recent work (ELLA, Share) maintains evolving shared low-rank subspaces that:

• Reduce interference between tasks
• Enable continual learning
• Keep memory constant

Distillation

Train a smaller model using a larger model as teacher.

Distillation benefits:

• Speeds up inference
• Often improves consistency
• Can reduce hallucination
• Makes deployment cheaper

This is not runtime learning—it’s offline structural learning.

The Alignment Pipeline

Modern models typically go through:

1. Pretraining → General competence
2. SFT → Follow instructions
3. RLHF/DPO → Align with preferences
4. Safety fine-tuning → Reduce harmful outputs

Each step modifies weights. Each step risks forgetting previous capabilities.

Key Insight

Fine-tuning changes the brain. RAG changes the notes on the desk.

Weight-based learning is the core capability layer. It’s slow to change, expensive to update, and risky to modify—but it forms the stable foundation that everything else builds upon.

References

Coming Next

In Part 4, we’ll explore memory-based learning: RAG, CAG, Engram, and other techniques that learn without touching weights.

Change the brain carefully.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #23

Today’s Five

1. Emergent Behavior

Some capabilities appear only when models reach sufficient scale. These behaviors were not directly programmed but arise from learned representations.

Emergence is a key phenomenon in large language models.

Like a child learning words and then suddenly understanding full sentences.

2. Tool Use

Modern AI systems can generate structured commands to call external tools. These include search engines, calculators, or code interpreters.

This extends model capabilities beyond internal knowledge.

Like asking a librarian to look something up instead of guessing.

3. Loss Surface Sharpness

Sharp minima are sensitive to small weight changes. Flatter minima tend to be more robust and often generalize better.

Training methods that find flatter regions can improve test performance.

Like standing on a plateau instead of balancing on a narrow peak.

4. Learning Rate Schedules

Instead of keeping the learning rate constant, training often starts high and gradually reduces it. Schedules like step decay or cosine annealing improve convergence.

Warm restarts can help escape local minima.

Like running fast at first, then slowing down to finish precisely.

5. Canary Deployment

A new model version is rolled out to a small percentage of users first. If problems appear, rollout stops before affecting everyone.

Essential MLOps practice for safe production updates.

Like tasting food before serving it to all your guests.

Quick Reference

Short, accurate ML explainers. Follow for more.

There are two fundamentally different failure modes in modern AI systems.

They are often confused. They should not be.

The Two Failures

Catastrophic Forgetting (Weight-Space Failure)

When you fine-tune a model on new tasks, performance on older tasks may degrade.

This happens because gradient descent updates overlap in parameter space. The model does not “know” which weights correspond to which task. It optimizes globally.

Example: Fine-tune a model on medical text. Its ability to write code degrades. The new learning overwrote old capabilities.

Why It Happens

Neural networks store knowledge distributed across many weights. When you update those weights for Task D, you modify the same parameters that encoded Task A. The old knowledge gets overwritten.

This is the stability vs plasticity tradeoff:

• Plasticity: Learn new things quickly
• Stability: Retain old things reliably

You cannot maximize both simultaneously.

Solutions

Context Rot (Inference-Time Failure)

Context rot is not weight damage.

It happens when:

• Prompts grow too large
• Earlier instructions get diluted
• Attention spreads thin
• The model begins averaging patterns instead of reasoning

Example: A 50,000 token conversation. The original system prompt is still there, but the model stops following it. Earlier context gets “forgotten” even though it’s technically present.

Why It Happens

Transformer attention is finite. With limited attention heads and capacity, the model cannot attend equally to everything. As context grows, earlier tokens receive less attention weight.

This creates:

• Instruction drift: Original instructions lose influence
• Pattern averaging: The model reverts to generic responses
• Lost coherence: Multi-step reasoning fails

Solutions

The Critical Distinction

Why This Matters

If you confuse these failure modes, you apply the wrong fix.

• Forgetting problem? Don’t add more context. Fix your training.
• Context rot problem? Don’t retrain. Fix your context management.

Many “AI agents that forget” discussions conflate both. Modern systems need solutions for both simultaneously.

References

Coming Next

In Part 3, we’ll examine weight-based learning in detail: pretraining, fine-tuning, LoRA, alignment methods, and distillation.

Different failures need different fixes.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #22

Today’s Five

1. RSFT (Rejection Sampling Fine-Tuning)

A method where many model outputs are generated, weaker ones are filtered out, and the best samples are used for further fine-tuning. It improves output quality without full reinforcement learning.

The model learns from its own best attempts.

Like practicing many attempts and studying only your best ones.

2. Model Steerability

The ability to adjust a model’s behavior through prompts, parameters, or control mechanisms. This allows flexible behavior without retraining.

Steerable models can adapt to different tasks or styles at inference time.

Like steering a car instead of letting it move in a fixed direction.

3. LSTM (Long Short-Term Memory)

A recurrent neural network architecture with gates that regulate memory flow. It was designed to mitigate vanishing gradient problems in sequence modeling.

LSTMs decide what to remember and what to forget at each time step.

Like a notebook where you choose what to keep and what to forget.

4. Why More Data Beats Better Models

In many cases, adding high-quality data improves performance more than small architecture improvements. Data scale often matters as much as model design.

This is sometimes called “the unreasonable effectiveness of data.”

Like practicing with many real conversations instead of perfecting one grammar rule.

5. System Reliability vs Model Quality

A slightly less accurate model that runs reliably can outperform a fragile but slightly better one. Engineers balance uptime, latency, and stability against pure accuracy.

Production systems need both correctness and dependability.

Like choosing a reliable car over a faster one that breaks down often.

Quick Reference

Short, accurate ML explainers. Follow for more.

In Part 1, we demonstrated that multiple scouts dramatically improve learning in sparse-reward environments. Five scouts achieved 60% success where a single scout achieved 0%.

This post explores how scouts explore: intrinsic rewards that drive novelty-seeking behavior, and what happens when you mix different exploration strategies.

Resource	Link
Code	many-eyes-learning
Part 1	Solving Sparse Rewards with Many Eyes
Video	Many-Eyes Learning: Watch AI Scouts Explore

Recap: The Many-Eyes Architecture

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Scout 1   │  │   Scout 2   │  │   Scout N   │
│ (strategy A)│  │ (strategy B)│  │ (strategy N)│
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       v                v                v
┌─────────────────────────────────────────────────┐
│              Experience Buffer                   │
└─────────────────────────────────────────────────┘
                       │
                       v
┌─────────────────────────────────────────────────┐
│               Shared Learner                     │
└─────────────────────────────────────────────────┘

Scouts are information gatherers, not independent learners. They explore with different strategies, pool their discoveries, and a shared learner benefits from the combined experience.

New Scout Strategies

CuriousScout: Count-Based Novelty

IRPO formalizes intrinsic rewards as the mechanism that drives scout exploration. CuriousScout implements count-based curiosity:

class CuriousScout(Scout):
    def __init__(self, bonus_scale: float = 1.0):
        self.state_counts = defaultdict(int)
        self.bonus_scale = bonus_scale

    def intrinsic_reward(self, state):
        count = self.state_counts[state]
        return self.bonus_scale / sqrt(count + 1)

How it works:

• Track how many times each state has been visited
• Reward = bonus_scale / √(count + 1)
• Novel states get high rewards; familiar states get diminishing returns

The intuition: A curious scout is drawn to unexplored territory. The first visit to a state is exciting (reward = 1.0). The fourth visit is mundane (reward = 0.5). This creates natural pressure to explore widely.

OptimisticScout: Optimism Under Uncertainty

A different philosophy: assume unknown states are valuable until proven otherwise.

class OptimisticScout(Scout):
    def __init__(self, optimism: float = 10.0):
        self.optimism = optimism

    def initial_q_value(self):
        return self.optimism  # Instead of 0

How it works:

• Initialize all Q-values to a high value (e.g., 10.0)
• The agent is “optimistic” about unvisited state-action pairs
• As it explores and receives actual rewards, Q-values decay toward reality

The intuition: If you’ve never tried something, assume it might be great. This drives exploration without explicit novelty bonuses.

Strategy Comparison

The Diversity Experiment

Does mixing strategies help, or is it enough to have multiple scouts with the same good strategy?

Setup

• 7x7 sparse grid, 100 training episodes
• All configurations use exactly 5 scouts (fair comparison)
• 5 random seeds for statistical significance

Configurations

1. Homogeneous Random: 5 identical random scouts
2. Homogeneous Epsilon: 5 identical epsilon-greedy scouts (ε=0.2)
3. Diverse Mix: Random + 2 epsilon-greedy (ε=0.1, 0.3) + CuriousScout + OptimisticScout

Results

Analysis

Finding: Strategy quality matters more than diversity in simple environments.

• Epsilon-greedy (homogeneous or mixed) outperforms pure random
• Diverse mix performs the same as homogeneous epsilon-greedy
• Having 5 good scouts beats having 5 diverse but weaker scouts

Why doesn’t diversity help here?

In a simple 7x7 grid, the exploration problem is primarily about coverage, not strategy complementarity. Five epsilon-greedy scouts with different random seeds already explore different regions due to stochastic action selection.

Diversity likely provides more benefit in:

• Complex environments with multiple local optima
• Tasks requiring different behavioral modes
• Environments with deceptive reward structures

Web Visualization

The web visualization demonstrates Many-Eyes Learning with real-time parallel scout movement. (The upcoming video walks through this demo—the post focuses on the underlying mechanism.)

How It Works

The web version uses Q-learning with a shared Q-table (simpler than DQN for clarity). All scouts contribute to the same Q-table—the core “many eyes” concept: more explorers = faster Q-value convergence.

Exploration Modes

The UI provides a dropdown to select different exploration strategies:

The Diversity vs Performance Trade-off

There’s a fundamental trade-off between visual diversity and learning performance:

• Shared Policy wins on performance: The “many eyes” benefit comes from diverse exploration during learning (finding the goal faster). But once Q-values converge, all scouts should follow the same optimal policy.

• Diverse Paths sacrifices performance for visuals: Scout-specific directional biases (Scout 1 prefers right, Scout 2 prefers down) create visually interesting heatmaps but suboptimal behavior.

• High Exploration never converges: Fixed 50% random actions means scouts never fully exploit the learned policy.

Key insight: For best learning, use Shared Policy. Use other modes to visualize how different exploration strategies affect the learning process, but expect higher average steps.

Learning Phases

Why “Average Steps to Goal”?

Success rate is coarse-grained—with 5 scouts, only 6 values are possible (0%, 20%, 40%, 60%, 80%, 100%). After ~10 episodes, all scouts typically reach the goal. Average steps shows continued policy refinement, dropping from ~70 (random) to ~8 (optimal).

Running the Visualization

./scripts/serve.sh   # Open http://localhost:3200

• Yew/WASM frontend with FastAPI backend
• Speed control from 1x to 100x
• Replay mode to step through recorded training

What’s Next

Potential future directions:

Key Takeaways

1. Intrinsic rewards drive exploration. CuriousScout and OptimisticScout implement different philosophies: novelty bonuses vs optimistic initialization.

2. Strategy quality > diversity in simple environments. Five good scouts beat five diverse but weaker scouts.

3. Diversity during learning, convergence after. The “many eyes” benefit comes from diverse exploration during learning. Once Q-values converge, all scouts should follow the same optimal policy.

4. Shared Q-table enables collective learning. All scouts contribute to one Q-table—more explorers means faster convergence.

5. Visual diversity costs performance. Modes like “Diverse Paths” create interesting heatmaps but suboptimal behavior. Use “Shared Policy” for best learning results.

References

Diverse exploration, convergent execution. Many eyes see more, but the best path is the one they all agree on.

When people say, “AI learned something,” they usually mean one of at least four very different things.

Large Language Models (LLMs) do not learn in one single way. They learn at different time scales, in different locations, and with very different consequences. To understand modern AI systems—especially agents—we need to separate these layers.

Four Time Scales of Learning

1. Pretraining (Years)

This is the foundation.

The model trains on massive datasets using gradient descent. The result is a set of weights—billions of parameters—encoding statistical structure of language and knowledge.

This learning:

• Is slow and expensive
• Persists across restarts
• Cannot easily be reversed
• Is vulnerable to interference if modified later

Think of this as long-term biological memory.

2. Fine-Tuning (Days to Weeks)

Fine-tuning modifies the weights further, but with narrower data.

This includes:

• Instruction tuning (following directions)
• Alignment methods (Reinforcement Learning from Human Feedback (RLHF), Direct Preference Optimization (DPO))
• Domain adaptation
• Parameter-efficient methods like Low-Rank Adaptation (LoRA)

This is still weight-based learning.

It persists across restarts. It risks catastrophic forgetting. It modifies the brain itself.

3. Memory-Based Learning (Seconds to Minutes)

This is where many modern systems shift.

Instead of changing weights, they store information externally:

• RAG (Retrieval-Augmented Generation)
• CAG (Cache-Augmented Generation)
• Vector databases
• Engram-style memory modules

The model retrieves relevant memory per query.

The brain stays stable. The notebook grows.

This learning:

• Persists across restarts
• Survives model upgrades
• Does not cause forgetting
• Is fast

4. In-Context Learning (Milliseconds)

This is temporary reasoning scaffolding.

Information exists only in the prompt window.

It:

• Does not update weights
• Does not persist across sessions
• Is powerful but fragile
• Suffers from context rot

This is working memory.

Why This Matters

Most discussions collapse all of this into “the model learned.”

But:

• Updating weights risks forgetting
• Updating memory does not
• Updating prompts does not persist
• Updating adapters can be modular and reversible

Continuous learning systems must coordinate all four.

Persistence Comparison

That last column is subtle but powerful for agents.

References

Coming Next

In Part 2, we’ll examine the two fundamental failure modes that arise from confusing these layers: catastrophic forgetting and context rot.

Learning happens in layers of permanence.

After building midi-cli-rs for quick mood-based generation, I wanted something more surgical. What if music generation worked like Unix commands—small tools connected by pipes?

The Unix Philosophy for Music

Most generative music tools are monolithic. You get one application with a closed workflow. If you want to inspect intermediate results, you can’t. If you want to swap one transformation for another, you rebuild everything.

Unix solved this decades ago: small tools that do one thing well, connected by pipes. Each tool reads from stdin, writes to stdout. You can inspect any point in the pipeline with head, filter with grep, transform with jq.

music-pipe-rs applies this philosophy to MIDI composition.

A Pipeline in Action

seed 12345 | motif --notes 16 --bpm 120 | humanize | to-midi --out melody.mid

Four stages:

1. seed establishes the random seed for the entire pipeline
2. motif generates a melodic pattern (using the pipeline seed)
3. humanize adds timing and velocity variation (using the same seed)
4. to-midi converts the event stream to a standard .mid file

The output plays in any DAW.

Seed-First Architecture

The seed stage goes at the head of the pipeline:

# Explicit seed for reproducibility
seed 12345 | motif --notes 16 | humanize | to-midi --out melody.mid

# Auto-generated seed (printed to stderr)
seed | motif --notes 16 | humanize | to-midi --out melody.mid
# stderr: seed: 1708732845

All downstream stages read the seed from the event stream. No --seed arguments scattered across the pipeline. One seed, set once, used everywhere.

This means:

• Same seed = identical output across all random stages
• Different seed = different composition with same structure
• Reproducibility is trivial: just save the seed number

JSONL: The Intermediate Format

Between stages, events flow as JSONL (JSON Lines). Each line is a complete event:

{"type":"Seed","seed":12345}
{"type":"NoteOn","t":0,"ch":0,"key":60,"vel":80}
{"type":"NoteOff","t":480,"ch":0,"key":60}

This format is human-readable and tool-friendly:

# See the first 10 events
seed 42 | motif --notes 8 | head -10

# Count how many NoteOn events
seed 42 | motif --notes 16 | grep NoteOn | wc -l

# Pretty-print with jq
seed 42 | motif --notes 4 | jq .

No binary formats to decode. No proprietary protocols. Just text.

Visualization with viz

The viz stage prints a sparkline to stderr while passing events through:

seed 12345 | motif --notes 16 | viz | humanize | to-midi --out melody.mid

Output on stderr:

▃▅▇▅▃▁▂▄▆▇▆▄▂▁▃▅

For more detail, use piano roll mode:

seed 12345 | motif --notes 16 | viz --roll

 G6 │···█············│
F#6 │·····█··········│
 F6 │····█···········│
 G5 │·██·········█···│
 F5 │···········█····│
 E5 │·········██···█·│
 C5 │█·····███····█·█│

The visualization goes to stderr; the JSONL events continue to stdout. You can inspect the music without breaking the pipeline.

Available Stages

Each stage is a separate binary. Mix and match as needed.

Euclidean Rhythms

The euclid stage generates Euclidean rhythms—mathematically optimal distributions of hits across steps:

# 3 hits distributed across 8 steps (Cuban tresillo)
seed | euclid --pulses 3 --steps 8 --note 36 | to-midi --out kick.mid

# 4-on-the-floor kick pattern
seed | euclid --pulses 4 --steps 16 --note 36 | to-midi --out four-floor.mid

These patterns appear in music worldwide because they “feel right”—the spacing is as even as possible.

Scale Locking

The scale stage constrains notes to a musical scale:

seed 42 | motif --notes 16 | scale --root C --mode minor | to-midi --out c-minor.mid

No wrong notes. Every pitch fits the harmonic context.

Layering Streams

Generate drum and melody separately, then combine:

{
    seed 100 | euclid --pulses 4 --steps 16 --note 36 --ch 9;
    seed 100 | motif --notes 16 | scale --root C --mode pentatonic;
} | to-midi --out layered.mid

Channel 9 is General MIDI drums. Same seed ensures coherence between parts. Both streams merge into a single MIDI file.

Why Not Just Use midi-cli-rs?

Different tools for different needs:

midi-cli-rs is high-level: pick a mood, get music. music-pipe-rs is low-level: build compositions from primitive operations.

Both are useful. Both work with AI coding agents.

The Personal Software Pattern

This continues the theme: build small tools that compose well. Don’t try to solve everything in one application. Let Unix handle orchestration.

The best part? Standard tools still work. head, grep, jq, wc—all participate in the pipeline. No special music knowledge required to inspect the data.

Disclaimer

You are responsible for how you use generated audio. Ensure you have the appropriate rights and permissions for any commercial or public use. This tool generates MIDI data algorithmically—how you render and distribute the final audio is your responsibility.

Be aware that algorithmic composition can inadvertently produce sequences similar to existing copyrighted works. Whether you use this tool, AI generation, or compose by hand, you must verify that your output doesn’t infringe on existing copyrights before public release or commercial use. Protect yourself legally.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #21

Today’s Five

1. Prompt Injection

Malicious instructions embedded in user input that override intended system behavior. An attacker crafts text that tricks an AI into ignoring its original instructions.

This is a major security concern for LLM-integrated applications.

Like slipping a forged instruction into a trusted document.

2. Jailbreaks

Techniques that attempt to bypass safety constraints in AI systems. These attacks exploit gaps between a model’s capabilities and its safety training.

Safety training can fail due to competing objectives or mismatched generalization.

Like convincing a guard to bend the rules.

3. GRU (Gated Recurrent Unit)

A recurrent neural network unit with gates that control memory flow. GRUs decide what information to keep and what to discard at each time step.

Simpler than LSTM but designed for similar sequence modeling tasks.

Like a notepad where you decide what to keep and what to erase.

4. Planning vs Prediction

Prediction forecasts likely outcomes. Planning evaluates actions across possible futures. Accurate predictions don’t guarantee good decisions—you also need to model how actions affect outcomes.

This is a key gap in many AI/ML systems.

Like knowing it will rain versus deciding whether to bring an umbrella.

5. Production Rollbacks

Reverting to a previous stable model version after deployment issues. When a new model causes problems in production, rolling back quickly minimizes impact.

Essential MLOps practice for maintaining system reliability.

Like reloading a saved game state when something breaks.

Quick Reference

Short, accurate ML explainers. Follow for more.

Personal Software doesn’t stop at “it works.” It evolves. After building midi-cli-rs for AI agents to generate music, I wanted more moods—without recompiling Rust every time.

The solution: a plugin system that lets anyone create custom mood packs using simple TOML files.

Resource	Link
Examples	Listen to Samples
Wiki	Plugin Documentation
Video	Plugin Moods Explainer
Code	midi-cli-rs

The Problem with Built-in Only

The original midi-cli-rs shipped with a handful of mood presets: suspense, eerie, upbeat, calm, ambient, jazz. Useful, but limited. What if you want synthwave? Chillout? Something faster or in a different key?

Hardcoding every possible mood isn’t practical. And asking users to modify Rust source code isn’t friendly.

Three Levels of Extensibility

This post covers Plugin Moods—the middle tier. You can preset combinations of tempo, key, and intensity, but you’re still using the built-in generators’ musical logic. Want a “smooth-jazz” preset (slower, mellower)? Plugin mood. Want bebop or Latin jazz with different chord progressions? That requires a custom generator.

Custom generators (writing new Rust code) will be covered in a future post when the plugin editor ships.

The Plugin Architecture

Custom moods live in ~/.midi-cli-rs/moods/ as TOML files. Each file is a “mood pack” that can define multiple moods. The CLI discovers them automatically.

Here’s how it works:

~/.midi-cli-rs/
└── moods/
    ├── electronic.toml    # Your synthwave, techno, etc.
    ├── cinematic.toml     # Epic, tension, wonder
    └── seasonal.toml      # Holiday themes

Creating a Mood Pack

A plug-in mood pack has two parts: pack metadata and mood definitions.

[pack]
name = "electronic"
version = "1.0.0"
author = "Your Name"
description = "Electronic music styles"

[[moods]]
name = "synthwave"
base_mood = "upbeat"
default_tempo = 118
default_key = "Am"
default_intensity = 65
description = "80s synthwave vibes"
tags = ["electronic", "retro"]

[[moods]]
name = "chillout"
base_mood = "ambient"
default_tempo = 85
default_key = "Em"
default_intensity = 40
description = "Relaxed electronic"

Each mood delegates to a built-in generator (base_mood) but overrides specific parameters. You get the musical logic of the built-in mood with your customizations applied.

Available Base Moods

Your custom moods can extend any of the nine built-in generators:

Configuration Options

Each mood definition supports these overrides:

How Seeds Create Variation

Seeds aren’t random—they’re deterministic variation selectors. The same mood + same seed always produces identical output. But different seeds create observable musical differences across multiple dimensions:

The system uses hash-based mixing with unique salts for each parameter. This means adjacent seeds (42 vs 43) produce completely different outputs—no gradual transitions between seeds.

When you combine plugin moods with seed variation, you get a matrix: your custom tempo/key/intensity settings applied across different seed-driven variations of the underlying generator’s patterns.

Using Custom Moods

Once your TOML file is in place, the mood appears automatically:

# List all moods (built-in + plugins)
midi-cli-rs moods

# Generate with your custom mood
midi-cli-rs preset -m synthwave -d 5 -s 42 -o output.wav

The seed system still works—same mood + same seed = identical output.

Example: Electronic Pack

Here’s a complete pack with four electronic moods:

[pack]
name = "electronic"
version = "1.0.0"
description = "Electronic music styles"

[[moods]]
name = "synthwave"
base_mood = "upbeat"
default_tempo = 118
default_key = "Am"
default_intensity = 65

[[moods]]
name = "chillout"
base_mood = "ambient"
default_tempo = 85
default_key = "Em"
default_intensity = 40

[[moods]]
name = "techno"
base_mood = "upbeat"
default_tempo = 130
default_key = "Dm"
default_intensity = 85

[[moods]]
name = "8bit"
base_mood = "chiptune"
default_tempo = 140
default_key = "C"
default_intensity = 70

Drop this in ~/.midi-cli-rs/moods/electronic.toml and you have four new moods.

What’s Next

This plugin system handles mood variations—different tempos, keys, and intensities applied to existing generators. A future update will add a plugin editor for creating entirely new musical patterns without writing Rust.

For now, the delegation model covers most use cases: want faster jazz? Darker ambient? Major-key suspense? Create a TOML file and you’re done.

The Personal Software Pattern

This follows the Personal Software philosophy: start with something that works, then extend it as needs emerge. The plugin system wasn’t in the original design. It grew from actual use—wanting more moods without recompiling.

Good personal software leaves room to grow.

Disclaimer

You are responsible for how you use generated audio. Ensure you have the appropriate rights and permissions for any commercial or public use. This tool generates MIDI data algorithmically—how you render and distribute the final audio is your responsibility.

Be aware that algorithmic composition can inadvertently produce sequences similar to existing copyrighted works. Whether you use this tool, AI generation, or compose by hand, you must verify that your output doesn’t infringe on existing copyrights before public release or commercial use. Protect yourself legally.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #20

Today’s Five

1. Variational Autoencoders (VAEs)

VAEs are probabilistic autoencoders that learn a structured latent distribution. By sampling from that distribution, they can generate new examples similar to the training data.

The key innovation is regularizing the latent space to be smooth and continuous.

Like learning not just to summarize books, but to create new ones in a similar style.

2. Uncertainty Estimation

Models can estimate how confident they should be in predictions. Some uncertainty comes from noisy data (aleatoric), and some from limited knowledge (epistemic).

Knowing when a model is uncertain enables safer decision-making.

Like a weather forecast giving seventy percent chance of rain instead of a simple yes or no.

3. Why Interpretability Is Hard

Neural networks represent information across many interacting parameters. No single component cleanly maps to a human concept.

Distributed representations enable powerful learning but resist simple explanations.

Like trying to explain a dream by pointing to individual neurons.

4. Gradient Noise

When training with mini-batches, gradients vary from step to step. A little noise can help exploration, but too much can slow convergence.

Batch size, learning rate, and gradient clipping all influence this noise level.

Like getting slightly different directions each time you ask for help.

5. Human-in-the-Loop Systems

Humans review, supervise, or override model decisions in critical workflows. This improves safety and accountability in high-stakes applications.

The approach combines model efficiency with human judgment where it matters most.

Like a pilot monitoring autopilot and stepping in when necessary.

Quick Reference

Short, accurate ML explainers. Follow for more.

It was 2020 when GPT-3 shocked everyone. It could learn from examples in the query—without updating its weights. We called it In-Context Learning. But was it magic, or was it doing something deeper?

Resource	Link
Video	ICL Revisited
Papers	4 References

Phase 1: The Empirical Discovery (2020)

The GPT-3 paper showed that large models could perform few-shot learning. Give them examples, and they generalize. No gradient updates. No retraining. Just forward passes.

The surprising part was that scaling alone seemed to unlock it.

Paper: Language Models are Few-Shot Learners

ELI5: Show a big language model a few examples of a task in your prompt, and it figures out how to do the task—without any retraining. Nobody told it to do this. It just emerged when models got big enough.

Main idea: Scale unlocks emergent capabilities. ICL was discovered, not designed.

Phase 2: Mechanistic Explanations (2022)

By 2022, researchers began probing the internal mechanisms. Several papers proposed that transformers implement implicit meta-learning. The model appears to learn during inference by performing gradient-descent-like operations internally.

Paper: What Explains In-Context Learning in Transformers?

ELI5: When you give a transformer examples, its attention layers do something that looks like fitting a simple linear model to those examples—on the fly, during the forward pass. It’s not memorizing; it’s computing a mini-solution.

Main idea: ICL works because attention can simulate linear regression internally.

Paper: Transformers Learn In-Context by Gradient Descent

ELI5: The transformer’s forward pass is secretly doing something similar to training. The attention mechanism acts like one step of gradient descent over the examples you provided. Learning happens inside inference.

Main idea: ICL is implicit gradient descent—learning hidden inside prediction.

Phase 3: Engineering the Effect

Once researchers understood that ordering and structure affect ICL, prompt design became less of an art and more of an optimization problem. The quality and arrangement of demonstrations directly shape performance.

ICL became tunable. Researchers could now deliberately improve it rather than just observe it.

Phase 4: Interactive ICL (2026)

Recent work pushes this further. Models are trained to predict natural language critiques and feedback. If a model can predict what a teacher would say, it can internalize that signal. External correction becomes an internal capability.

Paper: Improving Interactive In-Context Learning from Natural Language Feedback

ELI5: Train a model to guess what feedback a human would give. Now the model has internalized the “teacher” and can improve itself without needing the actual teacher present. Self-correction without weight updates.

Main idea: Models can learn to learn from feedback, making ICL interactive and self-improving.

Beyond Language

Newer work applies ICL to neuroscience discovery, showing that the mechanism is not limited to text tasks. It becomes a flexible reasoning substrate across domains. That’s when you know a concept has matured.

The Arc

The Deeper Insight

In-Context Learning started as an emergent surprise. Now it’s becoming an engineered learning substrate inside transformers.

It was not magic. It was meta-learning hiding in plain sight.

ICL started as “whoa, it works.” Now we understand “why it works.” Next: engineering it deliberately.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #19

Today’s Five

1. Autoencoders

Autoencoders are neural networks trained to compress inputs into a smaller representation and reconstruct them. The bottleneck forces the model to capture essential structure.

This learned compression is useful for dimensionality reduction, denoising, and feature learning.

Like summarizing a book into key points and then rebuilding the story from that summary.

2. Correlation vs Causation

Two variables can move together without one causing the other. Models typically learn correlations present in data, not true cause-and-effect relationships.

This matters because interventions based on correlation alone may not produce intended effects.

Like noticing umbrella sales rise with rain—umbrellas don’t cause rain.

3. Curriculum Learning

Training starts with easier examples and gradually introduces harder ones. This can improve stability and learning speed in some settings.

The approach mirrors how humans learn complex subjects incrementally.

Like teaching math by starting with addition before moving to calculus.

4. Failure Analysis

Failure analysis groups model errors into categories to understand where performance breaks down. This helps target improvements instead of guessing.

Systematic error analysis often reveals actionable patterns invisible in aggregate metrics.

Like a teacher reviewing which types of questions students miss most often.

5. Covariate Shift

Covariate shift occurs when the input distribution changes between training and deployment, while the task itself remains the same. The model may underperform because it sees unfamiliar inputs.

Monitoring input distributions helps detect this shift early.

Like training a driver in sunny weather and testing them in snow.

Quick Reference

Short, accurate ML explainers. Follow for more.

JSON is everywhere. APIs. Logs. Databases. Configuration files. But it’s not alone. A whole ecosystem of formats exists—each optimizing for different tradeoffs.

This post expands on the JSON et al short, providing technical depth on each format: when it was created, where it’s specified, and what problems it solves.

The Tradeoff Triangle

Before diving in, understand the fundamental constraint. Data formats balance three competing goals:

You usually only get two. JSON optimizes readability. Protobuf optimizes compactness. JSONB optimizes query performance. No format wins everywhere.

JSON: The Ubiquitous Baseline

Created: 2001 (discovered/formalized by Douglas Crockford) Specification: ECMA-404 (2013), RFC 8259 (2017) File Extension: .json

JSON (JavaScript Object Notation) emerged from JavaScript’s object literal syntax but became language-agnostic. Crockford didn’t invent it—he “discovered” it already existing in JavaScript and formalized the specification.

Technical Details

• Encoding: UTF-8 text (UTF-16/32 allowed but rare)
• Data Types: Objects {}, arrays [], strings, numbers, booleans, null
• Schema: None required
• Comments: Not allowed in strict JSON

Strengths

• Universal parser support (every language has one)
• Human readable without tools
• Web-native (JavaScript parses it natively)
• Simple specification (fits on a business card)

Weaknesses

• Verbose (field names repeated for every object)
• No binary data type (must base64-encode)
• No comments (frustrating for config files)
• Parsing overhead (tokenization + string decoding every time)

ELI5

Like typing a long email instead of sending a terse text. Every message spells everything out—clear, but verbose.

When to Use

REST APIs, configuration (when comments aren’t needed), data interchange between systems, anywhere human readability matters more than efficiency.

JSONL / NDJSON: Streaming JSON

Created: ~2013 (formalized) Specification: JSON Lines, NDJSON File Extension: .jsonl, .ndjson

JSONL (JSON Lines) and NDJSON (Newline-Delimited JSON) are the same concept: one valid JSON object per line, separated by newlines.

Technical Details

{"name": "Alice", "score": 95}
{"name": "Bob", "score": 87}
{"name": "Carol", "score": 92}

No wrapping array. Each line is independently parseable.

Strengths

• Streaming: Process line-by-line without loading entire file
• Append-only: Add records without rewriting the file
• Parallel processing: Split by line, distribute to workers
• Fault-tolerant: One corrupt line doesn’t invalidate the file

Weaknesses

• Not valid JSON (can’t parse with standard JSON parser)
• Still text-based (same verbosity as JSON)
• No random access by index

ELI5

Like removing one comma per line to save some typing. Each line is self-contained, so you can grab and process them one at a time.

When to Use

Log files, big data pipelines (Spark, Pandas), ML datasets, event streams, anywhere you need to process records incrementally.

JSONB: Binary JSON for Databases

Created: 2014 (PostgreSQL 9.4) Specification: Implementation-specific (no universal standard) Storage: Database column type

JSONB isn’t a file format—it’s a database storage optimization. PostgreSQL’s JSONB differs from MongoDB’s BSON, which differs from other implementations.

PostgreSQL JSONB Details

• Parsed once: Text converted to binary on INSERT
• Keys sorted: Deterministic ordering for indexing
• Duplicates removed: Last value wins
• Offset table: O(log n) field lookup instead of O(n) text scanning

MongoDB BSON

Specification: bsonspec.org

BSON (Binary JSON) is MongoDB’s serialization format. Unlike PostgreSQL’s JSONB, BSON is a standalone binary format:

• Type-prefixed values
• Supports additional types (Date, Binary, ObjectId)
• Length-prefixed for fast skipping
• ~10-15% smaller than JSON typically

Strengths

• Fast queries without re-parsing
• Indexable (GIN indexes on JSONB in PostgreSQL)
• Type coercion at storage time

Weaknesses

• Not portable (implementation-specific)
• Not human-readable
• INSERT overhead (parsing cost upfront)

ELI5

Instead of cooking from scratch every time, you heat a pre-made meal. The prep work happens once (on INSERT), so serving (queries) is fast.

When to Use

Database storage where you query into JSON structures. PostgreSQL JSONB + GIN indexes enable fast @> containment queries.

Protocol Buffers: Google’s Schema-First Format

Created: 2001 (internal Google), 2008 (open-sourced) Specification: developers.google.com/protocol-buffers File Extension: .proto (schema), binary wire format

Protocol Buffers (Protobuf) is Google’s language-neutral, schema-required serialization format. It powers gRPC.

Technical Details

Schema definition:

message Sensor {
  int32 temperature = 1;
  int32 humidity = 2;
}

Wire format uses field numbers, not names:

Field 1: 72
Field 2: 40

Key Features

• Varint encoding: Small integers use fewer bytes
• Field numbers: Enable backward compatibility
• Code generation: .proto → language-specific classes
• No self-description: Receiver must know schema

Strengths

• Extremely compact (3-10x smaller than JSON typically)
• Fast serialization/deserialization
• Strong versioning semantics
• gRPC integration

Weaknesses

• Requires schema agreement
• Not human-readable
• Tooling required for debugging
• Schema evolution has rules

ELI5

Everyone agrees upfront what “field 1” means. You don’t waste space spelling out “temperature”—you just send the number 1 and the value. Both sides know the code.

When to Use

Microservices (gRPC), internal APIs, anywhere bandwidth and latency matter more than debuggability.

ASN.1: The Telecom Veteran

Created: 1984 (ITU-T X.208) Specification: ITU-T X.680-X.683 Encoding Rules: BER, DER, PER, XER, and more

ASN.1 (Abstract Syntax Notation One) predates all modern formats. It defines both schema and encoding, with multiple encoding rules for different use cases.

Encoding Rules Comparison

Where You See ASN.1

• X.509 certificates (SSL/TLS certs are DER-encoded ASN.1)
• LDAP (directory services)
• SNMP (network management)
• Telecom protocols (SS7, GSM, LTE)

Strengths

• Bit-level precision
• Proven over 40 years
• Multiple encoding options
• Formal verification possible

Weaknesses

• Complex specification
• Steep learning curve
• Tooling can be expensive
• Security vulnerabilities in parsers (historically)

ELI5

Same idea as Protobuf—everyone agrees upfront what each field number means. ASN.1 just got there 20 years earlier and handles even more edge cases.

When to Use

You probably won’t choose ASN.1 for new projects. You’ll encounter it in cryptography, certificates, and legacy telecom systems.

YAML: Human-Friendly Configuration

Created: 2001 (Clark Evans, Ingy döt Net, Oren Ben-Kiki) Specification: yaml.org/spec/1.2.2 File Extension: .yaml, .yml

YAML (YAML Ain’t Markup Language) prioritizes human readability. It’s a superset of JSON—any valid JSON is valid YAML.

Technical Details

# Comments allowed!
server:
  host: localhost
  port: 8080
  features:
    - auth
    - logging

Key Features

• Indentation-based: Whitespace matters
• Comments: # for single-line
• Anchors/aliases: &name and *name for references
• Multiple documents: --- separator

Strengths

• Highly readable
• Comments supported
• Multi-line strings without escaping
• Complex data structures

Weaknesses

• “Norway problem”: NO parses as boolean false
• Whitespace sensitivity causes errors
• Multiple ways to express same data
• Security concerns (arbitrary code execution in some parsers)

ELI5

Optimized for clarity, not bandwidth. YAML is for humans editing config files—not for machines exchanging data over networks.

When to Use

Configuration files (Kubernetes, Docker Compose, CI/CD), anywhere humans edit data directly and comments help.

TOML: Minimal Configuration

Created: 2013 (Tom Preston-Werner) Specification: toml.io File Extension: .toml

TOML (Tom’s Obvious Minimal Language) emerged as a reaction to YAML’s complexity. It’s used by Rust (Cargo.toml), Python (pyproject.toml), and others.

Technical Details

[server]
host = "localhost"
port = 8080

[server.features]
auth = true
logging = true

Key Features

• Explicit typing: Dates, times, arrays have clear syntax
• Sections: [section] and [section.subsection]
• No anchors: Intentionally simpler than YAML
• Deterministic: Same data = same representation

Strengths

• Easy to read and write
• Unambiguous parsing
• Clear error messages
• Growing ecosystem support

Weaknesses

• Less expressive than YAML
• Nested structures can be verbose
• Smaller ecosystem than JSON/YAML

ELI5

Same goal as YAML—clarity for humans, not bandwidth for machines—but with stricter rules so you make fewer mistakes.

When to Use

Configuration files where YAML’s complexity isn’t needed. Rust projects (mandatory). Python packaging (pyproject.toml).

TOON: Token-Optimized for LLMs

Created: October 2025 (toon-format organization) Specification: github.com/toon-format/toon (v3.0) File Extension: .toon Media Type: text/toon (provisional)

TOON (Token Oriented Object Notation) is the newest format in this list, designed specifically for LLM input. It’s a lossless representation of JSON that minimizes tokens.

Technical Details

TOON combines YAML-style indentation for nested objects with CSV-like tabular layouts for uniform arrays:

users[2]{name,age}:
Alice,25
Bob,30

Equivalent JSON:

{"users": [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]}

Key Features

• Header-based: Field names declared once, values follow
• 40% fewer tokens: Than equivalent JSON typically
• Lossless: Round-trips to JSON perfectly
• UTF-8 always: No encoding ambiguity

Performance

Strengths

• Significant token savings at scale
• Better context window utilization
• Lower API costs for LLM applications
• Human-readable (unlike binary formats)

Weaknesses

• New format (October 2025)
• Limited tooling compared to JSON
• Requires conversion layer for existing systems
• Not yet widely adopted

ELI5

Like having one header row for each column in a table instead of repeating the column name for every single row. You declare field names once, then just list the values.

When to Use

LLM prompts with structured data, RAG applications, anywhere token efficiency matters. Especially useful for large datasets with uniform object arrays.

Implementations

• TypeScript: Reference implementation
• Python: toons (Rust-based, fast)
• Go, Rust, .NET: Available via toon-format org

Alternatives Not in the Video

MessagePack

Created: 2008 (Sadayuki Furuhashi) Specification: msgpack.org

Binary JSON without schema. Type-prefixed values, efficient numeric encoding.

Use when: You want JSON semantics but smaller/faster.

CBOR

Created: 2013 (IETF) Specification: RFC 8949

Concise Binary Object Representation. Designed for constrained environments (IoT).

Use when: Resource-constrained devices, need a standard binary format.

Apache Avro

Created: 2009 (Apache, Doug Cutting) Specification: avro.apache.org

Schema-based, row-oriented binary format. Schema embedded or stored separately. Strong schema evolution support.

Use when: Big data pipelines (Hadoop, Kafka), schema evolution is critical.

Apache Parquet

Created: 2013 (Twitter + Cloudera) Specification: parquet.apache.org

Columnar storage format. Not for serialization—for analytics storage.

Use when: Large-scale analytics, data warehousing, Spark/Pandas workflows.

Cap’n Proto

Created: 2013 (Kenton Varda, ex-Protobuf author) Specification: capnproto.org

Zero-copy serialization. The serialized form is the in-memory form.

Use when: Extreme performance requirements, inter-process communication.

FlatBuffers

Created: 2014 (Google) Specification: google.github.io/flatbuffers

Zero-copy like Cap’n Proto but with better tooling. Used in games, mobile.

Use when: Games, mobile apps, anywhere memory allocation matters.

Quick Reference

Key Takeaways

1. No “best” format exists. Each optimizes for different constraints.

2. Text formats favor humans. JSON, YAML, TOML prioritize readability over efficiency.

3. Binary formats favor machines. Protobuf, MessagePack, CBOR prioritize compactness and speed.

4. Schema formats favor correctness. Protobuf, Avro, ASN.1 catch errors at compile time.

5. The tradeoff triangle is real. Readability, compactness, query performance—pick two.

The question isn’t “which format wins?” The question is: what problem are you solving?

Resources

• ECMA-404 JSON Specification
• RFC 8259 JSON
• JSON Lines Specification
• PostgreSQL JSONB Documentation
• Protocol Buffers Documentation
• YAML 1.2.2 Specification
• TOML v1.0.0 Specification
• RFC 8949 CBOR
• MessagePack Specification
• Apache Avro Specification

Data formats are design decisions. Choose based on your constraints, not trends.

Questions? Find me on YouTube @SoftwareWrighter.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #18

Today’s Five

1. Preference Learning

Instead of learning from fixed labels, models are trained from comparisons between outputs. This helps align model behavior with human judgments.

The approach works well when absolute quality is hard to define but relative preferences are easier to express.

Like learning to cook by asking which dish tastes better.

2. Ensembling

Ensembling combines predictions from multiple models. Different models make different errors, and combining them can improve robustness.

Common strategies include voting, averaging, and stacking models together.

Like asking several experts and averaging their opinions.

3. Why ML Is Fragile

Models rely on statistical patterns learned from data. When those patterns shift, performance can degrade quickly.

This fragility emerges because models optimize for training distributions, not arbitrary future scenarios.

Like a spell checker that works on common words but struggles with unusual ones.

4. Epoch

An epoch is one complete pass through the training dataset. Multiple epochs allow the model to refine its weights over repeated passes.

Training typically continues for many epochs until validation performance stops improving.

Like reading a textbook from beginning to end more than once.

5. Cost vs Quality Tradeoffs

Increasing model size or compute often improves performance, but also increases cost and latency. Engineers balance quality against budget and responsiveness.

Production systems often use smaller, faster models rather than the largest available.

Like choosing between a luxury car and an economy car depending on your needs.

Quick Reference

Short, accurate ML explainers. Follow for more.

AI coding agents can write code, generate images, and produce text. But what about music? When I needed background audio for explainer videos, I wanted a tool that AI agents could use directly—no music theory required.

Resource	Link
Video	midi-cli-rs Explainer
Examples	Listen to Samples
Code	midi-cli-rs

The Problem

Generating music programmatically is hard. Traditional approaches require understanding music theory, MIDI specifications, instrument mappings, and audio synthesis. That’s a lot to ask of an AI agent that just needs a 5-second intro.

I wanted something simpler: a CLI tool where an agent could say “give me 5 seconds of suspenseful music” and get a usable WAV file.

The Solution: Mood Presets

midi-cli-rs solves this with mood presets—curated musical generators that produce complete compositions from a single command:

# Generate a 5-second suspenseful intro
midi-cli-rs preset --mood suspense --duration 5 -o intro.wav

# Upbeat outro with specific key
midi-cli-rs preset -m upbeat -d 7 --key C --seed 42 -o outro.wav

Six moods are available:

Each mood generates multi-layer compositions with appropriate instruments, rhythms, and harmonies. The --seed parameter ensures reproducibility—same seed, same output. Different seeds produce meaningful variations in melody contour, rhythm patterns, and instrument choices.

Melodic Variation

The presets don’t just randomize notes—they use a contour-based variation system. Changing the seed produces melodies that follow different shapes (ascending, descending, arch, wave) while staying musically coherent. This means you can generate multiple versions of a mood and pick the one that fits best.

How It Works

The tool generates MIDI programmatically, then renders to WAV using FluidSynth:

Mood Preset → MIDI Generation → FluidSynth → WAV Output

MIDI generation uses the midly crate to create standard MIDI files. Each preset generates multiple tracks with different instruments, note patterns, and dynamics.

Audio rendering calls FluidSynth as a subprocess with a SoundFont (instrument samples). This avoids LGPL licensing complications—subprocess execution doesn’t trigger copyleft.

Note-Level Control

When presets aren’t enough, you can specify exact notes:

# Note format: PITCH:DURATION:VELOCITY[@OFFSET]
midi-cli-rs generate \
    --notes "C4:0.5:80@0,E4:0.5:80@0.5,G4:0.5:80@1,C5:1:90@1.5" \
    -i piano -t 120 -o arpeggio.wav

Or use JSON for complex multi-track arrangements:

echo '{"tempo":90,"instrument":"piano","notes":[
  {"pitch":"C4","duration":0.5,"velocity":80,"offset":0},
  {"pitch":"E4","duration":0.5,"velocity":80,"offset":0.5},
  {"pitch":"G4","duration":1,"velocity":90,"offset":1}
]}' | midi-cli-rs generate --json -o output.wav

Web UI

For interactive composition, there’s a browser-based interface:

midi-cli-rs serve  # Starts on http://127.0.0.1:3105

The Presets tab lets you adjust mood, key, duration, intensity, and tempo with immediate audio preview. Click the clock button to generate a time-based seed for unique but reproducible results.

The Melodies tab provides note-by-note composition with keyboard shortcuts:

• a-g for note pitch
• [ / ] to adjust duration
• + / - to change octave
• Tab to navigate between notes

For AI Agents

The CLI is designed for AI agent usage:

1. Simple commands: One line generates complete audio
2. Reproducible: Seed values ensure consistent output
3. Self-documenting: --help includes agent-specific instructions
4. Composable: Generate tracks separately, combine with ffmpeg

# AI agent workflow
midi-cli-rs preset -m suspense -d 5 --seed 1 -o intro.wav
midi-cli-rs preset -m upbeat -d 10 --seed 2 -o main.wav
ffmpeg -i intro.wav -i main.wav -filter_complex concat=n=2:v=0:a=1 final.wav

SoundFont Quality Matters

The quality of generated audio depends heavily on the SoundFont used. SoundFonts are collections of audio samples for each instrument—a tiny SoundFont with compressed samples will sound thin and artificial, while a larger one with high-quality recordings produces professional results.

For anything beyond quick prototypes, use a quality SoundFont. The difference is dramatic—the same MIDI file can sound like a toy keyboard or a real instrument depending on the samples.

The tool auto-detects SoundFonts in common locations (~/.soundfonts/, /opt/homebrew/share/soundfonts/, etc.), or specify one explicitly with --soundfont.

Technical Details

Built with Rust 2024 edition using permissively licensed dependencies:

FluidSynth is called as a subprocess for WAV rendering, keeping the main codebase MIT-licensed.

Try It

Listen to sample outputs, or build locally:

git clone https://github.com/softwarewrighter/midi-cli-rs.git
cd midi-cli-rs
cargo build --release
./target/release/midi-cli-rs preset -m jazz -d 5 -o jazz.wav

Requires FluidSynth for WAV output (brew install fluid-synth on macOS).

Disclaimer

You are responsible for how you use generated audio. Ensure you have the appropriate rights and permissions for any commercial or public use. This tool generates MIDI data algorithmically—how you render and distribute the final audio is your responsibility.

Be aware that algorithmic composition can inadvertently produce sequences similar to existing copyrighted works. Whether you use this tool, AI generation, or compose by hand, you must verify that your output doesn’t infringe on existing copyrights before public release or commercial use. Protect yourself legally.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #17

Today’s Five

1. Benchmark Leakage

When benchmark or test data influences training, tuning, or model selection, evaluation results become unreliable. This inflates reported performance beyond real-world capability.

Strict separation between development and evaluation data is essential for honest assessment.

Like practicing with the exact questions that will appear on the final exam.

2. Concept Drift vs Data Drift

Data drift occurs when input distributions change. Concept drift occurs when the relationship between inputs and outputs changes. Both can degrade model performance over time.

Data drift: customers buy different products. Concept drift: what “good” means has changed.

Like customers buying different products versus products changing what they mean.

3. Weight Decay

A regularization method that penalizes large weights, often implemented as L2 regularization. This encourages simpler models that generalize better.

Weight decay adds a term proportional to the squared magnitude of weights to the loss function.

Like encouraging shorter, simpler answers instead of overly complicated ones.

4. Scaling Laws

Empirical relationships showing how performance tends to improve as model size, data, or compute increase. These relationships follow predictable power-law curves.

Scaling laws help predict resource requirements for target performance levels.

Like noticing that adding horsepower often increases a car’s speed, but with diminishing returns.

5. Shadow Deployment

Running a new model in parallel with production without affecting live user decisions. The shadow model processes real traffic but its outputs are only logged, not served.

This allows safe evaluation before full deployment.

Like a new chef preparing the same dishes in the back kitchen before serving customers.

Quick Reference

Short, accurate ML explainers. Follow for more.

I first discovered ToonTalk during the Windows XP era—probably around 2003 or 2004. It was unlike anything I’d seen: a programming environment disguised as a video game where you trained robots by showing them what to do. The concept stuck with me for two decades.

Resource	Link
Video	ToonTalk in Rust
tt-rs Demo	Live Demo
tt-rs Repo	tt-rs

What is ToonTalk?

ToonTalk is a visual programming environment created by Ken Kahn in 1995. The “Toon” stands for cartoon—every abstract programming concept is mapped to a concrete, animated metaphor:

The design was influenced by games like The Legend of Zelda and Robot Odyssey—the kind of games that made you think while you played.

Programming by Demonstration

The core idea is radical: you don’t write code, you show a robot what to do.

1. Create a robot and put it in “training mode”
2. Perform actions while the robot watches (move items, compare values, etc.)
3. The robot records your actions as a program
4. Give the robot a box matching the training pattern—it executes the learned behavior

This is programming by demonstration. The robot generalizes from your example, matching patterns and applying transformations. It’s the same conceptual model as teaching a child: “Watch what I do, then you try.”

Three Generations

ToonTalk has existed in three forms:

The original was a full 3D world—cities, houses, helicopters, even bombs for debugging. Ken Kahn later created ToonTalk Reborn, a simplified JavaScript version that runs in browsers.

Why I Built tt-rs

When I rediscovered ToonTalk Reborn a few years ago, I wanted to experiment with the concepts myself. But diving into a large jQuery codebase wasn’t appealing. So I did what any reasonable person would do: I vibe coded my own version in Rust.

tt-rs is a modern reimplementation using:

• Rust for core logic
• WebAssembly for browser execution
• Yew for reactive UI
• SVG/CSS for graphics and animations

It’s not a port—it’s a fresh implementation inspired by the same ideas. Building it myself lets me understand the concepts deeply and experiment with variations.

Three Learning Levels

The demo introduces concepts progressively through three levels:

Level one covers the fundamentals: numbers with arithmetic, boxes as containers, scales for comparison, and tools for copying and removing. Level two adds asynchronous messaging—birds carry items to their paired nests. Level three brings sensors that produce values and robots that automate actions.

Current Features

The live demo includes:

Widgets:

• Numbers: Rational arithmetic with +, -, *, / operators
• Boxes: Configurable containers with 0-9 holes (resize with keyboard)
• Text: Basic text display
• Scales: Visual comparison that tips when values differ
• Robot: Training mode, action recording, execution
• Bird/Nest: Message passing with pairing and delivery
• Sensors: Time (milliseconds) and random number generation

Tools:

• Wand: Copy any widget
• Vacuum: Remove widgets
• Magnifier: Inspect nest message queues and robot actions

Interactions:

• Drag-and-drop with visual feedback
• Box joining (drop box on edge of another)
• Box splitting (drop box on a number)
• Contextual help panel with level-specific content
• Puzzle system with animated “Show Me” demos

Robot Training

The core feature is programming by demonstration:

1. Click robot to enter training mode (yellow glow indicates “I’m watching”)
2. Perform actions while the robot records (arithmetic, copy, remove, move to box)
3. Click robot again to stop training
4. Click robot to replay—it executes the recorded sequence

The tutorials demonstrate this workflow step by step. In the “Train Robot” tutorial, you teach a robot to move a number into a box. In “Robot Sensors,” you train a robot to generate random numbers, apply modulo, and send results to a nest via a bird.

Interactive Tutorials

Each tutorial has two parts:

1. Show Me: Watch an animated demonstration where a cursor walks through the solution
2. Practice: Try it yourself with the same widgets

The tutorials cover:

• Fill a box with numbers
• Add numbers together
• Copy widgets with the wand
• Send messages with birds and nests
• Train your first robot
• Combine robots with sensors

What’s Next

The immediate priorities:

1. Pattern matching - Robot generalizes from specific values to “any number”
2. Watched execution - See robot work step-by-step with animated cursor
3. Persistence - Save and load workspaces

Long term, I’d like to add the 3D elements from the original—the cities, the houses, the helicopter view. But that’s a much larger project.

The Enduring Appeal

What makes ToonTalk fascinating isn’t just the visual metaphors—it’s the computational model. Under the hood, ToonTalk implements concurrent constraint logic programming. The robots are essentially guarded Horn clauses. The birds and nests implement the actor model.

Heavy concepts, but you don’t need to know any of that to use it. You just train robots by example. The abstraction is complete.

That’s why it stuck with me for twenty years. Good abstractions are rare. When you find one, it’s worth understanding deeply.

Some ideas are worth rediscovering. ToonTalk is one of them.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #16

Today’s Five

1. Train / Validation / Test Split

Data is divided into training, validation, and test sets. Training learns patterns, validation tunes hyperparameters, test evaluates final performance.

Never use test data for any decisions during development—it should only be touched once.

Like practicing on homework, checking with practice tests, then taking the real exam.

2. Overconfidence

Models can assign very high probabilities to incorrect predictions. This is often related to poor calibration and can be dangerous in high-stakes applications.

Temperature scaling and other calibration methods can help align confidence with accuracy.

Like a student who is absolutely certain of a wrong answer.

3. Batch Normalization

Normalizes layer activations during training to improve stability and convergence. Each mini-batch’s activations are normalized to have zero mean and unit variance.

This reduces internal covariate shift and often allows higher learning rates.

Like keeping everyone on a similar pace during training so no one runs too far ahead.

4. Optimization vs Generalization

Training loss can decrease while test performance does not improve. Good optimization does not guarantee good generalization.

A model can perfectly fit training data while failing on new examples—this is overfitting.

Like memorizing last year’s exam instead of understanding the subject.

5. A/B Testing Models

Comparing two model versions using controlled live traffic experiments. Users are randomly assigned to see predictions from model A or model B.

Statistical analysis determines which model performs better on real-world metrics.

Like taste-testing two recipes with real customers to see which works better.

Quick Reference

Short, accurate ML explainers. Follow for more.

In Part 1, a tiny 135M model achieved 75% accuracy on multi-hop reasoning. This time we scale up to 360M—and discover that RSFT on easy examples makes performance worse.

Scaling Up: SmolLM-360M

Part 1 used the 135M model. For better reasoning traces and demo quality, we trained the 360M variant:

The 360M model produces more coherent traces and is used by the live inference demo.

The Distribution Trap

Here’s what happened when we trained RSFT on the “easy” training data:

RSFT on easy examples performed worse than the SFT baseline.

Why?

The training examples (1-3 hops) don’t match the evaluation distribution (4-5 hops). The model learns shortcuts that work on easy problems but fail on hard ones.

The rejection sampling “winners” from easy examples teach strategies that don’t generalize.

The Key Finding

Rejection sampling must match your target distribution.

This is counterintuitive. You might expect that training on more examples (even easy ones) would help. Instead:

• Easy winners use shortcuts (fewer reasoning steps)
• Hard eval requires full chain reasoning
• Model learns the wrong patterns

The fix: train RSFT on eval.jsonl (hard examples), not train.jsonl (easy examples).

Demo Improvements

The demo now includes four interactive tabs:

Try It: Live Inference

Ask DevOps troubleshooting questions and watch the model reason:

Question: What causes TLSHandshakeError?

TRACE: TLSHandshakeError is caused by ClockSkew,
and ClockSkew leads to CertificateExpired,
and CertificateExpired is fixed by RenewCert...
ANSWER: B

The knowledge graph scores the reasoning path during training, but at inference the model reasons independently.

Cross-Platform Support

The pipeline now runs on both platforms:

Unsloth provides 2x faster training with 60% less memory on NVIDIA GPUs.

Current Status

Next Steps

The corrected RSFT training:

python3 -m core.rsft \
  --examples data/eval.jsonl \  # Hard examples!
  --kg data/kg.json \
  --sft-adapter data/runs/run_360m/models/sft \
  --output data/runs/run_360m/models/rsft_eval \
  --model HuggingFaceTB/SmolLM-360M-Instruct \
  --k-samples 8 \
  --max-examples 50

Lessons Learned

1. Distribution Matching is Non-Negotiable

This isn’t a minor optimization—it’s the difference between 27% and 75% accuracy. Wrong distribution = wrong winners = wrong model.

2. Easy Examples Can Hurt

More training data isn’t always better. Easy examples teach shortcuts that fail on hard problems.

3. Verify Your Pipeline

We trained a full RSFT model before realizing the distribution mismatch. Always check that training data matches eval distribution.

4. The Fix is Simple

Once identified, the fix is one flag change: --examples data/eval.jsonl instead of train.jsonl.

Resources

• Repository: multi-hop-reasoning
• Live Demo
• Part 1: Training Wheels for Small LLMs
• Paper: Knowledge Graph-Guided RAG
• Training Status

Training distribution matters. Easy examples teach easy shortcuts.

In Part 1, naive LoRA fine-tuning caused catastrophic forgetting. Now we’re implementing the Share algorithm properly—and we’re about 60% of the way to verifying the paper’s claims.

Paper Claims vs Implementation Status

We’re systematically verifying the claims from the Share and UWSH papers:

Overall: ~60% complete. Infrastructure is solid. Routing tested. Sequential learning remains.

What We Built

The full Share algorithm implementation:

• Phase 1: SVD-based subspace extraction from 51 LoRA adapters (60% variance threshold)
• Phase 2: Coefficient-only training with frozen basis (83K params vs 1.6M full LoRA)
• Phase 3: Basis merging and updates
• Routing: Error pattern classification for coefficient selection

Bug Fixes That Unlocked Progress

Two critical bugs blocked proper Phase 2 training:

Bug 1: Zero-Gradient Saddle Point

Both coefficient matrices initialized to zero:

eps_beta = 0, eps_alpha = 0
→ delta_W = 0 @ 0 = 0
→ zero gradients, no learning

Fix: Dual small-random initialization.

Bug 2: Half-Parameter Training

LoRA-style initialization only trained one coefficient set:

Before: 112/224 parameters getting gradients
After:  224/224 parameters getting gradients

Fix: Both coefficient matrices need random initialization.

Experiment 1b: Routing Works

With gradient-trained v4 coefficients and proper routing:

Result handling improved 40% → 50%. Zero regressions. This is the first positive transfer from Share coefficients.

The Forgetting Heatmap

We applied each coefficient individually to all 30 koans:

Koan       BL  mut_bc dbl_mt ret_lr mis_cl mis_hs mis_or opt_ok res_me ROUTED
bc_001-009 P   P      P      P      P      P      P      P      P      P
bc_003,5,10.   .      .      .      .      .      .      .      .      .
rh_002     .   .     +GAIN   .      .     +GAIN  +GAIN  +GAIN  +GAIN  +GAIN
rh_008     P  -LOST  -LOST  -LOST  -LOST  -LOST  -LOST  -LOST  -LOST   P
tb_005     P   P      P      P      P     -LOST   P      P      P      P

Key finding: rh_008 regresses under every coefficient applied globally. But routing saves it by falling back to the base model when no pattern matches.

This is exactly what the Share paper predicts: task-specific coefficients improve targeted patterns without interfering with unrelated ones.

What the Papers Claim vs What We’ve Verified

Verified

1. Shared basis via SVD — We extract principal components from 51 adapters. Works.

2. 76x parameter reduction — 83K coefficient parameters vs 1.6M full LoRA. Verified.

3. Routing prevents forgetting — Zero regressions with routed inference. The fragile rh_008 koan survives because it falls back to base model.

4. Positive transfer possible — Result handling improved 40% → 50% with routed coefficients.

Not Yet Verified

1. Sequential learning — The core continual learning claim. Train task 1 → eval → train task 2 → eval (verify task 1 still passes). This is next.

2. UWSH subspace stability — Do different adapter subsets converge to similar subspaces? Grassmann distance measurement needed.

Next Experiments

The Architecture

Day:   Agent attempts to fix Rust errors
       ↓
       Successes and failures logged
       ↓
Night: Train coefficients (frozen basis)
       ↓
       83K params per task
       ↓
Eval:  Route to appropriate coefficients
       ↓
       Pattern-matched inference
       ↓
(repeat)

The key insight: train small, route smart. The shared basis captures common structure. Per-task coefficients specialize without interference.

Resources

• sleepy-coder Repository
• Part 1: When Fine-Tuning Fails
• Paper Checklists
• Share Paper (arXiv:2602.06043)
• UWSH Paper (arXiv:2512.05117)

60% of the way to verifying the papers. Sequential learning is next.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #15

Today’s Five

1. Perplexity

A metric for language models that reflects how well the model predicts the next token. Lower perplexity means better predictive performance.

Perplexity is the exponentiated average negative log-likelihood per token.

Like a test where lower scores mean you found the answers easier to guess.

2. Catastrophic Forgetting

When training on new tasks causes a model to lose performance on previously learned tasks. This is a key challenge in continual learning.

Techniques like elastic weight consolidation help preserve important weights.

Like learning a new phone number and forgetting the old one.

3. Weight Initialization

The starting values of model weights influence how well training progresses. Poor initialization can cause vanishing or exploding gradients.

Xavier and He initialization are common strategies for setting initial weights appropriately.

Like starting a race from a good position instead of stuck in a ditch.

4. Curse of Dimensionality

In high-dimensional spaces, data becomes sparse and distances behave differently, making learning harder. Points that seem close in low dimensions can be far apart in high dimensions.

Feature selection and dimensionality reduction help mitigate this effect.

Like searching for a friend in a city versus across the entire universe.

5. Monitoring & Drift Detection

Continuously tracking model performance and detecting shifts in input data distributions. Production models can degrade silently without proper monitoring.

Automated alerts help catch problems before they affect users.

Like a weather station alerting you when conditions change.

Quick Reference

Short, accurate ML explainers. Follow for more.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #14

Today’s Five

1. ROC / AUC

ROC curves plot true positive rate against false positive rate across all classification thresholds. AUC (Area Under the Curve) summarizes overall ranking performance in a single number.

AUC of 0.5 means random guessing; 1.0 means perfect ranking.

Like judging a student by considering every possible passing grade cutoff.

2. Spurious Correlations

Coincidental patterns in training data that don’t reflect true relationships. Models that rely on them can fail when the coincidence disappears.

Dataset curation and diverse evaluation help detect spurious features.

Like assuming umbrellas cause rain because you always see them together.

3. Gradient Clipping

Limiting the size of gradients during backpropagation. This helps prevent exploding gradients and unstable training, especially in recurrent networks.

Clipping can be by value or by global norm.

Like putting a speed limit on a car so it doesn’t lose control.

4. Loss Landscapes

How model error changes across different parameter settings. Training is like navigating this surface toward regions of lower loss.

Flat minima may generalize better than sharp ones.

Like hiking through mountains searching for the lowest valley, feeling the slope beneath your feet.

5. Cold Start Problems

Difficulty predicting for new users or items with no history. Without prior data, personalization becomes difficult.

Solutions include content-based features, popularity fallbacks, or asking initial questions.

Like a librarian trying to recommend books to someone who just walked in.

Quick Reference

Short, accurate ML explainers. Follow for more.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #13

Today’s Five

1. Calibration

How well a model’s predicted probabilities match real-world outcomes. If a model predicts 70% confidence many times, it should be correct about 70% of those cases.

Well-calibrated models enable better decision-making under uncertainty.

Like a weather forecast that predicts rain 30% of the time and is right about 30% of those forecasts.

2. Shortcut Learning

When models rely on superficial patterns instead of meaningful features. For example, identifying cows by detecting grass and failing when cows appear indoors.

Shortcuts can inflate benchmark scores while masking poor real-world performance.

Like passing a test by memorizing answer positions instead of learning the material.

3. Early Stopping

Training is stopped when validation performance stops improving. This helps prevent overfitting by halting before the model memorizes training data.

Patience hyperparameters control how long to wait before stopping.

Like knowing when to stop practicing before you start reinforcing mistakes.

4. Universal Approximation

The theorem stating that neural networks can approximate any continuous function, given enough capacity. In practice, finding the right weights through optimization is the challenge.

The theorem guarantees existence, not learnability.

Like having enough Lego blocks to build almost any shape—assembly is still hard.

5. Checkpointing

Saving the model’s state during training. This allows recovery from interruptions and comparison across training stages.

Checkpoints also enable selecting the best model rather than just the final one.

Like saving your game progress so you can reload if something goes wrong.

Quick Reference

Short, accurate ML explainers. Follow for more.

5 machine learning concepts. Under 30 seconds each.

Resource	Link
Papers	Links in References section
Video	Five ML Concepts #12

Today’s Five

1. Precision vs Recall

Precision measures how often positive predictions are correct. Recall measures how many actual positives are successfully found. Improving one often reduces the other.

The tradeoff depends on your application: spam filters favor precision, medical screening favors recall.

Like a search party: you can find everyone but raise false alarms, or be very certain and miss some people.

2. OOD Inputs (Out-of-Distribution)

Data that differs significantly from what the model saw during training. Models may fail silently or produce confident but wrong answers.

Detecting OOD inputs is an active research area for safer AI deployment.

Like asking a chef trained only in Italian food to make sushi.

3. Batch Size

The number of training examples processed before updating model weights. Larger batches can be more efficient computationally, but may generalize worse.

Finding the right batch size involves balancing speed, memory, and model quality.

Like grading tests one at a time or waiting to grade a full stack.

4. Inductive Bias

The assumptions built into a model that guide how it learns from data. Without inductive bias, models cannot generalize beyond training examples.

CNNs assume spatial locality; transformers assume tokens can attend to any position.

Like expecting nearby houses to have similar prices before looking at the data.

5. Latency vs Throughput

Latency is how long a single request takes. Throughput is how many requests can be handled per second. Optimizing one often comes at the expense of the other.

Batching improves throughput but increases latency for individual requests.

Like a restaurant serving one table quickly or many tables at once.

Quick Reference

Short, accurate ML explainers. Follow for more.

I wanted a neural network implementation where every step is visible—no framework magic hiding the math. Something I could use to teach the fundamentals, with a CLI for quick experiments and a web UI for visual demonstrations. Claude Code built it.

This is Personal Software for education: a complete neural network training platform with multiple interfaces, all from a single Rust codebase.

Resource	Link
Repo	neural-net-rs
Video	Neural-Net-RS Explainer

Why Build Your Own Neural Network?

Frameworks like PyTorch and TensorFlow are production-ready, but they hide the fundamentals. When teaching or learning, you want to see:

• How weights and biases actually change during training
• Why XOR needs a hidden layer when AND doesn’t
• What backpropagation really computes

Neural-Net-RS exposes all of this. No autograd magic—every gradient is computed explicitly. No tensor abstractions—just matrices with clear row-major storage.

What Got Built

A modular Rust workspace with multiple interfaces to the same core:

neural-net-rs/
├── matrix/              # Linear algebra foundation
├── neural-network/      # Core ML implementation
├── neural-net-cli/      # Command-line interface
├── neural-net-server/   # REST API with SSE streaming
└── neural-net-wasm/     # WebAssembly for browser

One codebase, three ways to interact:

• CLI: Train from terminal with progress bars
• Web UI: Visual training with real-time loss charts
• WASM: Run entirely in browser, no server needed

The Classic Problems

The platform includes 8 built-in examples that teach ML concepts progressively:

The XOR Problem

XOR is the canonical neural network problem. AND and OR are linearly separable—a single line can divide the outputs. XOR isn’t. You need a hidden layer.

AND: (0,0)→0, (0,1)→0, (1,0)→0, (1,1)→1  ← One line separates
XOR: (0,0)→0, (0,1)→1, (1,0)→1, (1,1)→0  ← No line works

Watch XOR training and you see why neural networks are powerful: they learn to create intermediate representations that make non-linear problems separable.

Implementation Details

Feed-Forward with Backpropagation

pub struct Network {
    pub layers: Vec<usize>,      // [input, hidden..., output]
    pub weights: Vec<Matrix>,    // Learned connections
    pub biases: Vec<Matrix>,     // Per-neuron offsets
    pub learning_rate: f64,      // Training step size
}

Forward pass: Each layer computes activation(weights × input + bias)

Backward pass: Gradients flow backward using the chain rule, updating weights to reduce error.

The sigmoid activation function maps any input to (0, 1):