The Node (and more) Banter

Platformatic
  • 0.0 (0)
  • TECNOLOGÍA
  • CADA SEMANA

The Node (and more) Banter is your weekly dose of unfiltered, unscripted conversations between Luca Maraschi and Matteo Collina. We explore the edge cases, the anti-patterns, and the things no one puts in the docs. From distributed architecture to platform pitfalls and how enterprises tackle modern development—nothing’s off-limits. It’s not just Node.js®—it’s everything around it, wrapped in sharp banter, war stories, and real-world insight. The sky’s the limit.

  1. HACE 19 H

    The Myths (and Costs) of Running Node.js on Kubernetes

    Kubernetes is often sold as the one-size-fits-all platform for scaling applications. But when it comes to Node.js, the reality looks very different: sluggish autoscaling, bloated cloud bills, and resource models that don’t align with Node’s event-driven nature. In this episode of The Node (& More) Banter, we cut through the hype and explore why Kubernetes isn’t always the perfect fit for Node.js workloads—and what teams can do about it. We’ll dig into: ✅ Why autoscaling lag hurts bursty Node.js traffic ✅ How CPU/memory limits clash with Node’s async model ✅ The hidden costs of “elastic” scaling in Kubernetes ✅ Why treating Node.js like Java leads to waste and inefficiency ✅ Smarter strategies for scaling Node.js effectively in the cloud If you’ve ever wondered why your Kubernetes setup feels slow, expensive, or unpredictable with Node.js, this conversation will help you rethink the defaults—and save both performance and money.

    33 min

  2. 24 SEP

    From Reactive to Predictive: Smarter Node.js Operations at Scale

    For enterprises, Node.js apps bring both agility and complexity. Over-provisioned clusters, slow autoscaling, and disconnected metrics can silently drive up costs and risk outages. The future lies in predictive operations: runtime-aware scaling, unified observability, and cache intelligence—all working together to keep systems fast and efficient. In this episode, we’ll explore how modern Node.js operations help enterprises: ✅ Cut infrastructure costs by up to 30% with smarter scaling ✅ Prevent outages before they happen with Event Loop–aware monitoring ✅ Gain full-stack visibility—from Kubernetes to caching efficiency ✅ Shift from firefighting to proactive operations If you care about performance, cost, and operational clarity, this is the conversation you don’t want to miss.

    41 min

  3. 17 SEP

    Type-Safe API Clients: The Future of Integration

    APIs are the backbone of modern applications—but how often do they break because of mismatched payloads or vague documentation? That’s where type safety comes in. Type-safe clients don’t just save you from runtime errors; they make development faster, safer, and way less stressful. In this episode, we explore why type-safe client generation matters, how it works under the hood, and why it’s becoming essential for teams building complex systems in Node.js and beyond. From automated TypeScript definitions to schema-driven code generation, this is the roadmap to more predictable and maintainable integrations. We’ll cover: ✅ What “type-safe client generation” actually means ✅ How it eliminates guesswork and reduces integration bugs ✅ The role of OpenAPI and JSON Schema in generating trusted clients ✅ Real-world examples of broken integrations—and how type safety prevents them ✅ How type safety improves onboarding and long-term maintainability If you’ve ever wrestled with unclear API docs, runtime surprises, or the dreaded undefined is not a function, this episode is your guide to making API integration reliable—without slowing down your team.

    42 min

  4. 10 SEP

    The Cost of Not Updating Node.js (with Erick Wendel)

    Sticking to an outdated Node.js version might feel safe—but under the hood, it can be a ticking time bomb. From unpatched security flaws to missed performance boosts, the tradeoffs aren’t always obvious until it’s too late. In this episode, we’re joined by Erick Wendel to explore the hidden risks, technical debt, and missed opportunities that come from running on old Node.js releases—and why so many teams delay the upgrade in the first place. We’ll dig into: ✅ How outdated versions silently impact performance and reliability ✅ The real security risks lurking in older releases ✅ Compatibility issues with modern libraries and tooling ✅ The gains you’re leaving on the table by not upgrading ✅ Practical strategies for safe, low-friction migrations ✅ The cultural, organizational, and technical reasons why teams resist updates If your Node.js stack hasn’t been updated in a while—or you’re weighing the risks of upgrading—this conversation will give you the clarity (and the push) you need.

    44 min

  5. 3 SEP

    Reading the Fire: Flamegraphs and the Hunt for Node.js Bottlenecks

    You can’t fix what you can’t see—and when it comes to performance issues in Node.js, flamegraphs are one of the most powerful tools you have. But what are they, really? And how do you actually use them? In this episode, we break down everything you need to know about flamegraphs—from the theory behind them to their implementation in Node.js. Whether you’re chasing event loop delays, CPU hotspots, or blocking I/O, flamegraphs reveal what your app is really doing under the hood. We’ll cover: ✅ What flamegraphs are and how they visualize stack traces over time ✅ How they’re implemented in Node.js (using V8 and async hooks under the hood) ✅ How to generate and capture them in dev and production ✅ How to read them: interpreting stack height, width, and call depth ✅ Real examples of uncovering performance bottlenecks ✅ How we’ve built automated flamegraph capture into Platformatic WattIf you’ve ever struggled with unexplained latency, inconsistent P99s, or just want to understand your Node.js app at a deeper level—this episode is your crash course in seeing the invisible.

    44 min

  6. 27 AGO

    Stop Reinventing the Wheel: Mastering HTTP Caching

    When it comes to speeding up API calls, many developers jump straight into custom caching layers—rediscovering problems that HTTP solved decades ago. In this episode, we dig into why HTTP caching is still one of the most underused superpowers in web performance. You’ll learn: ✅ How standard HTTP cache headers (Cache-Control, ETag, Vary) can do the heavy lifting ✅ Why revalidation beats blind refetching ✅ Common mistakes that lead teams to build fragile, homegrown caching hacks ✅ How proper HTTP caching strategies improve scalability, latency, and cost Before you spin up another custom cache, make sure you’re using the protocol that was built for the job.

    41 min

  7. 20 AGO

    The danger of SetImmediate

    At a glance, setImmediate() seems like just another async tool in Node.js—but misuse it, and you could end up with unresponsive apps, delayed executions, or even missed events. In this episode, we break down why setImmediate() is often misunderstood, where it actually fits into the event loop, and the hidden performance and logic traps it can introduce in real-world applications. We’ll dig into: ✅ How setImmediate() really works (vs setTimeout and process.nextTick) ✅ Common pitfalls that can silently break your logic ✅ Real-world debugging stories from misused timing functions ✅ Safer patterns for deferring work in production ✅ Why understanding the event loop is still essential for Node.js devs If you’ve ever added a setImmediate() and hoped for the best, this episode is for you.

    33 min

  8. 13 AGO

    The Hidden Cost of Async Context in Node.js (with Bryan English)

    From background tasks to cross-request tracing, many developers rely on async context to glue state across their code. But under the hood? It’s fragile, unpredictable, and often a performance landmine. In this episode, we’re joined by Bryan English to dive into the lesser-known tradeoffs of async context management in Node.js—and how to build observability without breaking your app or your brain. We’ll dig into: ✅ What async context really is (and what it isn’t) ✅ Why it breaks in production, especially under load ✅ The performance overhead of AsyncLocalStorage ✅ Real-world patterns for context propagation that don’t implode ✅ Lessons from building observability tools on top of it all If you've ever struggled to trace a request, debug a memory leak, or just wondered why your context vanished mid-flight—this one’s for you.

    52 min
Ver todo (30)

Acerca de

The Node (and more) Banter is your weekly dose of unfiltered, unscripted conversations between Luca Maraschi and Matteo Collina. We explore the edge cases, the anti-patterns, and the things no one puts in the docs. From distributed architecture to platform pitfalls and how enterprises tackle modern development—nothing’s off-limits. It’s not just Node.js®—it’s everything around it, wrapped in sharp banter, war stories, and real-world insight. The sky’s the limit.

Información

  • Creador
    Platformatic
  • Años de actividad
    2 k
  • Episodios
    30
  • Clasificación
    Apto
  • Copyright
    © Platformatic
  • Mostrar sitio web
    The Node (and more) Banter