This episode explores how a computational physics startup uses Herbie, an open-source tool from the University of Washington, to automatically detect and rewrite imprecise floating-point expressions. Hosts Lucas and Luna walk through a concrete example: a Naive Bayes classifier whose probability calculations were losing precision in the fifth decimal place due to catastrophic cancellation. Herbie rewrote the expression in under a minute, reducing error from 12% to 0.003% with no change in model logic. The discussion covers why floating-point errors matter in modern machine learning, how Herbie applies numerical analysis heuristics and Monte Carlo sampling, and the trade-offs between readability and precision. Relevant for engineers working on scientific computing, GPU kernels, or any system where tiny errors compound over millions of iterations.

#FloatingPoint #NumericalAccuracy #Herbie #NaiveBayes #CatastrophicCancellation #MachineLearning #ScientificComputing #OpenSource #UniversityOfWashington #Precision #GPU #ComputationalPhysics #Startup #TechnicalPodcast #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #TheTechnicalCoFounder

Keep every episode free: buymeacoffee.com/fexingo

Lucas and Luna explore how a small fintech startup called Resolve replaced traditional try-catch error handling with algebraic effects in their TypeScript backend. They walk through a concrete example: a payment-retry pipeline that reduced code complexity by 40 percent and made error paths testable as first-class control flow. The episode unpacks what algebraic effects actually are, why they're moving from research languages into production, and how one team made the jump without rewriting their entire stack. If you've ever struggled with deeply nested error handling or wondered whether academic PL concepts can actually ship, this one is for you.

#AlgebraicEffects #ErrorHandling #TypeScript #Fintech #Resolve #ControlFlow #ProgrammingLanguages #SoftwareEngineering #Backend #Startup #CodeQuality #DeveloperExperience #Business #Technology #FexingoBusiness #BusinessPodcast #Engineering #TechDeepDive

Keep every episode free: buymeacoffee.com/fexingo

Episode 111 of The Technical Co-Founder Podcast dives into WebAssembly as a sandbox for running untrusted code in production. Lucas and Luna explore how a startup called Extism uses WASM to let customers run custom plugins without security nightmares. They break down the technical trade-offs: why WASM's linear memory model beats containers for isolation, the performance overhead compared to native, and how Extism handles language-agnostic plugin systems. Specific numbers: a typical Extism plugin boots in under 100 microseconds versus 100+ milliseconds for a container. Luna challenges Lucas on whether WASM's lack of system call access limits real-world use cases. The conversation also touches on WASI, the WebAssembly System Interface, and where WASM is heading for server-side computing. If you're building a platform that needs safe extensibility, this episode gives you a concrete architecture to evaluate.

#WebAssembly #WASM #Extism #UntrustedCode #Sandbox #PluginSystems #PlatformEngineering #SecurityIsolation #WASI #ServerSideWASM #Containers #Performance #Microseconds #Business #Technology #FexingoBusiness #BusinessPodcast #TechnicalCoFounder

Keep every episode free: buymeacoffee.com/fexingo

In episode 110 of The Technical Co-Founder Podcast, Lucas and Luna explore how one startup — FoundationDB-inspired but built in Rust — uses deterministic simulation testing to catch distributed systems bugs before they reach production. They break down the technique: replayable pseudo-random scheduling, fault injection, and the insight that you can test failure modes that would take centuries to reproduce in the real world. Lucas explains why this matters for any team building on distributed consensus, and Luna asks the hard question: can you retrofit this into an existing system without rewriting from scratch? Specifics include a real case where a simulation found a two-year-old bug in a consensus protocol, and a discussion of the testing framework 'Turmoil' as an example. The episode is anchored to July 2026, when simulation testing is gaining traction beyond database internals into fintech and blockchain infrastructure.

#DeterministicSimulation #DistributedSystems #FoundationDB #Rust #Turmoil #Testing #FaultInjection #Consensus #Database #Fintech #Blockchain #Startup #Engineering #CTO #TechnicalCoFounder #FexingoBusiness #BusinessPodcast #SoftwareEngineering

Keep every episode free: buymeacoffee.com/fexingo

Fully homomorphic encryption has been the holy grail of privacy-preserving computation for over a decade — but the early implementations were so slow they were unusable outside labs. This episode drills into a specific startup, Zama, and their open-source library TFHE-rs, which brings FHE to production by running on GPU hardware. We walk through how they trade off noise budgets and bootstrapping cycles, why they chose Rust, and what a real-time encrypted inference pipeline actually looks like. Lucas and Luna break down the math without the jargon: learning with errors, programmable bootstrapping, and the throughput improvements that finally make this viable for industries like healthcare and finance. Recorded July 13, 2026.

#FullyHomomorphicEncryption #FHE #PrivacyEngineering #Cryptography #Zama #TFHE #GPUComputing #RustLang #HomomorphicEncryption #SecureComputation #DataPrivacy #MachineLearningInference #OpenSource #BusinessTechnology #FexingoBusiness #BusinessPodcast #TheTechnicalCoFounderPodcast #TechPodcast

Keep every episode free: buymeacoffee.com/fexingo

