Will Ware wware

How this stuff works

This is a Guile Scheme extension written in Rust instead of C. The longer-term goal is a Rust implementation of the Rete algorithm callable from Guile.

cargo build --release
sudo mkdir -p /usr/share/guile/site/3.0/

Machine readable scientific literature

First a bit of background. Around 2010 I had the idea that computers could do science, not simply run lab equipment but iterate the scientific method on their own. I was thinking about how to make that happen, and within a month I stumbled across a brilliant piece of work done by Ross King, then at Aberystwyth University. He built a robot that could make observations, reason about hypotheses and the predictions implied by those hypotheses, and design and perform experiments.

Prompt:

The inverters in the upper left are a square wave oscillator (around 100 kHz), used to sense capacitive connectivity between X wires and Y wires. The comparators are TLV3404. Inputs A,B,C,D,E,F and outputs G,H,I are connected to an Adafruit Grand Central M4 controller board. Inputs D,E,F select one of eight options in the 4051 analog multiplexer, just prior to the 3-bit flash ADC that generates G,H,I.

Show me Rust code that would run on the Grand Central board to perform a keyboard scan.

Response:

I'll help you create Rust code for scanning this capacitive keyboard matrix. From the schematic, we're dealing with:

Vibe Coding Meets Test-Driven Development

The Convergence of Approaches

Vibe coding - the practice of writing code that "feels right" and follows natural patterns - might seem at odds with Test-Driven Development (TDD)'s rigorous, test-first methodology. However, when combined thoughtfully, these approaches can create exceptionally robust and maintainable code.

A Concrete Example: WebAuthn Implementation

The WebAuthn implementation showcased in this repository demonstrates how these methodologies can work together effectively:

Writing good Python schemas

Good Python schemas specify interfaces and protocols without specifying implementation. They leverage type-hinting and linting tools like pylint and mypy.

Three Primary Goals

Early Design Documentation: Define comprehensive interface specifications before writing implementation code using Python's abc

Graph-RAG with Neo4j and MCP

A hands-on introduction to graph databases using Neo4j's classic movie dataset, accessible through both the Neo4j web interface and AI-powered natural language queries via Cursor IDE.

What Are Graph Databases?

Imagine you're organizing information about movies and actors. A traditional database stores these as separate tables:

Movies Table: Actors Table: Acted_In Table:

GPU-Accelerated AI Development with Lambda Labs

Like many developers, you may get tired of paying subscription fees to use online LLMs, especially when you hit usage limits or get throttled. Running models locally with Ollama is great, but without a GPU, performance suffers. Cloud GPU instances from services like Lambda Labs, RunPod, and others offer a cost-effective middle ground.

This guide focuses on Lambda Labs because of their straightforward pricing, good GPU selection, and excellent performance. The setup takes about 10-15 minutes and provides enormous speedups over CPU-only inference—typically 10-100x faster depending on the workload.

https://claude.ai/chat/9b9c7509-3108-4cb0-a940-5a8fde8a9e4c

Great work on the pipeline refactoring! This is a solid Unix-style architecture with clean separation of concerns:

What you've built:

✅ Modular stages - Each pipeline script is independent and can be run separately
✅ Interface-based design - Storage, parsers, and embeddings all use ABC interfaces
✅ Swappable backends - SQLite for dev/testing, PostgreSQL+pgvector for production
✅ Clean data flow - Each stage reads/writes through well-defined interfaces
✅ Comprehensive docs - README and TESTING guide are clear and helpful

	docker-compose.yml
	Dockerfile*
	models/
	ollama_data/
	.pytest_cache/
	__pycache__/

	.gradle/
	target/
	# btw the java files go in src/main/java/com/example/*.java