JSDay 2025: Unraveling Memory Leaks and Dependency Management

While there were tons of great talks, some sessions, to me, absolutely deserved some spotlight tackling those frustrating problems we all face but rarely talk about: memory leaks and dependency management nightmares.

Daniel Danielecki: The Memory Leak Whisperer

The first standout talk came from Daniel Danielecki, who works as a Senior Frontend Engineer at ABN AMRO. His session transformed what could have been a dry technical topic into an engaging exploration of one of JavaScript’s most persistent challenges.

Understanding Memory Management Fundamentals

Daniel broke down JavaScript’s memory architecture, clearly explaining the crucial differences between stack and heap memory:

• Stack: Fixed size, very fast access, primarily used for function calls, local variables, and return addresses
• Heap: Flexible and large, slower due to dynamic allocation, used for objects, arrays, closures, and other complex data structures

Memory Leaks Demystified

Daniel then got into what actually causes memory leaks, and he broke it down in a way that was refreshingly straightforward:

• Your code allocates memory (like creating objects) but never lets go of it
• In JavaScript, if something still references an object, it sticks around even if you’re done with it
• The garbage collector gets confused and can’t clean up the mess

He showed this slide about how memory leaks get progressively worse:

1. First, your app just uses more memory than it should (annoying but workable)
2. Then performance starts tanking as memory bloats
3. Finally, crash city - your app runs out of memory completely

Detective Tools I Didn’t Know We Had

The most useful was when Daniel demonstrated real debugging techniques. He pulled up Chrome DevTools and showed us exactly where to click in the Memory tab to:

• Take heap snapshots
• Compare memory usage between different points in time
• Find those sneaky objects that should have been garbage collected

He showed this incredible visualization called a reference chain diagram that maps out how objects reference each other. Seeing the exact path from the global window object down to leaked objects was very expressive, and also show and suggested some tools that can help us detect memory leaks head of time, like Fuite a CLI tool for finding memory leaks in web apps.

Carmen’s Dependency Therapy Session

Carmen Huidobro’s talk on dependency management. Carmen’s a Developer Educator at Directus, and her session title “Untangling Your Dependencies” perfectly captured what turned out to be a therapy session for dependency-traumatized developers 😁.

Carmen opened with a story about trying to update a React Native project, thinking it would be a quick version bump from 0.55.4 to 0.74.1. What should have been a simple update turned into a nitghmare of error after errors:

• React throwing errors, so she updated React
• Which broke React DOM, so that needed updating
• Which created conflicts with other dependencies
• Which forced updates to those dependencies
• Which broke even more things

“I kept going until I felt like a cable box” she said, which perfectly captured that dependency update spiral we’ve all experienced.

The Dependency Web Carmen Untangled

Carmen did a fantastic job explaining the tangled web of different dependency types. What I found super helpful was how she distinguished between:

• Direct dependencies (the ones you actually asked for)
• Dev dependencies (only for development)
• Peer dependencies (the “you need to have this already” dependencies)
• Transitive dependencies (the surprise party guests - dependencies of your dependencies)

She showed this visualization of interconnected packages that to help realize how complex modern JavaScript projects really are.

Tool Recommendations

• She demonstrated Yarn interactive to analyze update options
• Showed how npm why helps trace why random packages appear in your project
• Introduced Knip for finding unused dependencies

No silver bullets here, just practical options for different scenarios.

Carmen’s “8 Lessons”

The heart of Carmen’s talk was her framework of 8 lessons she’s learned from years of dependency battles. What made these great wasn’t just the lessons themselves but how she connected them to her knitting hobby. Carmen cleverly wove knitting metaphors throughout her presentation to make complex dependency concepts more relatable:

1. “Weaving the dependency landscape” - Take time to understand what you’re working with before diving in.
2. “You’re one stitch in a large chain” - Remember you’re part of an ecosystem, and your choices affect others.
3. “Untangling the inevitable knots” - Break big problems down into smaller, more manageable chunks.
4. “Picking the right knitting needles” - Choose the right tools for specific problems.
5. “One big stitch in time saves many” - Prioritize important updates.
6. “Making experimental stitches” - Test changes in isolation.
7. “Knowing where to draw lines” - Set boundaries for what dependencies you’ll accept.
8. “When to let go” - Know when to abandon approaches that aren’t working.

Her closing quote hit hard: “Software is never finished. Only abandoned.” She attributed it to “Leonardo da Vinci, probably, if he were doing this today,” which got a big laugh. But it also perfectly captured the endless nature of dependency management.

The Rest of JSDay

While these two talks were my personal highlights, the conference had plenty of other gems:

Matteo Collina’s “State of Node.js 2025” was packed as always, with everyone eager to hear about the performance improvements in Node.js 22. I was particularly interested in the new security features he outlined.

I also caught Małgorzata Janeczek’s “JavaScript is weird. MythBusters special”

// pov: Javascript perfectly makes sense
console.log(typeof NaN); // "number" 🤯
console.log(NaN === NaN); // false 😵
console.log("5" - 1); // 4, but "5" + 1
console.log("5" + 1); // 51 of course

which had the whole room laughing at JavaScript’s quirky behaviors while actually explaining why they happen.

And another very interesting one was “Compiling JavaScript ahead of time” by Oliver Medhurst who is the creator of Porffor, an ahead-of-time JavaScript compiler, was started by Oliver in June 2023 as a side project and he has now been working on it full-time since August 2024! Check it out, and if you’d like to contribute, it’s an open source project.

JSDay 2025 reinforced something important: even as JavaScript and its ecosystem grow more complex, understanding fundamentals like memory management and smart dependency strategies matters more than ever. These aren’t just academic concerns but practical skills that make the difference between maintainable applications and development nightmares.