What's up, everyone! Roberto Hernando here, and today I want to share a story that's given me a lot to think about. I've spent years, phew, so many years!, navigating the world of JavaScript frameworks. I started with Angular, fell in love with its structure, how it guided me step-by-step. Then, I moved to Vue.js, which won me over with its flexibility, how good it felt to write code with it. They're brutal tools, don't get me wrong, they've made my life as a developer much easier and more productive, no doubt.
But lately, I've felt this need, almost a tickle, to reconnect with the basics. You know, that semantic HTML, the CSS that handles all the styling, and that pure JavaScript, the one that runs in the browser without an extra layer of abstraction. I found myself on a project, a crazy idea that had been bouncing around in my head, where a framework as heavy as Angular or Vue felt... a bit excessive. It was like using a truck to move a chair.
The Leap to "Vanilla"
So I decided, in a burst of bravery (or maybe madness, time will tell), to launch this new project using only pure JavaScript, HTML, and CSS. No complex bundlers at first, no Virtual DOM, no magic directives. At first, the idea excited me. I thought: "This is going to be a piece of cake, I know how this stuff works!".
The reality, as often happens, was a little different. The first challenge was state management. With Angular or Vue, you have integrated solutions or very mature libraries that solve your life. Suddenly, having to think about how to pass data between different parts of the application, how to update the interface when something changes, became an interesting puzzle. At first, I resorted to something as basic as passing elements via parameters and callback functions. It worked, yes, but I quickly realized the scalability issue. For a small application, perfect. But imagine this growing... uff.
Unexpected Tangles and the Magic of the DOM
Then came DOM manipulation. I remember I used to think of the DOM as something the frameworks handled for me efficiently. And they do, mind you. But what happens when it's you who has to insert a new element, or update an attribute, or delete something? It forces you to think a lot more about efficiency. You can't just be creating nodes left and right, or updating styles massively without thinking about reflow and repaint. I started reading again about how to interact directly with the DOM, about using `createElement`, `appendChild`, `textContent`...
And that's where I realized something: the power the browser has on its own! With a little well-applied logic and understanding how the DOM works, you can do surprisingly fluid things. It's not the abstraction I was used to, it's more... raw, more direct. You have to be more conscious of what you're asking the browser to do.
Rediscovering the Web's Foundation
But the most interesting thing, and this is what made me write this post, is how much it's made me rediscover the foundation of the web. Understanding how events work, the lifecycle of an element, how JavaScript communicates with HTML and CSS, all of that becomes crystal clear when you don't have a framework in the middle. It's like I used to see the forest through a telephoto lens, and now I'm seeing it from ground level, feeling every leaf, every branch.
I've had to resort to native APIs that I'd almost forgotten existed. `fetch` for requests, `localStorage` for saving simple data, `addEventListener` for handling interactivity. And honestly, it's comforting. You feel like you control every byte, every line of code.
Is It Worth Disconnecting for a Bit?
The million-dollar question: is this journey outside of frameworks worth it? My answer, after these weeks of experimentation, is a resounding YES. I'm not saying frameworks are bad, far from it! They are fantastic tools for large and complex projects, where productivity, maintainability, and scalability are key. They are the standard solution and, in most cases, the most appropriate one.
But disconnecting once in a while, getting your hands dirty with "vanilla", gives you a perspective you can't get any other way. It reminds you that behind all those layers of abstraction, there's a browser doing its job. It teaches you to be more efficient, to think more fundamentally. It gives you a renewed appreciation for simplicity and the intrinsic power of the original web technologies.
Furthermore, I've discovered that for small projects, quick prototypes, or sites with very specific interactivity, going "vanilla" can be even faster and lighter. Fewer dependencies, lower load times, more readable code for those who don't know the specific framework. It's a matter of choosing the right tool for the right job.
Lessons Learned Along the Way
If you're thinking of doing something similar, or are just curious, here are some of my takeaways:
- State is Your Friend (and Your Enemy): Think very carefully about how you're going to manage your application's state. For medium-sized projects, perhaps a lightweight state management library like Preact's `useState` if you want something similar to React, or implementing your own pub/sub patterns can be a good option.
- DOM Efficiency is Key: Don't manipulate the DOM haphazardly. Be mindful of updates. Avoid unnecessary re-renders. Learn to use DOM APIs intelligently.
- Know Your Native Tools: `fetch` is powerful, `addEventListener` is your best friend, and `querySelector` and `querySelectorAll` will make your life much easier. Don't underestimate the power of native JavaScript.
- CSS Still Reigns Supreme: Just like with JS, having a good understanding of pure CSS gives you incredible control. Sometimes, the simplest solution is a well-applied class or a CSS property.
- Simplicity is Power: Sometimes, the simplest is the most elegant and maintainable. You don't always need the latest technology to solve a problem.
Final Thoughts and Next Steps
This journey has refreshed my memory and given me new ideas. I don't think I'll abandon frameworks completely; my work often requires them, and I love their advantages. But I do appreciate what's underneath a lot more. I feel like a more complete developer, with a deeper understanding of how the web works.
So, if you've been doing this for a while and feel that spark of curiosity, I encourage you to challenge yourself. Take on a small project, or a specific feature, and try to do it without frameworks. You'll be surprised how much you can learn and rediscover. At the end of the day, the web is a wonderful collection of technologies, and understanding them at their core is a gift for any developer.
I hope this anecdote has been interesting for you! You know, you always learn something new, even when you think you know it all. Catch you in the next post!