Let's talk tech

Among the most important "skill" to master is within the paradigm of declarative programming.

Most reactivity is based on declarative principles, to bring reliable and predictable as well as readability.

This is one of the biggest changes from the old, imperative, frontend.

When handling reactivity different aspect of concurrency is very often in play. Whether it's perceived concurrency or proper multi threading, we face race conditions and timing issues where a solid foundation in concurrency theory is important.

We mostly think in events and subscription patterns. Our flow of programs are almost always determined by user actions. We often apply common event driven patterns to achieve maintainable and scalable architecture.

When we dive a little deeper into the Modern Frontend, one of the very important but complex parts is dependency management. Within dependency management, graph theory is key to understand complex concepts such as phantom dependencies and dopplegangers.

Important techniques like chunking and tree shaking are also founded in graph theory.

Of course data structures is a big part of a data consuming frontend application. Good and well scoped data structures lead to better and more predictable software.

Achieving the ability to deploy fast and frequently requires high confident in the software. This confidence can be achieved through well written unit tests.

In the frontend unit tests are more complex than known from a common backend application. The interface of consumption is often a user, a keyboard and a mouse. To maintain trustworthy tests, we need to follow same interface when testing our code. This makes it very important to understand what and how to test, to achieve the goal: If behaviour breaks, the test should break. If behavior is not broken, the test should not break either.

Type theory is of course a given when working with software especially at scale. But this is not how it used to be in the old frontend.

When we build scalable architectures it often involves heavy use of generics and general polymorphism.

We've tried it over and over again, and know how much effort is saved by making code generic but more importantly modular and replaceable.

Transpiling and compiling has become integrated parts of the modern frontend. Bundling and static site generation are also sharing "interests" with compilers.

And finally frontend is of course also about making pretty and performant user interfaces. It requires an visual eye for details and a good degree of perfection to master this area.

Now top that up with sophisticated design and style systems, integrated within the reactive, chunked page setup, and you actually get challenged!

• react, solid, svelte, vue, angular

• nextjs, gatsby, nuxtjs, sveltekit, solidstart

• RxJS

• Marbles

• SignalR

• Testing library

• Jest

• Marble testing

• Vitest

• Rush Stack

• Heft

• Api extractor

• Typescript

• Vite