Joel Holmes

About

Mon, 01 Jan 0001 00:00:00 +0000

Grey Seal is a Retrieval-Augmented Generation (RAG) chat backend — a service for having grounded conversations with a knowledge base I actually own and control.

Why I Built It

I wanted to be able to ask questions across the documents, links, and notes stored in my self-hosted platform and get answers that cite real sources rather than hallucinated ones. Commercial RAG products exist, but they require sending your data to a third party. Grey Seal runs entirely on my own infrastructure: the LLM runs locally via Ollama, vector search is handled by Shrike, and the data never leaves the network.

About

Mon, 01 Jan 0001 00:00:00 +0000

Lynx is a personal link and feed management service — a place to save, organise, and enrich URLs and RSS/Atom feeds without handing that data to a commercial read-later or bookmarking platform.

Why I Built It

I wanted to own my reading list. Existing bookmarking tools work well enough, but they’re third-party services with their own retention and privacy trade-offs. Lynx runs on my own infrastructure and stores everything in a PostgreSQL database I control.

About

Mon, 01 Jan 0001 00:00:00 +0000

Magpie is a resource tagging and cataloguing service — the central hub that ties together the other services in my self-hosted platform by receiving resource events, persisting their metadata, and fanning them out to downstream consumers.

Why I Built It

As I added more services (Lynx for links, Owl for books and papers, Weevil for reading data) each one needed to notify the rest of the platform that a new thing existed. Rather than wiring every producer directly to every consumer, I built Magpie as a single intake point: producers publish one event to Magpie, and Magpie re-publishes it on the shared Kafka bus for whatever downstream services care.

About

Mon, 01 Jan 0001 00:00:00 +0000

Owl is a personal digital library service — a place to store and manage PDF/EPUB books and academic papers without depending on a third-party platform.

Why I Built It

I wanted a single place to keep my reading material that I actually control. Commercial alternatives for books are fine, but for academic papers the existing options are either siloed into specific platforms or require manual bookkeeping across folders and browser tabs. Owl runs on my own infrastructure and stores everything in a database and object storage bucket I own.

About

Mon, 01 Jan 0001 00:00:00 +0000

Shrike is a unified search and retrieval service — a single endpoint any service in my platform can query instead of each one maintaining its own search index.

Why I Built It

As the number of services grew, so did the need to search across them. I didn’t want every service managing its own embeddings and full-text indexes independently. Shrike sits downstream of the Kafka bus, ingests events from all producers, and builds a shared dual-backend index: Qdrant for semantic (vector) search and PostgreSQL for keyword full-text search. Any service that needs search talks to Shrike rather than its own database.

About

Mon, 01 Jan 0001 00:00:00 +0000

Weevil is a personal book tracking service — a place to keep a record of books I’ve read, want to read, or am currently reading, without depending on a third-party platform like Goodreads or Storygraph.

Why I Built It

I wanted full ownership of my reading data. Existing platforms are convenient but come with trade-offs: lock-in, privacy concerns, and the ever-present risk that a service you rely on changes or disappears. Weevil runs on my own infrastructure, stores everything in a database I control, and exposes it through an API I wrote.

EasyPost

Mon, 01 Jan 0001 00:00:00 +0000

Building distributed systems for USPS-compliant label generation, transaction processing, and carrier integration at scale.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Grey Seal within joel.holmes.haus Person(admin, "Admin", "Manages conversations and resources; chats with the assistant") Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA") System(greyseal, "Grey Seal", "RAG-powered conversation and resource management service") System(shrike, "Shrike", "Search — provides hybrid semantic/keyword context retrieval") System(magpie, "Magpie", "Resource hub — receives ingested resources from Grey Seal") } SystemDb(postgres, "PostgreSQL", "Conversations, messages, roles, resources") SystemDb(redis, "Redis", "Per-conversation resource snippet cache (24 h TTL)") System_Ext(ollama, "Ollama", "Local LLM (deepseek-r1) — streaming chat completions") SystemQueue(kafka, "Kafka", "greyseal.v1.Resource (ingest queue) · shrike.v1.TextExtractedEvent") Rel(admin, ui, "Uses") Rel(ui, greyseal, "ConnectRPC") Rel(greyseal, postgres, "Reads / writes") Rel(greyseal, redis, "Resource snippet cache") Rel(greyseal, ollama, "Streaming LLM chat") Rel(greyseal, shrike, "ConnectRPC hybrid search for context") Rel(greyseal, kafka, "Publishes greyseal.v1.Resource") Rel(kafka, greyseal, "async ingest queue") Rel(kafka, magpie, "greyseal.v1.Resource")

Container Diagram

C4Container title Grey Seal — Internal Containers Boundary(greyseal, "Grey Seal") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "ConversationService · ResourceService · RoleService") Container(worker, "cmd/worker", "Go / Kafka", "Async content fetch — scrapes websites/PDFs, publishes TextExtractedEvent to Shrike") Container(convSvc, "conversation.Service", "Go", "Chat (RAG pipeline) · CRUD · SubmitFeedback · summarisation") Container(resourceSvc, "resource.Service", "Go", "Ingest · CRUD — triggers async indexing via KafkaIndexer") Container(roleSvc, "role.Service", "Go", "CRUD for system prompt roles") Container(cache, "RedisResourceCache", "Go / Redis", "Per-conversation snippet cache keyed greyseal:conv:{uuid}:resources") ContainerDb(convRepo, "ConversationRepo + MessageRepo", "PostgreSQL / squirrel", "conversations · messages tables") ContainerDb(resourceRepo, "ResourceRepo", "PostgreSQL / squirrel", "resources table") } SystemDb(postgres, "PostgreSQL", "") SystemDb(redis, "Redis", "") System_Ext(ollama, "Ollama", "POST /api/chat stream") System_Ext(shrike, "Shrike", "ConnectRPC SearchService") SystemQueue(kafka, "Kafka", "") Rel(api, convSvc, "Chat · CRUD") Rel(api, resourceSvc, "Ingest · CRUD") Rel(api, roleSvc, "CRUD") Rel(convSvc, cache, "Cache-first context lookup") Rel(convSvc, shrike, "Hybrid search with EntityUUIDs filter") Rel(convSvc, ollama, "Streaming completion") Rel(convSvc, convRepo, "Persist messages + summary") Rel(resourceSvc, resourceRepo, "CRUD") Rel(resourceSvc, kafka, "Publishes TextExtractedEvent or greyseal.v1.Resource") Rel(kafka, worker, "greyseal.v1.Resource") Rel(worker, kafka, "Publishes shrike.v1.TextExtractedEvent") Rel(convRepo, postgres, "SQL") Rel(resourceRepo, postgres, "SQL") Rel(cache, redis, "GET / SET")

Overview

