The world of frontend development is a constantly spinning carousel. As soon as you've mastered one framework, the next "Next Big Thing" is already on the horizon, promising to make everything better, faster, and easier. Looking back on my own journey, I see not just a list of technologies, but a personal development—a story of pragmatism, curiosity, initial aversion, and unexpected affection.

This article is my personal retrospective. Not an ultimate "This is the best framework" sermon, but an honest reflection on the tools that have shaped my path as a developer.

In the beginning there was... SharePoint? And an Angular fork

My journey didn't start in the shiny greenfield project heaven. It began in the pragmatic world of SharePoint on-prem. Anyone who has ever had to develop here knows: it's a discipline of its own. Our tool of choice was not ordinary Angular, but a fork called SPAngular.

It was specifically optimized to integrate into the complex and sometimes stubborn architecture of SharePoint. Hand on heart: the developer experience was... functional. It was often cumbersome and far from the elegance of modern frameworks. But it got the job done. It allowed us to bring reactive UIs into an environment that wasn't really made for it.

A typical "Component" back then, simplified, might have looked like this:

// Imagine a lot of SharePoint-specific boilerplate here
var spAngularModule = angular.module("mySharePointApp", []);

spAngularModule.controller("MyWebPartController", [
  "$scope",
  "spListService",
  function ($scope, spListService) {
    $scope.items = [];
    $scope.title = "My Documents";

    function fetchDocs() {
      // Complex call to a SharePoint service
      spListService.getListItems("Document Library").then(function (data) {
        $scope.items = data;
      });
    }

    fetchDocs();
  },
]);

Looking back, it was the perfect, albeit tough, start. It taught me to work within strict boundaries and to find solutions for real business problems, even when the tools weren't ideal.

A breath of fresh air: Vue and the magic of Quasar

After the SharePoint era, switching to Vue.js felt like a liberation. Suddenly, everything was so... logical. Single-File Components (.vue files), the separation of template, script, and style in one file, immediately felt right.

Together with the Quasar Framework, it was a real power duo. Need a complex, responsive data table? q-table. A standardized dialog? q-dialog. Productivity skyrocketed. I could focus on the logic while Quasar took care of the heavy lifting in UI building.

A simple example that shows the clarity of Vue:

<template>
  <div class="q-pa-md">
    <q-btn :label="`Clicks: ${count}`" @click="increment" color="primary" />
  </div>
</template>

<script setup>
  import { ref } from "vue";

  const count = ref(0);

  function increment() {
    count.value++;
  }
</script>

<style scoped>
  .q-pa-md {
    border: 1px solid #ccc;
    border-radius: 4px;
  }
</style>

Vue showed me how much fun development can be when the framework doesn't get in your way but supports you. It was intuitive and powerful at the same time.

The great love: Svelte and syntactic sugar

And then came Svelte. Svelte wasn't just another framework, it was a revelation. The idea of not using a virtual DOM and instead generating highly optimized, pure JavaScript code at build time immediately convinced me.

But what really blew me away was the syntax. It no longer felt like learning a framework. It felt like just writing HTML, CSS, and JavaScript.

Reactivity? Just declare a variable with let.

<script>
  let count = 0;

  function handleClick() {
    count += 1;
  }

  // Derived value? No problem!
  $: doubled = count * 2;
</script>

<main>
  <button on:click={handleClick}>
    Clicked: {count} {count === 1 ? 'time' : 'times'}
  </button>

  <p>{count} * 2 = {doubled}</p>
</main>

<style>
  main {
    text-align: center;
    padding: 1em;
  }
</style>

This code is so incredibly elegant and readable. No this.setState(), no .value, no boilerplate. It's just there and it works. For me, this is the pinnacle of syntactic sugar.

But there's a catch. As much as I love Svelte, reality catches up with you. The ecosystem is smaller. You don't find a ready-made library for every problem. SvelteKit, the associated meta-framework, is fantastic, but it requires compromises. Sometimes you have to build things yourself for which there are already established solutions in other ecosystems.

From foe to friend: My deep dive into React

I admit it openly: I didn't like React at first. JSX felt to me like an unclean mix of HTML and JS. Hooks like useState seemed cumbersome compared to the magic of Svelte. Why should I write [count, setCount] when let count is enough?

But then came a project that required React with TypeScript. So I had to dive deep—and my opinion changed fundamentally.

I began to understand the genius behind function components and hooks. The unidirectional data flow architecture makes applications extremely predictable and well testable once they reach a certain complexity.

import React, { useState, useEffect } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  // A side effect that runs every time 'count' changes
  useEffect(() => {
    document.title = `You clicked ${count} times`;
  }, [count]);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

But the real game-changer for me was something else: AI support. Tools like GitHub Copilot seem to think in React. I describe a component in a comment, and Copilot spits out almost finished, idiomatic React code. Need a complex hook? The suggestions are usually spot on. This productivity boost is simply undeniable in professional everyday life. The huge ecosystem does the rest.

Conclusion: Pragmatism wins, but the heart beats for Svelte

So where am I today? I currently develop my private projects mainly with React. The reason is pure pragmatism. The combination of the gigantic ecosystem, the maturity of the framework, and the phenomenal tooling and AI support simply makes me incredibly productive.

Every framework on my journey has taught me valuable lessons:

• SPAngular taught me to solve problems under difficult conditions.
• Vue showed me the joy of a good developer experience.
• React taught me the power of structure, predictability, and a superior ecosystem.
• Svelte showed me how elegant and beautiful code can be.

My wish for the future? Broader acceptance for Svelte. I dream of a world where the Svelte ecosystem is so rich that choosing Svelte is not just a matter of the heart, but also of pragmatic reason.

Until then, for me: The best tool is the one with which you can best get the job done. And sometimes that's not the one you fell in love with at first sight.

Peace out,

— Josun