Happy Monday! ☀️
Welcome to the 48 new hungry minds who have joined us since last Monday!
If you aren't subscribed yet, join smart, curious, and hungry folks by subscribing here.
📚 Software Engineering Articles
🗞️ Tech and AI Trends
👨🏻💻 Coding Tip
Use Rust lifetime bounds to express how long callbacks may borrow captured data.
Time-to-digest: 5 minutes
LinkedIn's tracking infrastructure ingests hundreds of billions of events per day—millions per second at peak—turning user interactions into signals for experimentation, analytics, and product decisions. The system had served the company well for years, but the technical environment had shifted. Modernizing meant more than upgrading libraries; it required a complete architectural rethink with zero downtime.
The challenge wasn't just adopting gRPC and modern Java. The legacy system mixed all event categories—compact engagement signals, bursty media events, deeply nested observability payloads—into one resource pool. A true rebuild meant separating workloads, changing the request contract, altering serialization, and migrating production traffic without dropping a single event.
The challenge: Modernize a high-throughput event pipeline from Java 8 + REST to gRPC + modern Java while handling resource contention between disparate workload types and ensuring zero data loss during migration.
Implementation highlights:
Parallel rebuild with traffic comparison. Kept the legacy service live while building a new destination in parallel. Sent 10% of eligible events through both pipelines, matched outputs by comparison ID, and moved traffic only when validation passed—allowing rollback via routing rather than deployment.
Workload isolation by cost and failure risk. Split traffic into categories with independent capacity, metrics, and deployment controls. Media bursts no longer starved experimentation signals, and deeply nested observability events got their own tuned resource model.
Context deduplication on the wire. Sent shared client and session context once per request instead of repeating it for every event. Cut inbound network usage by ~89% (from 210.7G to 21.7G in observed windows) while maintaining the same downstream contract.
Inline encoding and zstd compression. Replaced intermediate Avro objects with precompiled encoders and switched batch compression from gzip to zstd. Improved throughput by 13–25% locally and reduced Kafka producer CPU without requiring downstream schema changes.
Staged rollout with production profiling. Moved high-volume events first to surface concurrency problems early, then optimized based on real workload shapes. Discovered a shared-cache contention issue hidden by sequential benchmarks; fixed it with direct conversion paths for supported events.
Results and learnings:
Evidence-driven migration. A tagged sample avoided the cost of duplicating 100% of traffic while still catching field-level incompatibilities, latency shifts, and schema mismatches before full ramp.
Concurrency beats benchmarks. Sequential tests hid thread contention on shared resources. Production profiling under realistic load revealed optimization opportunities that synthetic tests missed entirely.
Asynchronous boundaries hide problems. Success at the API boundary doesn't guarantee Kafka delivery. Independent validation at request, producer callback, and downstream consumption stages caught issues that synchronous checks would have masked.
The lesson: when a simple migration would leave old and new code assumptions tangled together for months, a parallel rebuild with comparative validation is worth the engineering cost. Just make sure your feature flags let you roll back in seconds—because at LinkedIn's scale, even small inefficiencies compound faster than you can say "I'll optimize that in the next release."
ARTICLE (agents watching agents)
Agentic Monitoring
GITHUB REPO (inference goes brrr)
DeepSeek open-sources its production inference engine to cut compute costs
ESSENTIAL (types prevent chaos)
The bedrock of software design
ARTICLE (humans vs. AI hammers)
Elephants, Goldfish And The New Golden Age Of Software Engineering
ARTICLE (hollow orchestrators rise)
AI Made Developers Faster. Is Their Judgment Keeping Up?
ARTICLE (flash beats molasses)
DeepSeek ships open-source Flash model with faster outputs and free search API
ARTICLE (SSO so you don’t)
The Developer’s Guide To SSO
ARTICLE (tiny PRs go brrr)
Speeding up code review with small-change
ARTICLE (EU languages need nuance)
Go Runtime Choices for AI Models and Better Linguistic Nuance in EU Support Chatbots
ARTICLE (fundamentals still matter)
How to Learn ML in 2026 interview
Want to reach 200,000+ engineers?
Let’s work together! Whether it’s your product, service, or event, we’d love to help you connect with this awesome community.
Brief: Cloudflare reduced AI code review costs from $2.46 to $0.77 per review by optimizing token usage and experimenting with model selection and effort levels.
Brief: Claude proved security properties across 123 open-source libraries at the assembly code level, discovering long-hidden bugs in production software.
Brief: PHP released urgent updates (8.5.12, 8.4.27, 8.3.36, 8.2.35) fixing two critical RCE vulnerabilities in memory management and error handling that allow unauthenticated attackers to execute code on servers.
Brief: Kimi released K3.1 Pro, its most capable open-weight model with a 1-million-token context window, delivering improvements in coding, 3D creation, and financial analysis.
Brief: OpenAI hardened research environments with defense-in-depth security and implemented a policy of no internet access for frontier model training to prevent sophisticated models from escaping containment.
Brief: Meta adopted agentic AI in the development cycle for Forum, shifting from human-in-the-loop assistance to human-on-the-loop oversight where agents autonomously plan, build, test, and verify code.
This week’s tip:
Leveraging Lifetime Subtyping for Complex Borrowing Patterns
Use lifetime subtyping ('a: 'b) to express constraints that a reference must outlive another, enabling patterns like callbacks that capture borrowed data with strict compile-time verification.
When to use it:
When building event systems or callback registries where captured references have varying lifetimes.
When the compiler rejects valid code due to lifetime mismatch in higher-order functions.
When designing libraries that need to express nuanced lifetime contracts to users.
People do not decide their futures; they decide their habits and their habits decide their futures.
Gary Keller
That’s it for today! ☀️
Enjoyed this issue? Send it to your friends here to sign up, or share it on Twitter!
If you want to submit a section to the newsletter or tell us what you think about today’s issue, reply to this email or DM me on Twitter! 🐦
Thanks for spending part of your Monday morning with Hungry Minds.
See you in a week — Alex.
Icons by Icons8.
*I may earn a commission if you get a subscription through the links marked with “aff.” (at no extra cost to you).