The Creator

Giovanni Marianne

Creator of DOM Helpers Library

Origins: A Vanilla JavaScript Passion

DOM Helpers Core was born from a deep passion for Vanilla JavaScript and a desire to preserve a direct, hands-on relationship with the DOM. My journey began with exploring modern frameworks like React and Vue.js—powerful tools that have transformed the way we build web applications.

Over time, I realized that what truly drew me to these frameworks was not the abstraction itself, but one core idea above all else: reactivity. However, as I went deeper into framework-driven development, I slowly began to lose my connection with plain Vanilla JavaScript.

Working behind layers of abstraction distanced me from how the DOM actually works. Native Web APIs started to feel unfamiliar, and fundamental concepts were no longer part of my day-to-day thinking. Instead of strengthening my understanding of the platform, too much was being abstracted away from it.

The Framework Dilemma

While frameworks provided incredible reactivity, they came with costs that grew harder to ignore:

The Abstraction Problem:

• Too much magic happening behind the scenes
• DOM manipulation hidden away from view
• The real mechanics of the DOM became distant and abstract
• Skills for direct DOM manipulation began to fade

The Spoon-Feeding Effect:

• Less logical understanding of what was actually happening
• Heavy abstractions that obscured fundamental JavaScript
• Gradual forgetting of how to truly work with the DOM
• Dependency on framework-specific patterns

The Lost Connection: Working with the DOM in the vanilla way was more exciting—it provided clarity, control, and deep understanding. Every action was intentional. Every result was traceable. JavaScript skills were constantly strengthened through direct manipulation. But there was one critical challenge: keeping the UI in sync with state changes.

The Realization

This synchronization problem—and only this problem—was what made frameworks necessary. Everything else about vanilla JavaScript development felt right. The question became clear:

What if we could solve just this one problem without sacrificing everything else?

The Vision

The creator envisioned a solution that would:

✅ Provide reactivity without abstraction
✅ Integrate into any project structure
✅ Preserve direct DOM manipulation
✅ Strengthen JavaScript fundamentals
✅ Work with any coding style

The result: DOM Helpers Reactive—a plug-and-play reactivity system that adapts to you, not the other way around.

Design Philosophy

Plug and Play, Not Restructure

Unlike frameworks that demand architectural compliance, DOM Helpers Reactive simply slots into existing projects:

• Plain JavaScript project? Load the script tag. Play with reactivity.
• jQuery codebase? Load the script tag. Reactivity works alongside jQuery.
• Custom architecture? Load the script tag. Keep your structure.

No migration. No refactoring. No forced patterns. Just reactivity.

Freedom of Style

DOM Helpers Reactive respects your preferences:

• Write imperative code if you prefer
• Write declarative code if you prefer
• Mix both styles freely
• Use your own naming conventions
• Structure your code your way

The library provides reactive power without dictating how you use it.

Preserve the Connection

The creator's core belief: developers should never lose touch with the DOM. Every abstraction in DOM Helpers Reactive is transparent and optional. You can always drop down to direct manipulation. You always know what's happening under the hood.

The DOM Helpers Ecosystem

DOM Helpers Core: The Foundation

DOM Helpers Core— is the main module of the DOM Helpers library. Core provides powerful, declarative DOM manipulation features with a rich set of capabilities. It represents my vision for what vanilla DOM manipulation should feel like: expressive, intuitive, declarative and powerful.

DOM Helpers Reactive: Independent Yet Integrated

DOM Helpers library provides also a reactivy system The reactive system is completely independent. It stands alone as a full-featured reactivity solution. You can use it without Core, and it works beautifully on its own.

But when combined with Core, something remarkable happens: you get reactivity plus powerful declarative DOM manipulation.

The synergy creates an environment where:

• State changes automatically update the UI (Reactive)
• DOM manipulation is expressive and elegant (Core)
• Everything works in pure vanilla JavaScript
• No framework lock-in
• No heavy abstractions
• Complete control

Two Modes of Power

Using Reactive Alone:

• Powerful reactivity features
• State management
• Automatic UI synchronization
• Minimal footprint
• Works with any DOM manipulation approach

Using Reactive + Core Together:

• All reactivity features
• Rich declarative DOM manipulation
• Seamless integration between state and DOM
• Incredible power and expressiveness
• Still pure vanilla JavaScript

The Mission

DOM Helpers Reactive exists to prove that you don't need to abandon vanilla JavaScript to have modern reactivity. You don't need framework abstractions. You don't need to give up control. You don't need to forget how the DOM works.

You just need the right tool—one that enhances rather than replaces, one that empowers rather than abstracts, one that respects your skills rather than hiding them.

For Developers Who:

• Love vanilla JavaScript
• Want to understand what's happening
• Prefer control over convenience
• Value learning over magic
• Need flexibility over structure
• Want reactivity without compromise

Looking Forward

The vision continues to evolve, guided by the same principles:

1. Keep it simple - Complexity should be optional, not mandatory
2. Stay transparent - Developers should always understand what's happening
3. Remain flexible - Never force architectural decisions
4. Preserve fundamentals - JavaScript skills should grow, not atrophy
5. Deliver power - Provide capabilities that rival any framework

DOM Helpers Reactive isn't just a library—it's a statement that vanilla JavaScript, when properly empowered, remains the most exciting and capable way to build for the web.

The Creator's Note

"I built this because I missed the DOM. I missed knowing exactly what was happening. I missed the excitement of direct manipulation. But I didn't want to give up manual dom manipulation. So I built something that let me have both—and I built it so you could have both too, on your terms, in your style, in your projects."

— Giovanni S. Marianne Creator of DOM Helpers Reactive

DOM Helpers: Bringing power back to vanilla JavaScript, one feature at a time.