grey-seal is a single-binary Go service (cmd/api) that exposes a Connect-RPC API over HTTP/2 (h2c). It uses a layered architecture: a thin gRPC/Connect handler layer delegates to domain service interfaces, which are backed by PostgreSQL repositories. LLM inference is delegated to a local Ollama instance; semantic search is delegated to the external shrike service. Resources are ingested asynchronously via Redpanda/Kafka: the API enqueues events that the worker process consumes to fetch content and forward it to shrike for chunking, embedding, and vector indexing.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Lynx within joel.holmes.haus Person(admin, "Admin", "Uses the joel.holmes.haus UI to manage feeds and websites") Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA") System(lynx, "Lynx", "Web feed and website archiving service") System(magpie, "Magpie", "Central resource index — receives website resources from Lynx") System(shrike, "Shrike", "Search — indexes enriched website text from Lynx") } SystemDb(postgres, "PostgreSQL", "Feeds, websites, and website metadata") SystemDb(minio, "MinIO / S3", "Archived HTML and readable text blobs") SystemQueue(kafka, "Kafka", "magpie.v1.Resource · shrike.v1.TextExtractedEvent") Rel(admin, ui, "Uses") Rel(ui, lynx, "ConnectRPC") Rel(lynx, postgres, "Reads / writes") Rel(lynx, minio, "Stores archived content") Rel(lynx, kafka, "Publishes resource events") Rel(kafka, magpie, "magpie.v1.Resource") Rel(kafka, shrike, "TextExtractedEvent")

Container Diagram

C4Container title Lynx — Internal Containers Boundary(lynx, "Lynx") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "FeedService · WebsiteService · Enricher goroutine") Container(worker, "cmd/worker", "Go / Kafka", "FeedConsumer · WebsiteConsumer · Enricher pipeline goroutine") Container(ui, "cmd/ui", "Go-app WASM :8000", "Browser SPA — calls cmd/api via ConnectRPC HTTP client") Container(feedSvc, "feed.Service", "Go", "CRUD for feeds") Container(websiteSvc, "website.Service", "Go", "Create (publishes Kafka event) · CRUD") Container(enricher, "enrichment.Enricher", "Go / goroutine", "7-step pipeline: fetch → metadata → archive HTML → readable → archive → persist → magpie") ContainerDb(feedRepo, "FeedRepo", "PostgreSQL / squirrel", "feeds table") ContainerDb(websiteRepo, "WebsiteRepo + MetadataRepo", "PostgreSQL / squirrel", "websites · website_metadata tables") } SystemDb(postgres, "PostgreSQL", "") SystemDb(minio, "MinIO / S3", "websites/{uuid}/original.html · readable.txt") SystemQueue(kafka, "Kafka", "") Rel(api, feedSvc, "delegates") Rel(api, websiteSvc, "delegates") Rel(api, enricher, "Enqueue()") Rel(worker, feedSvc, "FeedConsumer") Rel(worker, websiteSvc, "WebsiteConsumer") Rel(worker, enricher, "Enqueue()") Rel(feedSvc, feedRepo, "CRUD") Rel(websiteSvc, websiteRepo, "CRUD") Rel(websiteSvc, kafka, "Publish magpie.v1.Resource") Rel(enricher, websiteRepo, "UpdateNameIfBlank · UpsertMetadata") Rel(enricher, minio, "PutObject") Rel(enricher, kafka, "TextExtractedEvent") Rel(feedRepo, postgres, "SQL") Rel(websiteRepo, postgres, "SQL")

Overview

Lynx is structured as a multi-binary Go monorepo. Three runnable binaries share business logic through the lib/ package tree.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Magpie within joel.holmes.haus Person(admin, "Admin", "Manages resources, tags, and labels via the UI") Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA") System(magpie, "Magpie", "Central resource index — stores and fans out resource metadata") System(lynx, "Lynx", "Web archiving — publishes website resources") System(owl, "Owl", "Library — publishes book and paper resources") System(greyseal, "Grey Seal", "RAG service — consumes resources for conversation context") System(shrike, "Shrike", "Search — receives resource events for keyword indexing") } SystemDb(postgres, "PostgreSQL", "Resources, tags, labels, resource_tags, resource_labels") SystemQueue(kafka, "Kafka", "magpie.v1.Resource (inbound + outbound) · greyseal.v1.Resource") Rel(admin, ui, "Uses") Rel(ui, magpie, "ConnectRPC") Rel(lynx, magpie, "Publishes magpie.v1.Resource") Rel(owl, magpie, "Publishes magpie.v1.Resource") Rel(magpie, postgres, "Reads / writes") Rel(kafka, magpie, "inbound magpie.v1.Resource") Rel(magpie, kafka, "outbound greyseal.v1.Resource") Rel(kafka, greyseal, "greyseal.v1.Resource") Rel(kafka, shrike, "magpie.v1.Resource")

Container Diagram

C4Container title Magpie — Internal Containers Boundary(magpie, "Magpie") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "5 domain handlers: Resource · Tag · Label · ResourceTag · ResourceLabel") Container(worker, "cmd/worker", "Go / Kafka", "5 domain consumers; ResourceConsumer also republishes to grey-seal topic") Container(ui, "cmd/ui", "Go-app WASM :8000", "Browser SPA — resource list, tag/label management") Container(resourceSvc, "resource.Service", "Go", "Create · List · Get · Delete") Container(tagSvc, "tag.Service", "Go", "CRUD for tags") Container(labelSvc, "label.Service", "Go", "CRUD for labels") Container(rtSvc, "resource_tag.Service", "Go", "Manage tag associations") Container(rlSvc, "resource_label.Service", "Go", "Manage label associations") ContainerDb(resourceRepo, "ResourceRepo", "PostgreSQL / squirrel", "resources table (ON CONFLICT uuid DO NOTHING)") ContainerDb(tagRepo, "TagRepo + LabelRepo + join repos", "PostgreSQL / squirrel", "tags · labels · resource_tags · resource_labels") } SystemDb(postgres, "PostgreSQL", "") SystemQueue(kafka, "Kafka", "consumer group app-1") Rel(api, resourceSvc, "delegates · publishes Kafka event on Create") Rel(api, tagSvc, "delegates") Rel(api, labelSvc, "delegates") Rel(api, rtSvc, "delegates") Rel(api, rlSvc, "delegates") Rel(kafka, worker, "magpie.v1.Resource") Rel(worker, resourceSvc, "Upsert resource") Rel(worker, kafka, "Publishes greyseal.v1.Resource") Rel(resourceSvc, resourceRepo, "CRUD") Rel(tagSvc, tagRepo, "CRUD") Rel(resourceRepo, postgres, "SQL") Rel(tagRepo, postgres, "SQL")

System context

