Topics
Frontend
All articles on Frontend, newest first.
Transparency: I have revised all articles afterwards with the help of AI and translated them from German with its help. The ideas, experience and positions are my own. The audio versions of the German originals are read by a synthetic voice.
React Overview: From JSX to Component Architecture
A complete walk through React the way I teach it today – from declarative rendering through the question of who owns a piece of state to the architecture of a growing application. The details of individual stops will follow later as separate posts.
Forms in React 19: Actions, useActionState and useOptimistic
React 19 makes the form the actual interface: a function as the form action, plus three hooks for the result, the pending state and instant UI feedback. This post shows how they work together – and where optimistic rendering breaks down without a clean error path.
React Server Components and Server Actions: The New Boundary
Server Components run outside the client bundle and send their result to the browser instead of their code. Server Functions move writes to the server – both are implemented by a suitable framework or bundler.
2024 5
2024 5
- React Router Data Router: The URL as the Place for StateThe data router in React Router makes the URL the point of coordination – a route loads its data via loader before rendering and writes via action, so loading logic disappears from the component body.SoftwareFrontendReact
- React Transitions: Non-Urgent Updates with useTransitionuseTransition marks updates as non-urgent and keeps React responsive during expensive or suspending renders. Plus useDeferredValue as the tool for downstream renders.SoftwareFrontendReact
- Suspense and the use Hook: Rendering as If the Data Were Already ThereInstead of managing a loading state in every component, Suspense lets you describe in a single place in the tree what appears while waiting – and the use hook lets the component below render as if the data had long arrived.SoftwareFrontendReact
- Client State vs. Server Cache: The Most Consequential Boundary in the FrontendServer data is state, but not client-owned state. Why this distinction matters, when useEffect turns into a bad cache and what a server state library takes over.SoftwareFrontendReact
- TypeScript in React: Typing Props, Hooks and EventsHow props and state become verifiable contracts – and your editor reports errors before your users see them. From interface/type through useState generics and event types to useRef and utility types.SoftwareFrontendReact
2023 1
2022 6
2022 6
- Slots, Context and Web Components in SvelteThree composition tools in Svelte 3: slots pass content in from the outside, the Context API avoids prop drilling, and custom elements make a component reusable independently of any framework.SoftwareFrontendSvelte
- Build vs. Runtime in Web ProjectsThe rendering time is decided per route. Static, dynamic and incremental models can be combined according to data shelf life, cost and failure behavior.SoftwareFrontend
- RxJS in React: Observables in the UI Data FlowRxJS does not shine everywhere in React, only where asynchronous events have to be coordinated – debounced input, canceled autocomplete requests, continuous streams. The post shows the few places where observables really pay off, and where useState is perfectly enough.SoftwareFrontendReact
- Motion, Transitions and Animations in SvelteHow Svelte ships motion declaratively and without an extra library: transition directives for fading in and out, svelte/motion for smoothly interpolated values and animate:flip for reordering lists.SoftwareFrontendSvelte
- Svelte Stores: State Outside the ComponentSvelte stores are a minimal model for state that doesn’t fit into a single component: writable, readable, derived – plus the $ shorthand that subscribes and cleans up on unmount.SoftwareFrontendSvelte
- Svelte Reactivity: The Compiler Instead of a Virtual DOMSvelte compiles components at build time into targeted DOM code instead of diffing a virtual DOM at runtime. I show the mental model, reactive assignment with $: and the classic push trap that I keep running into in projects.SoftwareFrontendSvelte
2021 3
2021 3
- State Management in React: Redux Toolkit, Lightweight Stores, MobXWhen state is truly app-wide, the tool question comes up – Redux Toolkit, a lightweight store such as Zustand or Jotai, or the reactive model of MobX. But why this choice only comes after the counter-check, and usually turns out smaller than expected.SoftwareFrontendReact
- Using Context Well: A Distribution Path, Not Secret Global StateContext solves distributing data through the tree – but not the question of who owns the state. If you confuse the two, you build a global store through the back door and cause unnecessary renders when provider values change carelessly.SoftwareFrontendReact
- Preserving and Resetting State: React and the Position in the TreeReact does not store state in the component but at its position in the render tree – once you understand that, you control preservation and reset on purpose instead of by accident.SoftwareFrontendReact
2020 2
2020 2
- How React Renders and Updates the TreeFrom the JSX element to the visible pixel – what exactly happens between a state change and the redrawn screen. Render and commit as separate phases, the comparison of two trees and why React almost always touches only a tiny part of the DOM.SoftwareFrontendReact
- JSX Precisely: The Rules Behind the MarkupA precise look at JSX – what the compiler turns it into, why curly braces hold expressions rather than statements, how attributes, children, conditions and lists work, and where beginners stumble.SoftwareFrontendReact
2019 1
2018 3
2018 3
- Micro-Frontends: Team Boundaries in the BrowserWhy the real work in micro-frontends is not the integration technique but the team split – shown with a runnable example landscape of a gateway, four applications and a component library.SoftwareFrontend
- Frontend Interfaces Are APIsWhy props, URLs, events, CSS classes and localStorage deserve the same versioning discipline as a REST endpoint – at the latest when several teams work in the same browser.SoftwareFrontend
- Angular, React and the Value of TransitionsWhether a framework switch becomes a move or a rebuild depends on how cheaply two worlds can run side by side for months.SoftwareFrontend
2017 5
2017 5
- Prototypes: The Object Model Behind JavaScript Classesclass in ES2015 is essentially syntactic sugar over prototypes: if you understand the [[Prototype]] chain, Object.create, and the new sequence, you debug this errors and shared methods with more confidence.SoftwareFrontend
- Redux as a Protocol for UI ChangesThe store is the most boring part of Redux – the value lies in the message protocol of named, serializable actions that makes UI changes traceable, testable and open to discussion.SoftwareFrontend
- JavaScript Patterns That Stayed: Modules, Higher-Order Functions, CurryingThree JavaScript patterns have survived every framework change: the module pattern for clean encapsulation, higher-order functions for functions as values and currying for specialized variants. Why they form the foundation of modern utility libraries.SoftwareFrontend
- KnockoutJS: Fine-Grained Reactivity with Observables and ComputedHow KnockoutJS solves reactivity: observables as get/set functions, computed with automatic dependency tracking and targeted DOM updates instead of a global tree comparison.SoftwareFrontend
- Tic-Tac-Toe with Minimax in ReactAn unbeatable tic-tac-toe opponent in React shows why game logic as a pure function must know nothing about rendering – and why immutable moves fit React’s model.SoftwareFrontend