VarBear

Old workhorses won’t quit (Bash), rewrites bite back (Go—love and hate), and APIs are treated like infrastructure, not handshakes. Between sub‑millisecond AI caches, local‑first SQLite sync, Rust‑powered momentum, and the sobering math of one‑maintainer open source, this batch is all signal—skim now, steal later.

🐚 Bash Explained: How the Most Popular Linux Shell Works

🧱 Developer's block

🔌 Everything I know about good API design

⚙️ From Python to Go: Why We Rewrote Our Ingest Pipeline at Telemetry Harbor

🪓 Go is still not good

⚡ How Salesforce Delivers Reliable, Low-Latency AI Inference

🗄️ Lessons learned from building a sync-engine and reactivity system with SQLite

👤 Open Source is one person

🦀 The unexpected productivity boost of Rust

📦 We Needed Better Cloud Storage for Python so We Built Obstore

You just picked up a few unfair advantages—use them.

Have a great week!
FAUN.dev Team

New data from ecosyste.ms drops a hard truth: almost 60% of 11.8M open source projects are solo acts. Even among NPM packages topping 1M monthly downloads, about half still rest on one pair of hands.

The world runs on open source. But the scaffolding seems shakier than anyone wants to admit—millions rely on code maintained by lone developers, many juggling it on top of everything else.

Why it matters: Supply chain risk isn’t just where the code comes from. It’s who shows up to fix it when things break. Right now, that’s usually one person.

Telemetry Harbor tossed out Python FastAPI and rebuilt its ingest pipeline in Go. The payoff? 10x faster, no more CPU freakouts, and stronger data integrity thanks to strict typing.

PostgreSQL is now the slowest link in the chain—not the app—which is the kind of bottleneck you actually want. Means the system scales better.

Obstore is a new stateless object store that skips fsspec-style caching and keeps its API tight and predictable across S3, GCS, and Azure. Sync and async both work. Under the hood? Fast, zero-copy Rust–Python interop. And on small concurrent async GETs, it reportedly crushes S3FS with up to 9x better throughput.

System shift: Stateless APIs are trending—for good reason. Less hidden state means clearer, saner access patterns in distributed systems.

Lubeno's backend is 100% Rust, providing strong safety guarantees for refactoring confidence. Rust's type checker catches async bugs, unlike TypeScript. Rust excels in tracking lifetimes and borrowing rules. Zig, on the other hand, can be alarming with its compiler choices, such as overlooking typos in error handling.

This guide lays out the playbook for running tough, user-first APIs: no breaking changes, stick to familiar patterns, honor long-lived API keys, and make every write idempotent.

It pushes cursor-based pagination for heavy data, rate limits that come with context, and optional fields to keep things lean. Gives GraphQL a side-eye for being heavyweight and pricey to build.

Why it matters: The post tracks a shift in mindset—APIs aren’t just interfaces, they’re infrastructure. Built to last. Easy to adopt. Change carefully, or don’t change at all.

Salesforce’s AI Metadata Service (AIMS) just got a serious speed boost. They rolled out a multi-layer cache—L1 on the client, L2 on the server—and cut inference latency from 400ms to under 1ms. That’s over 98% faster.

But it’s not just about speed anymore. L2 keeps responses flowing even when the backend tanks, bumping availability to 65% during failures. Services like Agentforce stay up, even if they’re limping a bit.

System shift: What started as a performance tweak is now core to how Salesforce keeps its AI standing tall under pressure.

A dev ditched Electric + PGlite for a lean, browser-native sync setup built around WASM SQLite, JSON polling, and BroadcastChannel reactivity. It’s running inside a local-first notes app.

Changes get logged with DB triggers. Sync state? Tracked by hand. Svelte stores update via lightweight polling, with Yjs CRDTs smoothing out conflicts.

What’s the move? A nod toward slimmer, SQLite-backed sync engines—less server, more client.

Go’s been catching flak for years, and the hits keep coming: stiff variable scoping, no destructor patterns, clunky error handling, and brittle build directives. Critics point out how Go’s design often blocks best practices like RAII and makes devs contort logic just to clean up resources or manage state.

Overdoing “best practices” can kill momentum. Think endless tests, wall-to-wall docs, airtight CI, and coding rules rigid enough to snap. Sounds responsible—until it slows dev to a crawl.

The piece argues for flipping that script. Start scrappy. Build fast. Save the polish for later. It’s how you dodge dev paralysis and keep ideas flowing.

Bash isn't going anywhere. It's still the glue for CI/CD, cron jobs, and whatever janky monitoring stack someone duct-taped together at 2am. If automation runs the show, Bash is probably in the pit orchestra.

It keeps things moving on Linux, old-school macOS (think pre-Catalina), and even WSL. Still oddly cross-platform. Still everywhere.

☕ Git Pull Coffee – Black Mug Fuel your commits the right way. Perfect for devs who push code and pull coffee.

This 90-minute documentary chronicles Python's journey from an Amsterdam side project to a global programming powerhouse. Interviews with key figures reveal Python's community-driven evolution and the internal conflicts that threatened its existence. Explore the pivotal moments and impactful decisions that shaped this ubiquitous language.

MCP Servers are shaping the future of software. MCPMark is a comprehensive, stress-testing benchmark and a collection of diverse, verifiable tasks designed to evaluate model capabilities in real-world MCP use.

All Algorithms implemented in Python

Manage stacked Git branches

Lemonade helps users run local LLMs with the highest performance by configuring state-of-the-art inference engines for their NPUs and GPUs.

Did you know that CockroachDB lets you run serializable, slightly stale read-only queries from any replica using follower reads powered by its closed timestamp mechanism? The leaseholder continuously closes timestamps a few seconds behind wall-clock time (by default roughly 3 s), and any replica can serve reads up to that safe, closed timestamp. This enables geo-distributed applications to hit local replicas for low-latency reads while retaining correct, serializable guarantees—even though the data reflects a moment in the recent past.

"Most dev tools trade explicit knobs for implicit rules. That saves time until you need a knob, at which point you're debugging the rules."
— SenseiOne