Magpie sits at the centre of a wider knowledge-management ecosystem. Upstream producers (e.g. Owl, Lynx, or direct API callers) submit resources; Magpie stores them and fans events out to downstream consumers including grey-seal (RAG/vector DB), shrike (search index), and others.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Owl within joel.holmes.haus Person(admin, "Admin", "Manages personal library of books and academic papers") Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA") System(owl, "Owl", "Personal digital library — books and academic papers") System(magpie, "Magpie", "Resource hub — receives book and paper resources from Owl") System(shrike, "Shrike", "Search — indexes paper/book text via TextExtractedEvent") } SystemDb(postgres, "PostgreSQL", "Books, papers, book metadata") SystemDb(minio, "MinIO / S3", "PDF and book file blobs") SystemQueue(kafka, "Kafka", "owl.v1.Paper · owl.v1.Book · magpie.v1.Resource · shrike.v1.TextExtractedEvent") System_Ext(arxiv, "arXiv / CrossRef", "Academic paper metadata APIs") System_Ext(googlebooks, "Google Books / Open Library", "Book metadata APIs (enrichment)") Rel(admin, ui, "Uses") Rel(ui, owl, "ConnectRPC") Rel(owl, postgres, "Reads / writes") Rel(owl, minio, "Stores PDFs and book files") Rel(owl, kafka, "Publishes paper and book events") Rel(owl, arxiv, "Resolves DOI / arXiv metadata") Rel(owl, googlebooks, "Enriches book metadata") Rel(kafka, magpie, "magpie.v1.Resource") Rel(kafka, shrike, "TextExtractedEvent")

Container Diagram

C4Container title Owl — Internal Containers Boundary(owl, "Owl") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "BookService · PaperService · in-process Ingester goroutine") Container(worker, "cmd/worker", "Go / Kafka", "BookConsumer · PaperConsumer · Ingester pipeline · BookIngester pipeline") Container(bookSvc, "book.Service", "Go", "CRUD for books") Container(paperSvc, "paper.Service", "Go", "CRUD for papers · IngestPaperByURL · GetIngestionStatus") Container(ingester, "ingestion.Ingester", "Go / goroutine", "7-step paper pipeline: resolve → download → metadata → dedup → upload → persist → magpie") Container(bookIngester, "ingestion.BookIngester", "Go / goroutine", "4-step book pipeline: download → dedup → upload → persist") Container(metaClient, "metadata.CompositeClient", "Go / HTTP", "ArxivClient + CrossRefClient for DOI/arXiv resolution") ContainerDb(bookRepo, "BookRepo + BookMetadataRepo", "PostgreSQL / squirrel", "books · book_metadata tables") ContainerDb(paperRepo, "PaperRepo", "PostgreSQL / squirrel", "papers table") } SystemDb(postgres, "PostgreSQL", "") SystemDb(minio, "MinIO / S3", "papers/CHECKSUM · books/CHECKSUM") SystemQueue(kafka, "Kafka", "") System_Ext(arxiv, "arXiv / CrossRef", "") Rel(api, bookSvc, "delegates") Rel(api, paperSvc, "delegates") Rel(api, ingester, "Enqueue() / Status()") Rel(kafka, worker, "owl.v1.Book · owl.v1.Paper") Rel(worker, bookSvc, "BookConsumer") Rel(worker, paperSvc, "PaperConsumer") Rel(worker, ingester, "Enqueue()") Rel(worker, bookIngester, "Enqueue()") Rel(ingester, paperRepo, "Create") Rel(ingester, minio, "Upload PDF") Rel(ingester, kafka, "magpie.v1.Resource") Rel(ingester, metaClient, "Resolve DOI / arXiv") Rel(bookIngester, bookRepo, "Create") Rel(bookIngester, minio, "Upload book file") Rel(bookRepo, postgres, "SQL") Rel(paperRepo, postgres, "SQL")

Overview

Owl is a Go service (module github.com/holmes89/owl) that provides a personal digital library for books and academic papers. Three runtime processes share the same Go module:

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Shrike within joel.holmes.haus Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA — submits search queries") System(shrike, "Shrike", "Full-text and semantic search indexing service") System(lynx, "Lynx", "Web archiving — publishes TextExtractedEvent after enrichment") System(greyseal, "Grey Seal", "RAG conversations — queries Shrike for context retrieval") System(magpie, "Magpie", "Resource index — publishes Resource events for indexing") } SystemDb(postgres, "PostgreSQL", "Index records and full-text document store") SystemDb(qdrant, "Qdrant", "Vector store — cosine similarity search (768-dim)") System_Ext(ollama, "Ollama", "Local LLM — nomic-embed-text embeddings") SystemQueue(kafka, "Kafka", "TextExtractedEvent · EnvelopeEvent · ImportRequest · magpie.v1.Resource") Rel(ui, shrike, "ConnectRPC search queries") Rel(greyseal, shrike, "ConnectRPC hybrid search") Rel(lynx, kafka, "Publishes TextExtractedEvent") Rel(magpie, kafka, "Publishes magpie.v1.Resource") Rel(shrike, postgres, "Reads / writes index records") Rel(shrike, qdrant, "Vector upsert / search") Rel(shrike, ollama, "Embed text chunks") Rel(kafka, shrike, "TextExtractedEvent · EnvelopeEvent · ImportRequest · magpie.v1.Resource")

Container Diagram

C4Container title Shrike — Internal Containers Boundary(shrike, "Shrike") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "IndexRecordService (CRUD) · SearchService (semantic + keyword + reindex)") Container(worker, "cmd/worker", "Go / Kafka", "4 consumers: TextExtracted · Envelope · Import · Resource") Container(indexSvc, "index_record.Service", "Go", "CRUD for index records") Container(chunker, "lib/chunker", "Go", "512-word overlapping windows, 64-word overlap") Container(embedder, "OllamaEmbedder", "Go / HTTP", "nomic-embed-text via Ollama REST API") Container(vectorStore, "QdrantStore", "Go / HTTP", "Upsert · Search · DeleteByEntity on shrike_context collection") ContainerDb(indexRepo, "IndexRecordRepo + DocumentRepo", "PostgreSQL / squirrel", "indexrecords (tsvector GIN) · documents tables") } SystemDb(postgres, "PostgreSQL", "") SystemDb(qdrant, "Qdrant", "shrike_context collection, 768-dim cosine") System_Ext(ollama, "Ollama", "http://ollama:11434") SystemDb(minio, "MinIO / S3", "Blob source for ImportConsumer") SystemQueue(kafka, "Kafka", "") Rel(api, indexSvc, "delegates CRUD") Rel(api, chunker, "Reindex path") Rel(api, embedder, "Embed query") Rel(api, vectorStore, "Search / DeleteByEntity") Rel(api, indexRepo, "Keyword search (tsvector)") Rel(kafka, worker, "TextExtractedEvent · EnvelopeEvent · ImportRequest · magpie.v1.Resource") Rel(worker, indexSvc, "Upsert index records") Rel(worker, chunker, "Chunk full text") Rel(worker, embedder, "Embed chunks") Rel(worker, vectorStore, "Upsert points") Rel(worker, minio, "Download blobs (ImportConsumer)") Rel(indexRepo, postgres, "SQL") Rel(embedder, ollama, "POST /api/embed") Rel(vectorStore, qdrant, "HTTP REST")

