Freelance JavaScript Developer in Lyon

Why JavaScript mastery changes everything

JavaScript is the most used language in the world. It's also the most misunderstood. Most developers learn a framework — React, Vue, Angular — without understanding the language underneath. It works until it doesn't.

A this that changes context depending on how it's called. A Promise that silently swallows an error. A closure that captures a mutated variable. A forEach that ignores await. These aren't framework bugs. They're language bugs. And they cost hours when you don't understand why.

My strength: I don't work on top of JavaScript. I work with it. Every Vue composable, every NestJS service, every utility I write relies on deep understanding of the language — prototypes, event loop, closures, coercion, ES modules. That mastery is what makes my code reliable.

JavaScript in 2026: a transformed language

Today's JavaScript has nothing in common with what it was 5 years ago. The language evolves every year through the TC39 process, and recent additions are significant.

Native ES modules. No more CommonJS in 2026. Import/export is native in every browser and in Node.js. Tree-shaking works without configuration. Code is declarative and statically analyzable.

Mature async/await. Promise.allSettled(), Promise.any(), top-level await, AbortController for cancellation. Async handling is clean, readable and controllable. Callback pyramids are a memory.

Powerful browser APIs. IntersectionObserver, ResizeObserver, Intl, structuredClone, navigator.sendBeacon, Web Animations API. Many npm libraries can be replaced by native APIs that are lighter and faster.

Temporal & Iterator Helpers. New date and iterator manipulation APIs are arriving natively. No more depending on moment.js or lodash for operations the language now handles on its own.

JavaScript and TypeScript: complementary, not opposed

I write most of my code in TypeScript. But TypeScript compiles to JavaScript. Types disappear at runtime. What's left is JavaScript.

Understanding the prototype chain means understanding why instanceof fails across iframes. Understanding the event loop means understanding why await inside forEach doesn't do what you expect. Understanding coercion means understanding why [] == false is true.

TypeScript catches type errors. But logic errors, timing issues, concurrency problems, memory leaks — those require deep JavaScript understanding. Both are necessary.

My approach

ES2025+ by default. No polyfills when browser support is sufficient. I use modern language APIs and target recent browsers. Code is shorter, more readable and more performant.

Zero unnecessary dependencies. Before installing an npm package, I check if a native API does the job. structuredClone instead of lodash.cloneDeep. URLSearchParams instead of qs. Intl.DateTimeFormat instead of moment. Fewer dependencies, smaller attack surface, less debt.

Performance by default. Native lazy loading, requestAnimationFrame for animations, IntersectionObserver for deferred loading, list virtualization. Performance isn't a patch added at the end — it's a design constraint from the first commit.

Node.js in production. For backends, I use Node.js with NestJS. I know the event loop patterns — when to use setImmediate vs process.nextTick, how to avoid blocking the event loop, how to handle streams for large files without blowing up memory.