惯性聚合 高效追踪和阅读你感兴趣的博客、新闻、科技资讯
阅读原文 在惯性聚合中打开

推荐订阅源

WordPress大学
WordPress大学
GbyAI
GbyAI
P
Proofpoint News Feed
B
Blog
MyScale Blog
MyScale Blog
V
V2EX
B
Blog RSS Feed
Microsoft Security Blog
Microsoft Security Blog
量子位
Jina AI
Jina AI
博客园 - 叶小钗
Recent Announcements
Recent Announcements
有赞技术团队
有赞技术团队
罗磊的独立博客
L
LangChain Blog
I
InfoQ
云风的 BLOG
云风的 BLOG
freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
人人都是产品经理
人人都是产品经理
小众软件
小众软件
V
Visual Studio Blog
月光博客
月光博客
The Cloudflare Blog
雷峰网
雷峰网

The Practical Developer

The Libuv Thread Pool Trap: Why Node.js Async APIs Stall Under Load Postgres Covering Indexes with INCLUDE: Eliminate Heap Fetches on Read-Heavy Workloads Postgres DISTINCT ON: The Fastest Way to Get the Latest Row Per Group Postgres Transaction Isolation: The Anomalies Your App Actually Faces in Production Linux TCP Tuning for Node.js Microservices: The Kernel Settings That Stop Silent Connection Drops Under Load Postgres HOT Updates and Fillfactor: Why Not All Writes Are Created Equal Database Connection Pool Leaks: Finding the Promise That Never Returns Its Seat Linux OOM Killer in Production: Why Your Node.js Containers Die Without a Stack Trace Postgres Materialized Views: Refresh Strategies That Do Not Lock Your Dashboards API Dependency Health Checks: Why /health Is Not Enough Authorization with Zanzibar Tuples: How Google Manages Permissions and How To Build the Same Check in Node.js Postgres Advisory Locks: The 20-Character Primitive That Replaces Redis for Coordination Dead Letter Queues: The Message Queue Pattern That Saves You at 2 a.m. File Descriptor Exhaustion: The Kernel Limit That Silently Drops Node.js Connections Graceful Degradation: The Pattern That Turns Total Outages into Partial Success PostgreSQL Full-Text Search: Dropping Elasticsearch for 90% of Use Cases S3 Presigned Multipart Uploads: Stop Your API Server from Being a File Upload Bottleneck MessagePack vs JSON: The Binary Serialization Switch That Cut Our Internal RPC Overhead by 40% DNS Caching in Node.js: The Silent Cause of Production Latency Spikes Reliable Cron Jobs: The Pattern That Stops Double Runs, Missed Executions, And The 2 AM Page GraphQL Query Complexity: Stop the OOM Query Before It Reaches Your Resolver Node.js Event Loop Lag: The Hidden Metric Behind Random Latency Spikes API Request Validation with Zod: The Schema That Catches Bad Input Before It Corrupts Your Database Load Shedding in Node.js: How to Reject Traffic Before You Drown Request Hedging: Cut Tail Latency In Half Without Overprovisioning Git Bisect: The Automated Binary Search That Finds Breaking Commits in Minutes Node.js Garbage Collection Tuning: Stop Letting V8 Pause Your Event Loop Node.js Server Timeouts: The Settings That Stop Slow Clients from Holding Sockets Hostage Postgres BRIN Indexes: The Time-Series Secret That Shrinks Indexes by 99% Event Sourcing with PostgreSQL: The Pragmatic 80% Solution
Node.js vs Bun vs Deno: Which Runtime Should You Pick in ...
The Practica · 2025-01-15 · via The Practical Developer
Code on a monitor with syntax highlighting

Three JavaScript runtimes. One real question: which should you bet your project on?

Node.js is the safe, proven choice. Bun claims 3–5× faster startup and built-in bundler. Deno has the cleanest security model. Let’s cut through the marketing.

The quick benchmark

Running a simple HTTP server under load on the same machine:

RuntimeReq/secStartupMemory
Node 2242,00085ms38MB
Bun 1.197,00012ms22MB
Deno 271,00031ms29MB

Bun wins on raw throughput. But benchmarks aren’t production.

Where Node still wins

Ecosystem. npm has 2.5 million packages. The long tail of internal tooling, company libraries, and obscure adapters runs on Node. Until Bun hits 100% compatibility (it’s close but not there), Node is the default for anything complex.

Stability. Node 22 LTS is boring in the best way. It’s not changing the rules under you.

Hiring. Every senior engineer knows Node. Bun is a risk if you have turnover.

Where Bun earns its hype

  • Monorepo tooling. bun install is genuinely 10–25× faster than npm install on a cold cache. This alone can justify switching for large repos.
  • All-in-one. Bundler, test runner, package manager, TypeScript natively. Fewer config files.
  • Scripts and CLIs. Startup time matters here. A CLI that boots in 12ms vs 85ms is a real UX difference.

Where Deno fits

Deno’s permissions model (--allow-net, --allow-read) is excellent for running untrusted scripts or building security-sensitive services. If you’re writing serverless functions or internal tools that handle sensitive data, Deno’s defaults are right.

The recommendation

  • Greenfield web service → Node 22 LTS. Boring is good.
  • CLI tool or script → Bun. Startup speed and built-in TS win.
  • Security-critical or isolated function → Deno.
  • Monorepo with slow CI → Switch npm install to bun install. You don’t have to go all-in.

Don’t rewrite your Node app in Bun for the benchmarks. Do consider Bun for new tooling where startup time and simplicity matter.