Process Decomposition

Shrike is deployed as two containerised binaries (api and worker) plus an optional browser UI (ui). All three share the same Go module and library code under lib/.

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

System Context

C4Context title System Context — Weevil within joel.holmes.haus Person(admin, "Admin", "Tracks personal reading list, searches for and adds books") Boundary(platform, "joel.holmes.haus Platform") { System(ui, "joel.holmes.haus", "Go-app WASM admin SPA") System(weevil, "Weevil", "Book tracking and enrichment service") System(magpie, "Magpie", "Resource hub — receives book resources from Weevil") System(shrike, "Shrike", "Search — indexes book metadata") } SystemDb(postgres, "PostgreSQL", "Books and book metadata (enrichment results)") SystemDb(minio, "MinIO / S3", "Archived Google Books and Open Library JSON responses") SystemQueue(kafka, "Kafka", "weevil.v1.Book · magpie.v1.Resource") System_Ext(googlebooks, "Google Books API", "Book metadata and cover images") System_Ext(openlibrary, "Open Library API", "ISBN-based book metadata") Rel(admin, ui, "Uses") Rel(ui, weevil, "ConnectRPC") Rel(weevil, postgres, "Reads / writes") Rel(weevil, minio, "Archives enrichment API responses") Rel(weevil, kafka, "Publishes weevil.v1.Book") Rel(weevil, googlebooks, "Search + metadata enrichment") Rel(weevil, openlibrary, "ISBN metadata enrichment") Rel(kafka, magpie, "magpie.v1.Resource") Rel(kafka, shrike, "resource events")

Container Diagram

C4Container title Weevil — Internal Containers Boundary(weevil, "Weevil") { Container(api, "cmd/api", "Go / ConnectRPC h2c :9000", "BookService (CRUD + deterministic UUID from ISBN/title) · SearchService (Google Books proxy)") Container(worker, "cmd/worker", "Go / Kafka", "BookConsumer · Enricher goroutine") Container(uiSrv, "cmd/ui", "Go-app WASM :8000", "Browser SPA — book list, create, enrichment view, search") Container(bookSvc, "book.Service", "Go", "Create · Get · List · Update · Delete") Container(searchSvc, "search.Service", "Go", "Stateless proxy to Google Books API") Container(enricher, "enrichment.Enricher", "Go / goroutine", "6-step pipeline: Google Books → Open Library → archive both → persist metadata → magpie (stub)") ContainerDb(bookRepo, "BookRepo + BookMetadataRepo", "PostgreSQL / squirrel", "books · book_metadata (ON CONFLICT DO UPDATE)") } SystemDb(postgres, "PostgreSQL", "") SystemDb(minio, "MinIO / S3", "books//google-books.json · open-library.json") SystemQueue(kafka, "Kafka", "consumer group weevil-service-group") System_Ext(googlebooks, "Google Books API", "") System_Ext(openlibrary, "Open Library API", "") Rel(api, bookSvc, "delegates · publishes weevil.v1.Book to Kafka on Create") Rel(api, searchSvc, "delegates") Rel(kafka, worker, "weevil.v1.Book") Rel(worker, bookSvc, "Persist book from Kafka") Rel(worker, kafka, "Publishes magpie.v1.Resource") Rel(worker, enricher, "Enqueue(EnrichBookRequest)") Rel(enricher, googlebooks, "Search by GoogleID / ISBN / title") Rel(enricher, openlibrary, "Fetch by ISBN") Rel(enricher, minio, "Archive JSON responses") Rel(enricher, bookRepo, "Upsert book_metadata") Rel(bookRepo, postgres, "SQL")

System Overview

Weevil is structured around a classic event-driven backend. The API server publishes book creation events to Kafka; the worker consumes them, persists the book, and enqueues an enrichment request on a buffered channel for asynchronous processing.

Regrow

Mon, 01 Jan 0001 00:00:00 +0000

Designed and executed Kubernetes platform migration for existing microservices; built audit-driven MRV system for carbon credit programs using CQRS, Kafka, and Argo workflows.

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/greyseal/v1/conversation.proto
schemas/greyseal/v1/resource.proto
- Resource
- Source
schemas/greyseal/v1/role.proto
- Role
schemas/greyseal/v1/services/conversation.proto
schemas/greyseal/v1/services/resource.proto
schemas/greyseal/v1/services/role.proto
Scalar Value Types

Top

schemas/greyseal/v1/conversation.proto

Conversation

Conversation is a chat session that persists and can be resumed.

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/lynx/v1/feed.proto
- Feed
- FeedArticle
schemas/lynx/v1/services/feed.proto
schemas/lynx/v1/website.proto
- Website
schemas/lynx/v1/services/website.proto
Scalar Value Types

Top

schemas/lynx/v1/feed.proto

Feed

Field	Type	Label
uuid	string
title	string
url	string
description	string
categories	string	repeated
website_id	string

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/magpie/v1/label.proto
- Label
schemas/magpie/v1/resource.proto
- Resource
- Source
schemas/magpie/v1/resource_label.proto
- ResourceLabel
schemas/magpie/v1/resource_tag.proto
- ResourceTag
schemas/magpie/v1/services/label.proto
schemas/magpie/v1/services/resource.proto
schemas/magpie/v1/services/resource_label.proto
schemas/magpie/v1/services/resource_tag.proto
schemas/magpie/v1/tag.proto
- Tag
schemas/magpie/v1/services/tag.proto
Scalar Value Types

Top

schemas/magpie/v1/label.proto

Label

A single system-generated label on a resource. Labels are machine-authored, key=value structured, confidence-scored, and attached directly to a resource. They are immutable after creation.

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/owl/v1/book.proto
- Book
schemas/owl/v1/paper.proto
- Paper
schemas/owl/v1/services/book.proto
schemas/owl/v1/services/paper.proto
Scalar Value Types

Top

schemas/owl/v1/book.proto

Book

Book resource representing an uploaded or URL-fetched book

Field	Type	Label	Description
uuid	string		Unique identifier
title	string		Book title
authors	string	repeated	Authors
publisher	string		Publisher
publication_year	int32		Publication year
isbn	string		ISBN if available
format	string		File format (pdf, epub, mobi, azw3, etc.)
mime_type	string		MIME type
size_bytes	int64		File size in bytes
checksum	string		Content hash for deduplication (SHA-256)
storage_path	string		Storage location (bucket path)
original_filename	string		Original filename
tags	string	repeated	User-provided tags
notes	string		Notes or description
uploaded_at	google.protobuf.Timestamp		When uploaded
page_count	int32		Number of pages if available
language	string		Language (ISO 639-1 code)
source_url	string		Source URL if fetched from the web

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/shrike/v1/envelope.proto
- EntityEnvelope
schemas/shrike/v1/import_request.proto
- ImportRequest
- ImportRequest.MetadataEntry
schemas/shrike/v1/index_record.proto
- IndexRecord
schemas/shrike/v1/services/index_record.proto
schemas/shrike/v1/services/search.proto
schemas/shrike/v1/text_extracted.proto
- TextExtractedEvent
Scalar Value Types

