New session - 2025-12-16T02:56:16.345Z

Session ID: ses_4dae9b626ffeluKptIP9s9Aojs Created: 12/15/2025, 11:56:16 PM Updated: 12/16/2025, 12:02:28 AM

User

analyze this cfp submission

Session Title

Bridging Worlds: Writing Native Addons with Node-API

Description

Sometimes JavaScript isn’t enough for whether you’re chasing performance, need low-level system access, or want to integrate an existing C++ library you can’t (or don’t want to) rewrite. That’s where Node-API comes in: a stable, version-independent interface for writing native addons in Node.js.

In this talk, we’ll walk through building native addons using Node-API along with the node-addon-api C++ wrapper, which abstracts away the complexity of Node/V8 internals and lets you focus on your logic. You’ll learn how to build addons that are ABI-stable, maintainable, and portable across Node.js versions and all without tightly coupling your code to Node itself.

Whether you’re looking to boost performance, reuse internal C++ libraries, or modernize legacy systems, you’ll leave this session equipped to bridge native and JavaScript worlds.

Key Outcomes

After attending this talk, audience members will be able to:

  1. Understand what Node-API;
  2. Use the node-addon-api wrapper to write native addons in C++ without depending directly on Node.js internals;
  3. Build and compile a basic native addon and expose it cleanly to JavaScript;
  4. Safely integrate existing C/C++ codebases into Node.js applications.

Session format Session

In-person or virtual Virtual

Track Development

Level Intermediate

Language English

Assistant

Here is the analysis of your CFP submission based on the 4 U’s Framework and Features vs. Benefits guidelines.

1. The 4 U’s Analysis

Metric Score (1-4) Analysis
Useful 4/4 Very useful. Solving performance bottlenecks and reusing legacy C++ code are real, high-value problems for engineering teams.
Unique 2/4 “Intro to Node-API” talks are relatively common. To raise this score, the talk needs a specific “hook” or a concrete, unusual use case (e.g., “We wrapped a 20-year-old C++ engine” vs “How to build an addon”).
Urgent 2/4 Node-API has been stable for a while. Why is this urgent now? You might frame it around the pain of maintaining NAN-based addons or the increasing need for efficiency in serverless environments.
Ultra-specific 2/4 The description promises to build a “basic native addon.” This is vague. It is better to name what we are building (e.g., “a matrix multiplication engine” or “a system-level idle timer”).

Verdict: The topic is solid, but the pitch feels slightly generic. We need to make it feel like a “must-see” rather than “just another tutorial.”

2. Features vs. Benefits Analysis

You actually did a good job here, but we can sharpen the edges.

  • Current Feature: “Walk through building native addons using Node-API along with the node-addon-api C++ wrapper.”
    • Improved Benefit: “Stop fighting V8 breaking changes. Learn to build addons that survive major Node.js upgrades untouched.”
  • Current Feature: “Abstracts away the complexity of Node/V8 internals.”
    • Improved Benefit: “Write C++ for Node.js without needing a PhD in the V8 engine.”

3. Suggestions for Improvement

A. Title Alternatives (Punchier & More Specific)

Using the 38-headline patterns:

  1. Promise a Benefit: “Stop Rewriting C++ Libraries: How to Wrap Them Safely with Node-API”
  2. Arouse Curiosity: “The Secret to Writing Native Addons That Don’t Break When Node Updates”
  3. How-To: “How to Boost Node.js Performance with C++ (Without the V8 Headers Nightmare)”
  4. Problem/Solution: “JavaScript Too Slow? A Practical Guide to Bridging the Gap with Node-API”
  5. Specific Result: “Ship Stable Native Modules: From ‘Works on My Machine’ to ABI Stability”

B. Strengthening the Abstract

I recommend adding a concrete example to the description to boost the “Ultra-specific” score.

Revised Draft (incorporating improvements):

Title: Stop Rewriting C++ Libraries: A Practical Guide to Node-API

Abstract: JavaScript is powerful, but sometimes you hit a wall—whether it’s raw performance constraints or the need to use a battle-tested C++ library that you can’t justify rewriting. In the past, writing native addons meant wrestling with V8 internals and breaking builds with every Node.js update.

In this session, we will bypass the boilerplate and build a real-world image processing addon (or insert specific example here) using node-addon-api. You will learn how to create ABI-stable modules that run seamlessly across different Node versions, keeping your codebase maintainable and your team happy. Stop fighting the compiler and start bridging the native world with confidence.