We look at how a startup called SourceGraph uses hybrid vector search to let developers find code by meaning, not just by keyword. Lucas explains the technical architecture: embedding functions are called on every code push, vectors are stored in a custom index alongside a BM25 fallback, and queries are merged using a weighted combination. Luna brings up the latency challenge: vector search is slower than regex, but SourceGraph keeps median query time under 200 milliseconds by sharding and caching. We also discuss the trade-off between recall and cost: full embedding pipelines are expensive, so SourceGraph uses a tiered approach where smaller repos use lightweight models. The episode ends with a reflection on how semantic search is changing the way developers navigate large codebases, and a listener support pitch tied to the open-source nature of the tools discussed.

#SourceGraph #VectorSearch #SemanticCodeSearch #HybridSearch #BM25 #Embeddings #DeveloperTools #CodeSearch #AIEngineering #OpenSource #Business #Technology #FexingoBusiness #BusinessPodcast #TheTechnicalCoFounderPodcast #MachineLearning #NLP #StartupTech

Keep every episode free: buymeacoffee.com/fexingo

Most serverless platforms still run your code inside a container, but what if you stripped away the operating system entirely? Lucas and Luna talk to the CTO of a startup that replaced containers with unikernels—single-address-space machine images that boot in milliseconds and cut memory overhead by 80 percent. They walk through the architecture: how the team compiles each function into a lightweight kernel using MirageOS, how they handle networking without a traditional TCP/IP stack, and the surprising debugging challenges when your stack trace ends in the hypervisor. They also get honest about the tradeoffs—no shell access, limited library support, and why this model only makes sense above a certain invocation rate. If you've ever wondered whether serverless can get any leaner, this episode gives you a look under the hood of the next frontier.

#Unikernels #MirageOS #Serverless #CloudNative #Kernel #Hypervisor #Containers #ColdStart #Latency #MemoryFootprint #Solo.io #NanoVMs #LibraryOS #Haskell #OCaml #BusinessAndTechnology #FexingoBusiness #BusinessPodcast

Keep every episode free: buymeacoffee.com/fexingo

In this episode of The Technical Co-Founder Podcast, Lucas and Luna explore event sourcing through the lens of a startup that rebuilt its core ledger system using immutable event streams instead of traditional CRUD. They break down how EventStoreDB enables full audit trails, temporal queries, and simpler debugging by storing every state change as an append-only log. The discussion covers the trade-offs: eventual consistency, replay costs, and when event sourcing is overkill. A concrete example from a fintech company shows how event sourcing eliminated reconciliation nightmares and let developers ask 'what was the state at any point in time?' Perfect for engineers considering event-driven architectures or tired of patching database schemas.

#EventSourcing #EventStoreDB #CQRS #DomainDrivenDesign #EventDrivenArchitecture #Immutability #AuditTrail #Fintech #SoftwareArchitecture #BackendEngineering #DatabasePatterns #Infrastructure #TechnicalCoFounder #Fexingo #BusinessPodcast #BusinessAndTechnology #EngineeringLeadership #StateRebuilding

Keep every episode free: buymeacoffee.com/fexingo

Episode 105 of The Technical Co-Founder Podcast dives into the world of conflict-free replicated data types, or CRDTs. Lucas and Luna explore how a startup called Pixelboard built a real-time collaborative whiteboard that works seamlessly offline, then syncs when connectivity returns. The episode focuses on their specific engineering choices: why they chose an RGA-based list CRDT for drawing strokes, how they handle undo across peers, and the trade-off between causal delivery and performance. Lucas explains why CRDTs beat Operational Transform for this use case, citing data transfer of just 2.4 KB per stroke even with hundreds of collaborators. The hosts also touch on the operational complexity of garbage-collecting tombstones in an append-only log. This is a concrete case study for any engineering leader evaluating offline-first architecture.

#CRDT #OfflineFirst #CollaborativeEditing #RealTimeSync #Pixelboard #RGA #DistributedSystems #ConflictResolution #LocalFirst #WebDevelopment #StartupEngineering #ClientSideLogic #UndoRedo #BusinessAndTechnology #EngineeringPodcast #FexingoBusiness #BusinessPodcast #TechPodcast

Keep every episode free: buymeacoffee.com/fexingo

Episode 104 dives into the engineering trade-off between gRPC and Cap'n Proto, a zero-copy serialization format that one startup used to cut inter-service latency by 60 percent. Lucas walks through how the company swapped protobuf-generated gRPC stubs for raw Cap'n Proto messages over TCP, eliminating serialization overhead in their data pipeline. Luna presses on the costs: loss of HTTP/2 streaming, no built-in health checking, and a steeper learning curve for the team. The episode includes concrete benchmarks—300 microseconds per call down from 1.2 milliseconds—and a candid discussion of when the trade-off makes sense (high-throughput, latency-sensitive paths) versus when it doesn't (public-facing APIs or polyglot environments). The hosts also touch on the broader trend of zero-copy serialization in systems programming and why startups with tight latency budgets are revisiting old assumptions about gRPC as a default.

#CapnProto #gRPC #Serialization #ZeroCopy #Latency #InterServiceCommunication #StartupEngineering #SystemsProgramming #ProtocolBuffers #TCP #Performance #Microservices #Backend #DataPipeline #BusinessAndTechnology #FexingoBusiness #BusinessPodcast #TheTechnicalCoFounder

Keep every episode free: buymeacoffee.com/fexingo