Top

schemas/shrike/v1/envelope.proto

EntityEnvelope

Field	Type	Description
entity_uuid	string
app	string
entity_type	string
topic	string
event_type	string	"created"
occurred_at	google.protobuf.Timestamp
payload	bytes

API Reference

Mon, 01 Jan 0001 00:00:00 +0000

Protocol Documentation

schemas/weevil/v1/book.proto
- Book
- Source
schemas/weevil/v1/search.proto
- Search
schemas/weevil/v1/services/book.proto
schemas/weevil/v1/services/search.proto
Scalar Value Types

Top

schemas/weevil/v1/book.proto

Book

Field	Type	Label
uuid	string
created_at	google.protobuf.Timestamp
title	string
author	string	repeated
isbn_13	string
isbn_9	string
identifier	string	optional
source	Source	optional
read	google.protobuf.Timestamp	repeated
description	string	optional

Thoro.ai

Mon, 01 Jan 0001 00:00:00 +0000

Conceptualized and built a central fleet management and reporting system for a global robotic fleet from the ground up; led OEM technical teams internationally and mentored newly hired engineers.

Carnegie Robotics

Mon, 01 Jan 0001 00:00:00 +0000

Pioneered the cloud reporting and fleet management platform that was spun out to form Thoro.ai; independently built a decentralized distributed data system with Raft-based replication for U.S. Government robotics projects.

Edge Case Research

Mon, 01 Jan 0001 00:00:00 +0000

Developed production-grade Go services on Kubernetes for rapidly growing self-driving monitoring systems; led Kubernetes-integrated tooling to orchestrate perception model workloads.

Thycotic

Mon, 01 Jan 0001 00:00:00 +0000

Built a greenfield serverless Go application on AWS Lambda with CloudFormation, designed to transparently shift to EC2 once traffic thresholds were reached.

Wombat Security

Mon, 01 Jan 0001 00:00:00 +0000

Migrated monolithic Spring MVC platform to Spring Boot microservices; pioneered Docker containerization for production use across new products.

PNC Bank

Mon, 01 Jan 0001 00:00:00 +0000

Early-career role building enterprise backend systems, establishing foundational skills in financial-grade engineering and large-scale Java development.

Being a Bottleneck

Tue, 14 Jul 2026 00:00:00 +0000

In my last post I talked about automation and how I’ve been reconciling with how work gets done as a developer. The takeaway was that automation is helpful as long as the work is visible and chunked in a way that makes it easily digestible. With the way AI agents work, it becomes eerily similar to the brooms carrying buckets of water: task-oriented, efficient, and eager. Suddenly you’re faced with a huge amount of work in progress (WIP) slowly building up for you to verify. Again referencing The Goal, we find that mountains of work build up in front of bottlenecks. Yes, unfortunately, you are the bottleneck when it comes to AI and that is okay. In fact, it’s really important. Why?

The Right Amount of Automation

Wed, 29 Apr 2026 00:00:00 +0000

Like many people, I’ve found the move to using AI in my work a little earth-shifting. Listening to a recent episode of The Daily, I realized I wasn’t alone in my journey as a developer through this new world. At first I resisted because AI felt like “too much magic,” and after using AI for a while now I know that my hunch was true. The “magic” seems to be the same as the magic used in “The Sorcerer’s Apprentice” (or the German “Der Zauberlehrling”) wherein a mindless object can do your work to possibly deterious effects.

Continuous Delivery Made Easy

Thu, 28 Oct 2021 00:00:00 +0000

After graduating college I wound up with a job at a large bank. There I had a great history lesson on how software used to be developed. Huge requirements documents. Six month development windows. Saturdays spent trying to meet arbitrary requirements set forth my a committee. It was painful.

After the first week I sat down with a senior developer who was supposed to show me how to access the mainframe (this was 2011). He looked at me and said, “What are you even doing here? You should get out while you can.” I laughed and didn’t think anything of it for three years. For those three years I suffered through some pretty rough times including some major health issues but just thought of what I did as just a four letter word: W-O-R-K. It wasn’t fun but it was money.

Suggested Books

Mon, 12 Apr 2021 00:00:00 +0000

As I work with more and more junior developers I often find myself suggesting different books that have helped mold me into the developer I am today. For better or worse these books have changed my perspective on the industry and keep me coming back for more. I love reading technology books and so it can often feel overwhelming when I try to compile a list. Nor do I like the “Best 10 Technology Books Everyone Should Read” posts because I find them cliche and not that helpful because it lumps books together in one pile rather than by category or interest. I’m hoping this post is a living one in which I will be adding and updating content as time goes on since I’m revisiting and reading new books each day.

Work and Team Breakdown

Thu, 10 Dec 2020 00:00:00 +0000

The breakdown of work and the relation it has within development teams has interested me for a long time. There is no question as to where the thoughts began but they have led me down a larger path of discovery. The journey began by reading The Phoenix Project by Gene Kim, in it he talks about the four types of work, how work should be scheduled and broken down into easily repeatable tasks much like a manufacturing plant would. This made sense to me, what is all work but a sense of easily broken down tasks and steps? The smaller the tasks the easier it is to complete and increase throughput.

See One, Do One, Teach One

Wed, 30 Sep 2020 00:00:00 +0000

In the medical industry there is a common practice among surgical students learning a new procedure which is “see one, do one, teach one”. Seeing one allows the students to study from another experienced surgeon, ask questions, and take notes completely focused on learning from a teacher. Doing one enforces the application of the learned material allowing for physical practice with guidance from a teacher on the best practices. Finally in teaching one you learn to explain what you did to another and relearn and reinforce the steps of a procedure.

Working Together While Working Separately

Mon, 28 Sep 2020 00:00:00 +0000

In my current job I’ve been helping lead a small team in the development of a new product. This is a coordinated effort across the company and been a challenge to some as we quickly switch between discovering our customer’s needs with developing them. We have a road map and a plan but translating this into actual work has been difficult. All of the reading I’ve done over the years has helped me develop plans and strategies in order to help organize a group of people around a given task in order to deliver. As with anything application ends up being more difficult than theory.

Joy of Creating

Mon, 21 Sep 2020 00:00:00 +0000

I enjoy my work. I find it fulfilling and the problem solving to be engaging. Yet at the end of the day it’s work. The drudgery of completing tasks, the politics, the deadlines, can take away joy. Software development isn’t unique in this area, almost all jobs have this fine balance between fulfillment and drudgery which is why people have hobbies outside of work. Softball teams and woodworking, painting and poetry, all contribute to balancing our lives and bringing us joy through leisure.

