Tech 👨💻 • Finance 💰 • Piano 🎹
Vietnam
Joined August 2011
- Tweets4.9K
- Following726
- Followers881
- Likes1.2K
Dong Nguyen retweeted
we announced Jev 1.14 on 10.14 at 1:14pm PT 🔥
a new and improved model, along with experimental features for our dreamers:
• images
• a new box type
• longer context
surprise, Jev was already able to see you! 👁️
BUT our bar for production-grade intelligence is quite high, so builders beware, these are preview features.
enter the ~*~ danger zone ~*~ at your own risk. 🚨
Dong Nguyen retweeted
The top 1% of AI spenders now outspend the bottom 50% combined
They spend an average of $903/month, while the median customer spends just $25
More charts in our Top 100 Consumer AI Apps breakdown: a16z.news/p/top-100-consumer…
The seventh edition of our Top 100 Consumer AI Apps is here.
New this time: a revenue leaderboard, alongside the usual web and mobile traffic rankings.
Three years ago we published the first edition. ChatGPT was #1, Claude was unranked, and the entire category was chatbots, image generators, and not much else.
In today's edition:
- ChatGPT still holds the throne, now with 1B+ monthly actives on mobile
- Claude has climbed to #3 on web with nearly 1B monthly visits
- The category has expanded to vibe coding (Lovable, Cursor, Replit), music (Suno), design (Figma), voice (ElevenLabs), video (Higgsfield, Kling), agents (Manus), and even hardware (Plaud)
Full breakdown from @omooretweets: a16z.news/p/top-100-consumer…
Dong Nguyen retweeted
90% of Go in 2026 comes down to mastering these 10 concepts:
1) Context everywhere
Plumb ctx through handlers, clients, DB calls; timeouts and cancelation stop goroutine leaks and tail latency.
2) Concurrency with bounds
Goroutines are cheap until they aren’t; limit fanout with semaphores/worker pools and design backpressure, not infinite queues.
3) Interfaces + error design
Small interfaces, wrap with %w, sentinel vs typed errors; make call sites able to branch without string matching.
4) Memory + allocation hygiene
Know when you’re copying vs sharing, avoid accidental retention (slices/maps), use pprof allocs to fix GC-driven p99.
5) HTTP client/server gotchas
Reuse http.Client, set transport limits, close bodies, tune timeouts; on servers, avoid unbounded request bodies and slowloris.
6) Tooling that catches real bugs
go test -race, fuzzing, govulncheck, staticcheck; wire them into CI so correctness isn’t a vibe check.
7) Debugging production Go
Read goroutine dumps, block/mutex profiles, and execution traces; most incidents are deadlocks, thundering herds, or stuck I/O.
8) Observability that helps at 3am
Structured logs with request IDs, RED/USE metrics, tracing with sampling; instrument DB calls and external APIs first.
9) Security basics that ship safely
TLS defaults, secret handling, least-privilege IAM, input validation; watch for SSRF, path traversal, and unsafe deserialization.
10) Real-world mistakes to avoid
Sharing mutable state across goroutines, forgetting to drain channels, retrying without jitter, and treating nil errors as success paths
Dong Nguyen retweeted
If I had 6 months to become a Backend Engineer in the AI era.
I’d do this.
Stage 1: Core Languages and Concurrency
- Learn: Go, Rust or advanced Python. Goroutines, async/await, memory management, thread safety.
- Practice: Build a high-throughput HTTP server from scratch handling 10k+ concurrent connections.
- Why: AI generates code but you must architect the concurrency models that don't crash under load.
Stage 2: Modern Databases and Vector Stores
- Learn: PostgreSQL (deeply), pgvector, ClickHouse for analytics, Redis for caching, partitioning, indexing strategies.
- Practice: Build a multi-tenant database with Row-Level Security (RLS) and hybrid search (BM25 + vector).
- Why: Structured data and semantic embeddings now live in the same query engine.
Stage 3: Event-Driven Architecture
- Learn: Kafka, NATS or RabbitMQ. Pub/Sub patterns, event sourcing, dead-letter queues, exactly-once processing.
- Practice: Build an order-processing pipeline where every state change is an immutable event.
- Why: AI workloads are slow and asynchronous. You cannot block the main thread waiting for an LLM.
Stage 4: Durable Execution and Workflows
- Learn: Temporal or Inngest. State machines, saga patterns, infinite retries, checkpointing.
- Practice: Build a 3-day automated onboarding workflow that survives server restarts and API timeouts.
- Why: Background jobs are for emails. Durable execution is for multi-step AI agents.
Stage 5: AI Gateways and Semantic Caching
- Learn: API rate limiting, token budgeting, semantic caching (embedding similarity), fallback routing.
- Practice: Build a proxy that caches identical LLM prompts and automatically fails over to a cheaper model if the primary API 503s.
- Why: LLM APIs are expensive and flaky. The gateway protects your margins and your uptime.
Stage 6: Identity, Security and Zero Trust
- Learn: OAuth2, OIDC, JWTs, PII redaction, agent sandboxing, least-privilege access.
- Practice: Build an auth middleware that masks PII before it hits your logs and restricts AI agents to read-only DB roles.
- Why: When AI agents can write to your database, a bad prompt injection is a data breach.
Stage 7: Streaming and Real-Time Protocols
- Learn: Server-Sent Events (SSE), WebSockets, gRPC streams, WebRTC, backpressure handling.
- Practice: Build a real-time collaborative dashboard that streams LLM token generation and database updates simultaneously.
- Why: Time-To-First-Token (TTFT) and perceived latency are the new UX standards.
Stage 8: Full-Stack Observability
- Learn: OpenTelemetry, Prometheus, Grafana, Langfuse. Distributed tracing, custom metrics, log aggregation.
- Practice: Build a tracing pipeline that correlates a user's HTTP request with the exact LLM prompt and database query it triggered.
- Why: You cannot debug an AI hallucination if you can't replay the exact context the model saw.
Stage 9: Infrastructure as Code (IaC) and CI/CD
- Learn: Terraform or Pulumi, Docker, Kubernetes basics, GitHub Actions, ephemeral environments.
- Practice: Write scripts that spin up a complete, isolated staging environment for every pull request automatically.
- Why: Manual deployments are a liability. Infrastructure must be version-controlled and reproducible.
Stage 10: Cloud FinOps and Autoscaling
- Learn: Queue-based autoscaling (KEDA), spot instances, cost allocation tags, resource limits.
- Practice: Build an autoscaler that spins up GPU/CPU nodes based on Kafka queue depth and shuts them down when empty.
- Why: Backend engineers are now responsible for the cloud bill. Idle resources burn runway.
Stage 11: System Design and Resiliency
- Learn: Circuit breakers, bulkheads, rate limiting, chaos engineering, CAP theorem, distributed locks.
- Practice: Design a globally distributed rate-limiter using Redis that handles network partitions gracefully.
- Why: Systems fail. Your architecture must degrade gracefully not cascade into a total outage.
Stage 12: Public Portfolio and Teardowns
- Learn: Writing architecture decision records (ADRs), drawing system diagrams, benchmarking.
- Practice: Publish 3 deep-dive articles on how you scaled a specific bottleneck (e.g., "How I reduced DB latency by 80%").
- Why: Senior engineers are hired for their judgment not just their syntax.
CRUD is dead. AI writes the boilerplate.
The modern backend engineer builds the nervous system for global scale and autonomous agents.
Bookmark and Repost!
Big news from Xiaomi: MiMo v2.6 series released:
- MiMo v2.6 pro & flash, same price as v2.5, but 1/20–1/60 the cost of top overseas models
- UltraSpeed mode = 20x faster inference
- auto-code gen, 3D reasoning, Blender, robotics, even music creation
- Open-source weights + full training code
Xiaomi token plan is just what I need: no bloat, just power for building. #Xiaomi #MiMo
mimo.mi.com/docs/en-US/news/…
Dong Nguyen retweeted
I read 10+ articles and watched 5 hours of content to understand what Jev actually is.
This is my attempt to put it all in one place, from how it works and what you can build + list of useful resources needed to go deeper.
Dong Nguyen retweeted
LLMs vs. Jev, clearly explained!
TL;DR
The key difference is not that Jev generates faster.
Jev does not generate text at all.
A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it.
Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel.
Consider an agent handling a failed deployment. It may need to determine:
→ Whether the incident is urgent
→ Which team should handle it
→ Whether the proposed command is risky
→ Whether the task is complete
An LLM generates a response containing these answers sequentially. The application then parses and validates it.
With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities.
Jev supports three decision primitives:
1. **Choice** selects from known options, such as engineering, billing, or sales.
2. **Score** places the input on an ordered scale, such as low, medium, or high risk.
3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true.
The probabilities matter as much as the selected answers.
If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model.
This keeps control inside ordinary software.
Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text.
It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly.
It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential.
Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments.
The clean mental model is this:
LLMs generate new language when the answer space is open.
Jev evaluates known paths when the answer space is bounded.
I wrote the full breakdown explaining Jev and where it fits.
The article is quoted below.
Dong Nguyen retweeted
System Design Concept diagrams of the week.🚀
1. Rate Limiting
2. CRON Jobs
3. Load Balancers and Load Balancing Algorithms
4. Pub-Sub
5. Message Queues
I’ve been posting 1 system design concept every day.
Interested in learning system design? Follow along.
Dong Nguyen retweeted
In this article, the @golang team gives a detailed explanation of how the new goroutine leak profiler works (and when it doesn’t) with multiple examples of bad patterns and how to fix them 👉 go.dev/blog/goroutine-leak-p…
GoLand may not fix your leaks, but the new profile is already available in the “Go Optimization” tool, so that you can find and analyze them without having to leave your IDE.
Used to juggle Postgres, Redis, Meilisearch in separate apps. Switched to DBX - one lightweight open-source client for 90+ databases.
Built-in AI that actually sees db schema, so generating SQL is almost unfairly easy.
github.com/t8y2/dbx
Stumbled on this gem: Music Theory for Programmers.
As a coder who plays piano, seeing scales & chords built from pure math + JS arrays? Absolute mind-blow 🎹#MusicTheory #Programming #Piano #Coding @RunJS_app runjs.app/blog/music-theory-…
Dong Nguyen retweeted
Can a sufficiently powerful quantum computer forge the signatures used to authorize Bitcoin and Ethereum transactions? What would it take to upgrade both networks before that happens?
In this new lecture, Stanford cryptographer @danboneh explores why blockchains may turn to signatures built from hash functions. He also presents new research on threshold signing.
The talk ends with the questions Bitcoin still has to answer, including whether post-quantum signatures will require larger blocks, what happens to abandoned coins, and how someone such as Satoshi could prove ownership after Bitcoin’s current signatures have been retired.
00:00 Why blockchains need to prepare for quantum computers
03:05 Why Bitcoin may bet on hash-based signatures
06:25 The “big footgun” in stateful signatures
08:58 A quantum-safe signature that takes one billion hashes
14:13 Inside SLH-DSA’s virtual tree
20:30 How Bitcoin and Ethereum could make the switch
23:48 What happens when a wallet loses its state?
32:47 Can threshold signing survive the quantum transition?
36:39 How to hide lattice cryptography from the blockchain
38:49 Why threshold one-time signatures seem impossible
45:36 How context prevents forged signatures
49:37 The forgotten idea behind Winternitz signatures
54:50 Turning one-time signatures into threshold signatures
1:04:27 Will quantum-safe signatures require bigger Bitcoin blocks?
1:06:26 Abandoned bitcoin and Satoshi’s recovery problem
Bullish continuation or bull trap? what to observe:
- Spot demand vs Futures leverage
- ETF flows
- BTC $80k break
- Altcoin breadth
- Macro next week: Kevin Warsh at Jackson Hole
- Treasury yields & DXY
#BitcoinRecovery
Dong Nguyen retweeted
Bir Kere Girince Saatlerce Çıkamayacağınız 50 Site
1.) 'zoom.earth' — Dünyayı canlı uydu görüntüsüyle izleme
2.) 'flightradar24.com' — Şu an gökyüzündeki her uçağı görme
3.) 'marinetraffic.com' — Denizdeki tüm gemileri anlık takip
4.) 'windy.com' — Rüzgar ve fırtınaların canlı haritası
5.) 'lightningmaps.org' — Dünyaya düşen yıldırımları anlık izleme
6.) 'earthquake.usgs.gov' — Son depremlerin canlı listesi
7.) 'submarinecablemap.com' — İnterneti taşıyan okyanus kabloları
8.) 'globalforestwatch.org' — Ormanların yok oluşunu uydudan izleme
9.) 'worldometers.info' — Dünyanın istatistikleri saniye saniye
10.) 'internetlivestats.com' — Şu an atılan tweet ve arama sayısı
11.) 'thetruesize.com' — Ülkelerin gerçek boyutlarını karşılaştırma
12.) 'oldmapsonline.org' — Yüzyıllar öncesinin haritaları
13.) 'davidrumsey.com' — 150 bin tarihi harita arşivi
14.) 'openstreetmap.org' — Gönüllülerin çizdiği dünya haritası
15.) 'window-swap.com' — Rastgele birinin penceresinden dünyaya bakma
16.) 'virtualvacation.us' — Şehirlerde sanal yürüyüş
17.) 'mapcrunch.com' — Dünyanın rastgele bir noktasına ışınlanma
18.) 'atlasobscura.com' — Dünyanın en tuhaf yerlerinin kataloğu
19.) 'neal.fun' — Etkileşimli bilgi deneyimleri
20.) 'htwins.net/scale2' — Atomdan evrene ölçek yolculuğu
21.) 'eyes.nasa.gov' — Güneş sistemini 3B gezme
22.) 'stellarium-web.org' — Tarayıcıda gerçek gökyüzü haritası
23.) 'apod.nasa.gov' — NASA'nın günün astronomi fotoğrafı
24.) 'images.nasa.gov' — NASA'nın tüm görsel arşivi ücretsiz
25.) 'pudding.cool' — Veriyle anlatılan görsel makaleler
26.) 'ourworldindata.org' — Dünyanın gerçek verilerle hali
27.) 'gapminder.org' — Dünya hakkındaki yanlış bildiklerimiz
28.) 'informationisbeautiful.net' — Karmaşık veriyi görselleştirme
29.) 'data.worldbank.org' — Dünya Bankası'nın açık verileri
30.) 'data.tuik.gov.tr' — Türkiye'nin resmi istatistik veritabanı
31.) 'archive.org' — Milyonlarca kitap, film ve yazılım arşivi
32.) 'gutenberg.org' — Telifi düşmüş 70 bin ücretsiz kitap
33.) 'openlibrary.org' — Dünyanın her kitabının kaydı
34.) 'loc.gov' — ABD Kongre Kütüphanesi dijital arşivi
35.) 'europeana.eu' — Avrupa'nın kültürel miras arşivi
36.) 'dp.la' — Amerika'nın dijital kütüphane koleksiyonu
37.) 'artsandculture.google.com' — Müzeleri evden gezme
38.) 'rijksmuseum.nl' — Sanat eserlerini yüksek çözünürlükte indirme
39.) 'wikiart.org' — 250 bin sanat eserinin arşivi
40.) 'publicdomainreview.org' — Tarihin unutulmuş görsel hazineleri
41.) 'openculture.com' — Ücretsiz kültür ve eğitim arşivi
42.) 'metmuseum.org' — Met Müzesi'nin açık koleksiyonu
43.) 'musicmap.info' — Müzik türlerinin soy ağacı
44.) 'radiooooo.com' — Ülke ve on yıl seçip o dönemi dinleme
45.) 'listen.hatnote.com' — Wikipedia düzenlemelerini sese çevirme
46.) 'wikipedia.org/wiki/Special:R…' — Rastgele bilgi kuyusu
47.) 'timeanddate.com' — Zaman, gündoğumu ve gökyüzü olayları
48.) 'sciencedaily.com' — Bilim haberlerinin güncel akışı
49.) 'arxiv.org' — Bilimsel makalelerin ücretsiz ön baskıları
50.) 'observablehq.com' — Veriyi canlı kodla görselleştirme
İnternet, algoritmanın önünüze koyduğu o beş siteden ibaret değil.
Dong Nguyen retweeted
🐹 Go: a must-read deep dive into data races and the memory model
Why code that works can still be wrong:
• memory visibility between goroutines
• compiler & CPU reordering
• happens-before guarantees
• atomics, mutexes, channels
func25.dev/posts/go-memory-v…
#golang #go
Dong Nguyen retweeted
90% of Go in 2026 comes down to mastering these 10 concepts (the rest is arguing about frameworks):
1) Context everywhere
Deadlines and cancellation across HTTP, DB, and RPC; missing ctx is how you get stuck goroutines and mystery latency.
2) Concurrency with budgets
Goroutines are cheap until they’re not; cap with worker pools/semaphores and track p95 queue time, not just CPU.
3) Channels vs mutexes
Channels for ownership and pipelines, mutexes for shared state; mixing both without a clear rule breeds deadlocks.
4) Escape analysis and allocations
Know when you’re putting stuff on the heap; a single hot path allocating 1KB/request at 5k rps is 5MB/s of GC churn.
5) Interfaces and nil traps
Typed nil inside an interface still isn’t nil; it shows up as weird panic paths and broken error checks.
6) Error hygiene
Wrap with context, don’t log twice, and make retryable errors explicit; production is debugging by stack + message.
7) Tooling that pays rent
go test -race, go vet, staticcheck, fuzz, and pprof in CI; most outages are regressions these would’ve caught.
8) Debugging in prod
Learn pprof CPU/heap/block, goroutine dumps, and trace; knowing what a blocked goroutine looks like saves hours.
9) Observability, not printfs
OpenTelemetry traces + metrics + structured logs; always tag tenant, endpoint, status, and build SHA for bisects.
10) Security defaults
Disable http.DefaultTransport surprises, set timeouts, validate inputs, pin TLS settings, and audit deps; the common bug is trusting inbound JSON too much