4. Next Steps

To generate the final, submission-ready CFP, I need a few details to tailor the tone and structure:

  1. What is the specific conference name? (I can check their specific tracks and themes).
  2. Do you have a specific “demo” application in mind? (e.g., Image processing, heavy math, IoT, etc. - looking at your file list, maybe something related to your Brainfuck compiler or Git integration experiments?)
  3. Speaker Bio: Do you want me to generate a bio based on your about.md and project list (CodeMiner42, Ruby/Node expertise)?

User

/export miguel-analisis.txt

Assistant

User

i like you mentioned matrix multiplication. ai is very relevant these days, do you think we can wrap this add-on information in a talk about how to make matrix multiplication, which is very important for Machine Learning, in node?

like to show that node could compete with python libraries

Assistant

Tool: read

Assistant

Tool: read

Assistant

Tool: read

Assistant

That is a fantastic pivot! 🚀

Focusing on Matrix Multiplication for AI/ML transforms this talk from a generic “how-to” into a compelling, high-stakes story: Can Node.js actually compete with Python in the AI arena?

This angle immediately pushes the “Urgency” and “Uniqueness” scores to 4/4 because it challenges the industry standard (Python) and addresses a hot topic (AI infrastructure).

Here is the revised CFP designed to sell this specific narrative.

1. Title Options

Pick the one that fits your style:

  1. The “Challenge” Headline: “Python Isn’t Magic: Writing High-Performance Machine Learning Addons in Node.js”
  2. The “How-To” Headline: “Building a Matrix Multiplication Engine from Scratch with Node-API”
  3. The “Curiosity” Headline: “Can Node.js Beat Python at Math? Benchmarking Native Addons in the AI Era”
  4. The “Benefit” Headline: “Unlock High-Performance AI in Node.js: A Deep Dive into Node-API and C++”
  5. The “Bold Promise” Headline: “Stop Offloading to Python: Bring Heavy Computation Back to Node.js”

2. The CFP Submission

Talk Title: Python Isn’t Magic: Writing High-Performance Machine Learning Addons in Node.js

Abstract: Python currently dominates the AI/ML landscape, largely because libraries like NumPy wrap high-performance C++ code. But Node.js developers don’t have to sit on the sidelines. The Node-API provides a stable, version-independent way to bring that same raw power to JavaScript.

In this session, we will demystify the “magic” of ML libraries by building a native matrix multiplication addon from scratch. We will walk through using node-addon-api to wrap C++ logic, manage memory safely, and expose a clean JavaScript API. You will leave with the knowledge to build ABI-stable modules that can crunch numbers as fast as Python, proving that Node.js is ready for the heavy lifting of modern AI.

Description / Detailed Outline:

  • The “Why”: We start by benchmarking a naive matrix multiplication in plain JavaScript vs. Python’s NumPy. Spoiler: JS loses. We explain why (Single thread, V8 overhead) and why child_process isn’t the answer.
  • The “How” (Node-API):
    • Introduction to Node-API and node-addon-api (avoiding the “V8 headers” nightmare).
    • Live Coding/Walkthrough: Scaffolding a C++ addon.
    • The Core Logic: Implementing the matrix multiplication algorithm in C++.
    • Bridging the Gap: converting JS Arrays/TypedArrays to C++ vectors and back efficiently.
  • The “Result”: We run the benchmark again with our new addon. We discuss how to package this for distribution (prebuilds) so users don’t need a compiler installed.
  • The Takeaway: You don’t need to switch languages to build high-performance tools. You just need to know how to bridge the gap.

Target Audience: Intermediate to Advanced Node.js developers who are curious about internals, performance optimization, or Machine Learning infrastructure. No deep C++ knowledge required.

Key Outcomes:

  1. Understand why Python dominates ML (C++ bindings) and how Node.js can replicate that architecture.
  2. Build and compile a working Node-API addon using node-addon-api.
  3. Safely pass complex data (like matrices/buffers) between JavaScript and C++.
  4. Learn to distribute native modules that are stable across Node.js versions.

3. Speaker Bio (Drafted based on your profile)

I synthesized this from your about.md and past talks. Feel free to tweak!