Why I Program

Thu, 13 Aug 2020 00:00:00 +0000

We believe that programming can be, and should be, an intellectually rewarding activity; that a good programming language is a power conceptual tool… - The Art of Prolog

Why do I program? I like the intellectual simulation of solving a problem or designing something. So much of the time as a developer you end up building the same thing over and over. API endpoint for this or a message processor on a queue for that. Maybe this is just the pattern I’ve fallen in over the years. There is room for improvement or building better services but that isn’t enough sometimes. Where I find joy is in solving the problems or learning something new.

Mighty Oak

Mon, 13 Jul 2020 00:00:00 +0000

There is something strange about the way we view ourselves within in jobs. On television there is always a leader who emerges from a difficult scenario or a person who saves a company single handed by making the right deal. But this isn’t how it works, or at least it shouldn’t. Throughout my career I’ve learned that anything of significance shouldn’t be done on your own. In order to build something significant you need to work as a team. Now, you may be the first person on a project or a person who comes up with the idea, but without a community to support you failure will be inevitable.

Technology Maven

Mon, 06 Jul 2020 00:00:00 +0000

In my career I have found myself collecting things. I like to collect programming books, links about new databases and patterns, talks about functional programming. This collection has become somewhat obsessive in some cases and led to the disorganization I’ve described in other posts. When I was starting out I was told that this was not good, that you could run around your entire career chasing “shiny things”. This is true if you are chasing the newest JavaScript library or a cutting edge language, but I felt that maybe this didn’t apply to me. I collected books about LISP and functional programming which weren’t new. I watched talks about Java patterns and concurrency models. Was I chasing shiny things? Was this a waste of time?

Getting Started

Sun, 05 Jul 2020 00:00:00 +0000

Last week I wrote about issues I was having getting things done and worrying about stagnating in my career. I took some time over the past week to disconnect, relax, and reflect about both this problem with “closing” and my career. Throughout my life I’ve been constantly rushing forward and in my career worrying about what will come next. This rushing and worrying always leads me into a mild depression that becomes difficult to overcome. Eventually I realize where I am and find out where I need to go. Sometimes it’s a job change, other times it’s a mentality shift, and in one case it took me flying half way around the world for work to start fresh. What I’ve learned is to do the best where you are at and things will move forward. Following the course of the river instead of paddling against it. What is more important is maintaining a feeling of exploration and hunger. In Becoming Steve Jobs the authors write:

Where I Am

Thu, 25 Jun 2020 00:00:00 +0000

I’m all over the place. I can see that by my notebooks. Each month I sit down and write down a list of goals I want to accomplish. This ranges from books to read to projects to complete to posts to write. All in all I typically manage to complete about 60-70% of what I set out to do. But lately I’ve not even come close. This past month my goal was to clean things up and organize and I accomplished nothing.

Rushing

Thu, 11 Jun 2020 00:00:00 +0000

I’ve always rushed things. In elementary school I rushed through activities to move onto the next thing. In middle school I rushed through classes to take High School classes early. I did the same thing in High School, taking college courses early on to keep moving forward. I couldn’t wait to get through college and “into the real world”. Only to find myself there thinking about changing jobs or going back to school. It would be easy to make the excuse that my brain just is always rushing fast, but I feel like that is an easy excuse. I also don’t think I’m alone in this and hope to find a way to solve this personally.

Simple Site

Tue, 26 May 2020 00:00:00 +0000

Over the past couple of months I have worked on trying to increase my flow of writing. So far I have failed at that. I don’t really have an excuse for it but upon reflection I thought that I could maybe make things a little easier on myself by simplifying my website.

I drew inspiration from a site I found called Tiny Projects and another post about building a digital garden. The problem with my sites have always been they are cumbersome and mildly complicated. This stems from the origin of having a “digital resume” or portfolio to show to others for job searches. There I tried to flex my developer muscles by writing complicated HTML, to building with Gulp.js and Pug, then moving to a Javascript framework, to using Hugo. Each step had it’s complications and were not maintainable.

Project Of My Own

Wed, 15 Apr 2020 00:00:00 +0000

Michael Pollan is one of my favorite authors. Each of his works follow a similar pattern. Define an overarching theme (gardening, cooking, eating), then define some components, go into the history and practice of each sub component. For example in his work A Place of My Own the overarching theme is architecture and some sub-components are location, design, material, etc. In the section on location he talks about Feng-Shui and energy flow of the earth to find the right spot for his house going into the history of Feng-Shui and providing examples of buildings like Falling Water as ideal locations. In the end its a great example of personal project exploration.

Language Ergonomics

Sat, 28 Mar 2020 00:00:00 +0000

There are a ton of programming languages. Each language then holds a specific set of values that lend itself to solving certain problems. Too much time is spent arguing over which language is best and for what reason instead of looking at which languages match can help you solve a problem or match your values.

This last point is why I have spent a lot time exploring new languages.

Early in my career my manager had told me to focus on a depth and breadth strategy for developing in my career; go deep on one technology but explore others to see what is out there. And so I set off to become a better Java developer while still exploring languages and technologies that I came across. Soon I learned about containers, learned how they worked, how they were made and what languages worked best to create lightweight containers. This is where I started developing in Go. Over time I grew to love developing in Go and moved on from Java.

Engineer Mathematician

Fri, 27 Mar 2020 00:00:00 +0000

When I was in college I intented to major in Mathematics. Computer science was supposed to be my minor and support my interests in math. In my first semestor I took a formal math class and was completely lost. Meeting with my professor I discovered that my interests were in his terms “messy math” and not “pure math”. Dissalusioned with this notion of being interested in “messy math” I decided to shift my focus to Computer Science which I felt would allow me to reason through problems in the “messy way” I liked.

On Writing

Mon, 20 Jan 2020 00:00:00 +0000

Throughout my career I’ve always had side projects to help me learn, to practice, to sharpen my skills. Sometimes they were relate to things I had read or ideas that had crossed my mind. Whatever the reason for working on the project it typically ended up being benefitial for my personal growth. Unknowingly I was establishing a practice of a kata, doing an activity in order to refine and hone your skills.

Brave New World

Sat, 16 Feb 2019 00:00:00 +0000

Having just finished Aldous Huxley’s Brave New World, I was struck at the predominance of theme of desensitization. In a culture today where people have become desensitized to the world around them, I worry about its impact on our society. I’m not saying we’ve entered into a dystopian world but these types of books are meant to be hyperbole in order to draw attention to larger concerns expressed by the other or conclusions drawn from the reader.

Be Good to Yourself

Sat, 02 Feb 2019 00:00:00 +0000

Anything that gives you joy or happiness that is entirely for yourself. I have always struggled with self care because it always felt selfish… which is what it is supposed to be. Taking something for yourself can feel awkward at first while you look at all the things that need to be done or the expectations others may have for you. I have always struggled with the need to be the perfect father, husband, son, and employee. With this expectation of myself I left little room for self care and became frustrated, depressed and disengaged in all aspects of my life. All from a lack of self care.

Lambda Terraform

Mon, 21 Jan 2019 00:00:00 +0000

In a previous post I wrote about how to deploy an application in a container. The gist of the post talked about how containers provide a layer of abstraction so that your applications can run on any machine. This is great for local development and large scale applications. However, in order for them to run in a production environment they more than likely are required to run on some sort of runtime or server which can provide some additional cost overhead.

Growing As a Developer

Tue, 15 Jan 2019 00:00:00 +0000

Becoming a better developer does not always mean being an expert in a programming language. Nor does it mean being the smartest person in the room. More often than not you will find that you aren’t an expert and you aren’t the smartest person. Work is more than just programming, it’s understanding and developing products that people will use and to do that it requires more than just a rock star programmer, it requires a person who is has the abilities to help their company succeed.

New Year

Fri, 04 Jan 2019 00:00:00 +0000

I doubt anyone subscribes to my blog or reads it regularly but do those who tune in may have noticed that I haven’t been updating as much recently. For a while I was on a good pattern of posting once a week or at least every other week. These posts where planned and structured and part of an on going process of learning and self discovery. But that changed. Where I was once learning and writing about technology and felt inspired each step of the way, I soon found that both the projects and writing became strained and obligatory instead of inspired.

Cloud Team Thoughts

Fri, 09 Nov 2018 00:00:00 +0000

When I started developing Microservices I felt like I had been missing out on a huge part of the modern technology world. It turned out that I was right. Over the past few years I’ve been trying in my mind to figure out how modern development teams run effectively. What I discovered was that there are tons of people out there trying to figure out the same thing. Many of the things I’ll write about are patterns that have been around for more than a decade, yet still many companies don’t seem to adopt them. In the end building a team in the “cloud era” has changed the landscape and we can find that each change we see in infrastructure, development practices, project management, and testing perpetuates further advancement and change.

Go Docker

Fri, 26 Oct 2018 00:00:00 +0000

So you’ve built an app that runs on your machine. Great. Now what?

Obviously software is built to be used and today most of that software is being run on servers in the cloud. But sometimes it’s not. Sometimes it might be running on some old hardware in the basement of a company or maybe another developer needs to use your code as part of integration.

Whatever the case may be it would be nice to package your application in such a way that it’s guaranteed to work no matter what environment it is in.

Agile Career

Wed, 10 Oct 2018 00:00:00 +0000

There is a very important product that you have complete control over: you. Your skill set, your personality, your overall career is completely within your control. Those are all features of your product and it’s on those pieces that you need to iterate and improve.

Good products are successful often because they have good product managers. It is up to you to decide how you fit into the world and what people are demanding of you. Product managers help take “market interest” and turn it into deliverable features that enhance the product. Sometimes these features aren’t in demand but will aid in the overall quality of the product.

Go Pipeline

Wed, 03 Oct 2018 00:00:00 +0000

One of the most powerful things about Go is the ability to run parts of your application concurrently. This allows the application to run in parallel at times (depending on the number of cores) or continue to run while waiting for a blocked process. There are a number of concurrency patterns that allow you to structure your applications to get a performance boost.

Recently I stumbled across the “Pipeline” pattern and was able to use it to transform incoming data and aggregate the results. Imagine a water treatment plant. Dirty water comes in, clean water comes out. The water goes through several phases before it is clean. First you may filter out large chunks of sediment, then smaller chunks, until you are screening microscopic pieces of debris. Then you want to put it through a series of chemical cleanings and finally test the water quality. Water flows through these various phases. At no point is water stopped until the first step is fully complete. Instead the water is processed as it flow ultimately becoming clean.

Zero Dollar Idea

Fri, 28 Sep 2018 00:00:00 +0000

People enter into technology thinking they can pursue an idea that will make them a lot of money. If you read startup stories you will find that most start with an idea, evolve into a business, become broke, rebound and make millions…. or end up being broke and learning a lot.

I’ve read these stories but I am not a risk taker. Maybe I just don’t believe in my ideas as much as others or lack the confidence to pursue them. However, I like to see things come to life. Will it work? I don’t know. I know how to build it just not how to sell it.

Go Mock Testing

Thu, 27 Sep 2018 00:00:00 +0000

You should always write tests. To fully understand how to write production level applications in any language you should be able to write unit tests. Some people go to the extreme of doing Test Driven Development (TDD). TDD advocates that you should write tests before you write the code. This can be a good approach when trying to write code that can be easily tested. Yet I find that TDD is a lot like agile; a lot of people say they do it but in reality they do some sort of hybrid version. In the end it boils down to eating your veggies before your steak. Some people love veggies, just like people love writing unit tests, but most people find satisfaction in running their code and seeing it work.

Go Hex Arch

Wed, 19 Sep 2018 00:00:00 +0000

In an earlier post I wrote about how to structure Go programs to be leveraged by both a FaaS and a standalone application. This simple application showed the power of what a Hex architecture can do by limiting the need to rewrite logic when an external resource has changed. In that example we looked at changing communication between an HTTP call from an AWS Lambda to a direct application call.

Brain Expansion

Mon, 10 Sep 2018 00:00:00 +0000

I have a terrible memory. It’s not because I don’t pay attention; there is just too much on my mind. The barrage of incoming texts, work emails, news alerts, and ideas creates chaos. Disconnecting is not an option all of the time, especially for those in the technology field, so what can you do?

It used to be when a computer was running slow or crashing the best solution was to add more RAM, expand its memory. You can’t just open someone’s head and add more memory. Nor do I believe that “brain exercises” can help. Instead, what I have found is the only way to handle the title wave of distraction is to create a map, establish boundaries, and think out loud.

Serverless to Server

Thu, 16 Aug 2018 00:00:00 +0000

Functions as a service (FaaS) have really become a staple in most development circles. They provide little infrastructure overhead in the development of microservices and are often very lightweight. Yet FaaS face their own sets of challenges when it comes to costs, response times, and observability.

I believe that architectures will evolve over time. In some cases you may never want to change your FaaS but there may be cases that you’ll want to move it to it’s own application. The problem is you may want to go back or you may not want to rewrite all of the business logic injected into that FaaS. So what do you do?

Catching Up

Wed, 15 Aug 2018 00:00:00 +0000

I felt that I had a pretty good grasp of what the technology world was like when I graduated from college. After all I just built a series of programs for my classes (of varying quality), none of which had real world applications. I had built systems using live APIs like Twitter and used cool frameworks like Google Web Toolkit. So in the end I felt pretty confident in my abilities even though I had no exposure to the industry.