Edy Silva is a software engineer and architecture enthusiast who loves peering under the hood of the tools we use every day. With a background in full-cycle development at CodeMiner42 and a passion for sharing knowledge (from local meetups to Google I/O Extended), Edy specializes in bridging the gap between high-level developer experience and low-level system performance. When he isn’t debugging Node.js internals or optimizing Ruby memory usage, he is exploring how to make complex computer science concepts accessible to everyone.

4. Final Questions to Polish

To make this perfect, I just need one last thing:

  • What is the target Conference Name? (Knowing this helps me tweak the “Description” to match their specific tone—e.g., is it a “Web” conference, a “Node” conference, or a general “Tech” conference?)

User

this gets even bettern when we know that there’s this tensor library in C++: https://github.com/ggml-org/ggml

maybe we can just wrap it in node add ons

Assistant

Tool: webfetch

Assistant

This is a fantastic strategic move. 🎯

By pivoting to Node-API + GGML, you are no longer just “doing math”; you are showing how to run the same engine behind LLaMA.cpp (which runs local LLMs on MacBooks/CPUs efficiently) directly inside Node.js. This is cutting-edge and extremely high-value.

Here is the fully revised CFP. It is now a “Must-Watch” talk for anyone interested in AI, Performance, or C++.

Session Title

Running LLMs in Node.js: Wrapping GGML for High-Performance AI

(Alternative: “Beyond Python: Building a Tensor Engine in Node.js with GGML”)

Abstract

Python currently monopolizes the AI landscape, but the heavy lifting is actually done by C++ libraries like GGML—the tensor engine behind the revolutionary llama.cpp. Node.js developers shouldn’t have to spawn Python processes to access this power.

In this talk, we will build a high-performance tensor addon from scratch using Node-API. We will wrap the GGML C++ library to perform matrix multiplications and tensor operations directly in Node.js, achieving native-speed inference. You will learn how to structure ABI-stable addons, manage memory between V8 and C++, and finally prove that JavaScript is ready for the AI era.

Description / Detailed Outline

The “AI Engineering” stack is shifting. It’s no longer just about calling OpenAI APIs; it’s about running efficient, local inference. While Python has torch and numpy, Node.js has often been left behind—until now.

In this deep-dive session, we will:

  1. Deconstruct the Problem: Why is Python “fast” for AI? (Hint: It’s just C++ bindings).
  2. Meet the Tooling: Introduction to GGML (the library that powers local LLMs) and Node-API (the stable interface for V8).
  3. Live Code the Solution:
    • Setting up node-addon-api without the “V8 headers” headache.
    • Wrapping a ggml tensor operation (like matrix multiplication).
    • Benchmarking: JS implementation vs. Python/NumPy vs. Our Node+GGML Addon.
  4. Advanced Techniques: Handling heavy computation without blocking the Node.js Event Loop (using uv_queue_work or Napi::AsyncWorker).

You will walk away with a working pattern to integrate any C++ AI library into your Node.js stack, breaking the Python dependency chain.

Key Outcomes

  1. Understand the architecture of AI libraries (C++ core + high-level bindings) and replicate it in Node.
  2. Use Node-API to wrap the GGML tensor library for native-speed matrix operations.
  3. Build performant addons that don’t block the Node.js Event Loop.
  4. Create ABI-stable binaries that survive Node.js version upgrades.

Target Audience

Intermediate to Advanced Node.js engineers. No PhD in Math required—just a curiosity about how to make Node.js go fast and how modern AI libraries work under the hood.

Speaker Bio (Tailored for this talk)

Edy Silva is a Software Engineer and technical writer obsessed with performance and internals. With a background in building scalable systems at CodeMiner42 and a history of deep-diving into “black boxes” (from Brainfuck compilers to Git internals), Edy loves demystifying low-level concepts for high-level developers. He is currently exploring the intersection of local AI and web technologies, proving that you don’t need Python to run the future of software.

Why this version wins:

  1. Trend Alignment: Mentions LLaMA.cpp and Local LLMs (very hot topics).
  2. Credibility: GGML is a specific, well-respected library. Using it shows you know the landscape.
  3. Conflict: “Python monopolizes AI… Node.js is left behind.” This creates a narrative arc.
  4. Technical Depth: You aren’t just “talking about AI”; you are wrapping a tensor library.

Ready to export? Just let me know the conference name (or I can leave it generic) and I’ll finalize the text file.