Understanding Serverless

Wed, 15 Aug 2018 00:00:00 +0000

To be honest, I’ve had a rough time understanding how FaaS fit into my vision of a microservice architecture. It made sense that they were microservices themselves, especially when they are event driven: put something in a bucket, then do something, maybe do something else and so on. But what I didn’t understand was why build a serverless function if you could build an API.

In the end I realize that it was how I had learned to develop microservices that was the crux of my issue. I have always been a very detail oriented person. I like to write the code, package it, provision my server, deploy my code to the server, add the routing, etc. All of this obviously takes time, overhead, and an understanding of the underlying systems.

Accelerating Development

Sun, 15 Jul 2018 00:00:00 +0000

The main goal of every startup is to make money. Every part of the organization should be driven to create money for the company. This means creating products that users want to buy while decreasing the cost to produce the product all in a timely manner.

In a technology startup the product to deliver in many cases is code. The beginning phases of this process involve a lot of late nights, rapid development, and manual processes. As the company grows and the product becomes more complex these practices becomes untenable and error prone. Consequently the speed of development slows and the ability to respond to the market diminishes.

Consumer Driven Contracts

Fri, 15 Jun 2018 00:00:00 +0000

In the past I have written about what a microservice architecture looks like and some of the tradeoffs that come with it. One of the biggest gains this architecture brings you is the ability for many people to be working on different projects at the same time. Inevitably the services you are writing will be used or you may need to consume someone else’s API to get your work done.

This is easy right?

Clean Repositories

Tue, 15 May 2018 00:00:00 +0000

When reading Clean Architecture by Robert Martin, I came across a chapter of the same name. In it the author describes this “idealized” architecture structure where business and application logic are at the center of the diagram with outward rings surrounding it describing interactions with various frameworks and IO devices.

This architecture can also be known as Hex Architecture or Ports and Adapters Architecture, all having a similar design where core business logic is independent of the IO interfaces surrounding it allowing for architectures that are independent of frameworks, ui, and databases.

Narrative Code

Wed, 18 Apr 2018 00:00:00 +0000

Intro

In starting this series, I was confronted with the dilemma of which area of programming should I start with? Testing? Data Modeling? Language Types? All of which are very important topics and areas that any good developer should know. However, I felt strongly that the best area to start was not with code at all but writing.

As a developer we tend to write our code for one person, ourselves. Yet most of the time our code can live longer than the tenure at a job. Or even worse, you are forced to revisit code you wrote years ago and have no clue what it does.

Programming Is a Craft

Sun, 11 Mar 2018 00:00:00 +0000

This is a response to the following article Programming as craft

Programming is a craft. I will never claim to be a master of the craft but to say that programming cannot be considered a craft overlooks many elements of the profession. Sure, groups of developers aren’t building artisan furniture or designing magnificent cathedrals but none of these crafts were perfected overnight and relatively speaking programming is in its infancy.

The notion that programming is not a craft stuck me in an odd sense and I have been wrestling internally with its contents for a few weeks now. This response is not a critique of the authors points but rather a different perspective reflective of a personal journey that I’ve had in my career as a developer. I hope to address a few of his criticisms and point out some possible overlooked areas of the profession.

Dumb Phone Eulogy

Thu, 01 Mar 2018 00:00:00 +0000

I am one of the few people who’ve probably traded in their smart phone for a dumb phone. By dumb phone I mean a phone that pretty much just makes calls and texts. For over eight years now I’ve scorned the smart phone market because of the increasing negative effects I feel it has on people. The concept of being constantly connected always presents itself as a great thing but often leads to isolated interactions with people because they are busy checking their Facebook or Twitter feeds or playing some new game.

Sagas

Mon, 26 Feb 2018 00:00:00 +0000

My last couple posts have been about developing and designing cloud based applications. In the What Are Microservices blog post I wrote about the importance of having small shippable applications that can easily scale depending on demand and are decoupled from other services to allow for faster development and independent deployments. In A Tangled Mess we explored how to decouple the systems even more by publishing events as they occur and having other systems react in appropriate ways.

A Tangled Mess

Sun, 25 Feb 2018 00:00:00 +0000

The goal of microservices is to produce independent systems that have loose coupling. This allows for the ability to manage and release upgrades without impacting other applications. However, many first implementations of microservices make the developers believe that the only way to communicate with another API is through a client. Thinking that obviously this is part of the whole process, they design many APIs that rely on other APIs and the chain goes on and on, and in some cases back to the original API for more data. As you can imagine this becomes a tangled mess.

What Are Microservices

Sat, 24 Feb 2018 00:00:00 +0000

At the beginning we all start building an application. Then some part of it takes off and before you know it you are throwing new pieces on the original application until it becomes unweildy. Thus is born the Monolith. In time your system gets large, cumbersome, and hard to maintain. Then you hear about microservices (or maybe you started that way because it was in fashion when you started development) and start building them. But in developing microservices we can often forget about what they are and why we are doing it. It’s not because it’s the cool thing to do nor is it the easiest thing to do (quite the opposite) but it’s a smart thing to do.

Another Tech Blog

Fri, 23 Feb 2018 00:00:00 +0000

Who needs another technology blog? Aren’t there enough out there? It seems like it’s a right of passage for someone to create one but to who’s benefit? This has been the third or fourth (maybe fifth) attempt for me to start some sort of blog each with their vision.

Yet in the end they sit in a corner of the internet wasting away helping no one. All blogs feel that they need to solve the world’s problems, get one million hits, and then the authors can quit their day jobs.

Joel Holmes

About

Why I Built It

About

Why I Built It

About

Why I Built It

About

Why I Built It

About

Why I Built It

About

Why I Built It

EasyPost

Architecture

System Context

Container Diagram

Overview

Architecture

System Context

Container Diagram

Overview

Architecture

System Context

Container Diagram

System context

Architecture

System Context

Container Diagram

Overview

Architecture

System Context

Container Diagram

Process Decomposition

Architecture

System Context

Container Diagram

System Overview

Regrow

API Reference

Protocol Documentation

Table of Contents

schemas/greyseal/v1/conversation.proto

Conversation

API Reference

Protocol Documentation

Table of Contents

schemas/lynx/v1/feed.proto

Feed

API Reference

Protocol Documentation

Table of Contents

schemas/magpie/v1/label.proto

Label

API Reference

Protocol Documentation

Table of Contents

schemas/owl/v1/book.proto

Book

API Reference

Protocol Documentation

Table of Contents

schemas/shrike/v1/envelope.proto

EntityEnvelope

API Reference

Protocol Documentation

Table of Contents

schemas/weevil/v1/book.proto

Book

Thoro.ai

Carnegie Robotics

Edge Case Research

Thycotic

Wombat Security

PNC Bank

Being a Bottleneck

The Right Amount of Automation

Continuous Delivery Made Easy

Suggested Books

Work and Team Breakdown