Techneschen Blog | Olivier Page

Claude Code iwwer de ganze Software Life Cycle

Thu, 08 Oct 2026 00:00:00 GMT

Claude Code ass dem Anthropic säin agentescht Coding-Tool, dat an Ärem Terminal leeft an Iech bei all Schrëtt vum Software Life Cycle begleede kann. Dëse Guide verbënnt déi siwe Phasen — vun den Ufuerderunge bis zum Betrib — mat de konkrete Prompts, der Configuratioun an den Diagrammer, déi en Expert-Entwéckler wierklech benotzt.

Den SDLC a siwe Phasen

All Phas huet eng Aufgab fir den Agent. Bei all Schrëtt entscheet Dir, wat Dir ofgitt a wat Dir selwer iwwerpréift. Hei ass de Loop, duerno all Phas am Detail.

flowchart LR
    R[1. Requirements] --> P[2. Planning]
    P --> D[3. Design]
    D --> I[4. Development]
    I --> T[5. Testing]
    T --> C[6. CI / CD]
    C --> O[7. Operations]
    O -. feedback loop .-> R

1. Ufuerderungen

De Claude mécht aus rouen Notizen e strukturéierte Backlog a weist virun allem drop hin, wat zweedeiteg ass, ier et zu engem Bug gëtt. Gitt him d'Quell an e strenge Output-Format:

Turn notes/requirements.md into a structured backlog:
- Rewrite each functional requirement as "As a <role>, I want <goal>,
  so that <value>".
- List non-functional requirements (security, performance, availability)
  as separate items.
- Flag anything ambiguous or missing as an open question.
- Output a markdown table: ID | Requirement | Priority | Acceptance criteria.

2. Planung an Estimatioun

Brécht Epics an Dages-Aufgaben, no Ofhängegkeet geuerdnet. Den Agent ass gutt am Sequenzéieren, well en d'Kopplung tëscht Dateien a Servicer gesäit:

Break this epic into tasks no larger than one day, ordered by dependency.
For each task give: title, affected files, effort (S/M/L), and definition
of done. Start with the riskiest task.

Epic: migrate order checkout from REST to async messaging.

Fir grouss Ännerungen fänkt am Plan-Modus un, sou datt de Claude d'Approche an d'Aufgabelëscht virschléit, ier en Dateien beréiert. Liest den Plan no a passt en un, da loosst en ausféieren. De Plan gëtt Äre Gantt:

gantt
    title Sprint plan for checkout migration
    dateFormat  YYYY-MM-DD
    section Design
    ADR & event schema      :a1, 2026-10-08, 2d
    section Build
    Order service producer  :a2, after a1, 3d
    Consumer + DLQ          :a3, after a2, 3d
    section Test
    Contract tests          :a4, after a3, 2d
    section Ship
    Canary + rollout        :a5, after a4, 2d

3. Architektur an Design

Frot de Claude, e Systemdiagramm ze produzéieren, a widerspriecht him dann. En kritiséiert gär d'Kopplung, Single Points of Failure an d'Konsistenz-Kompromisser:

flowchart TD
    subgraph Client["Client"]
        A[Web App]
    end
    subgraph Edge["Edge"]
        B[API Gateway]
    end
    subgraph Core["Core services"]
        C[Order Service]
        D[Payment Service]
    end
    subgraph Data["Data"]
        E[(Order DB)]
        F[(Payment DB)]
    end
    A --> B
    B --> C
    B --> D
    C --> E
    D --> F
    C -. async events .-> D

Halt d'Resultat an engem Architecture Decision Record fest, sou datt déi nächst Sessioun — Mënsch oder Agent — mam selwechte Kontext ufänkt:

# ADR-007: Move checkout to async messaging

## Status
Proposed

## Context
Checkout currently calls the payment service synchronously over REST.
Under peak load this couples availability and pushes latency past SLO.

## Decision
Publish an OrderPlaced event to the broker; the payment service consumes
it and publishes PaymentCaptured. Use an outbox pattern for reliability.

## Consequences
- Lower coupling and better tail latency.
- New failure modes need a dead-letter queue and idempotent consumers.

4. Entwécklung

E produktiounsreif CLAUDE.md ass de gréissten Hebel fir konsistent Resultater. Et codéiert Build-Kommandoen, Architektur, Sécherheetsreegelen a Stil, sou datt all Sessioun vun Äre Standards ausgeet:

# CLAUDE.md

## Build & test
- `dotnet build` — build the solution (src/Orders.sln)
- `dotnet test` — run the xUnit suite
- `dotnet format` — apply code style from .editorconfig
- `dotnet ef migrations add <Name>` — add an EF Core migration

## Architecture
- `src/Orders.Api` — HTTP API (ASP.NET Core minimal APIs)
- `src/Orders.Application` — use cases, no I/O
- `src/Orders.Infrastructure` — EF Core, Azure Service Bus
- `src/Orders.Domain` — entities and value objects, no dependencies
- `tests/Orders.UnitTests` — one xUnit project per layer

## Security rules (never break these)
- Never log or commit secrets, tokens, or appsettings.Production.json
- Use parameterized queries; never concatenate SQL strings
- Do not add a package without mentioning it in the summary

## Testing
- New code ships with unit tests (xUnit + FluentAssertions)
- Mock external calls (HTTP, DB) — no network in unit tests
- Integration tests use Testcontainers

## Style
- Enable nullable reference types in every project
- Prefer records for DTOs and primary constructors for services
- Comments only explain "why", never "what"

Widderhuelbar Routinen ginn zu Skills. Schreift d'Prozedur eemol a léist se iwwer den Numm aus:

---
name: write-tests
description: Add unit tests for a changed class following project conventions.
---

1. Read the diff and find every public method that changed.
2. Write an xUnit test (with FluentAssertions) for the happy path plus one edge case each.
3. Mock dependencies with NSubstitute — no real I/O.
4. Run `dotnet test` and fix anything red before reporting.

Schwéier, isoléiert Aufgabe ginn un Subagents mat engem enken Toolset, fir d'Haaptsessioun fokusséiert a bëlleg ze halen:

---
name: code-reviewer
description: Expert reviewer for pull requests.
tools: Read, Grep, Bash
model: sonnet
---

Review the diff for correctness, performance, and security.
Return findings ordered by severity (blocker, major, minor).

Heefeg Prompts ginn zu Slash Commands, an $ARGUMENTS mécht se komposéierbar am ganze Code:

---
description: Generate unit tests for a given file.
---

Read the file at $ARGUMENTS and its dependencies. Write an xUnit
test at `tests/` covering the public methods, the happy path, and
one failure case. Run `dotnet test` and fix anything red.

5. Tester

Maacht Test-driven Development als enk Loop: Dir schreift den Test, deen feeler, de Claude implementéiert de minimale Fix, an d'Suite ass de Kontrakt. Iteréiert bis gréng, da refaktoréiert:

flowchart LR
    W[Write failing test] --> R[Claude implements]
    R --> G{Suite green?}
    G -- No --> F[Claude fixes]
    F --> G
    G -- Yes --> RF[Refactor & review]
    RF --> W

Act as the implementer. I have written this failing xUnit test:

<test code>

Implement the minimal change that makes it pass. Do not add features
the test does not require. Run `dotnet test` and confirm green.

Ier Dir merged, gitt den Diff un e Review-Subagent. E kontrolléiert Richtegkeet, Sécherheet a Konventiounen, ouni Är eegen Opmierksamkeet ze verbrennen.

6. CI/CD a Release

De Claude Code gehéiert an de Pipeline. E Merge geschitt eréischt no Lint, Tester, Sécherheetsscan an automatescher Review — dann Deployment mat Smoke-Test a Rollback-Wee:

flowchart LR
    PR[Pull request] --> L[Lint & typecheck]
    L --> T[Unit tests]
    T --> S[Security scan]
    S --> R[Claude Code review]
    R --> M[Merge]
    M --> D[Deploy]
    D --> P[Smoke tests]
    P --> V{Pass?}
    V -- No --> RB[Rollback]
    V -- Yes --> O[Release]

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 8.0.x
      - run: dotnet restore
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: >
            Review the changes in this pull request. Summarize the
            behaviour change, flag correctness and security issues,
            and post inline comments on the files.

Den Headless-Modus mécht den Agent skriptbar, sou datt Release-Checklisten an eemoleg Migratiounen aus dem Terminal oder engem Workflow-Schrëtt lafen:

claude -p "Run the release checklist and report failures" \
  --output-format stream-json \
  --permission-mode acceptEdits

Hooks setzen d'Politik um Tool-Niveau duerch a blockéieren geféierlech Kommandoen, ier se lafen:

#!/usr/bin/env bash
# .claude/hooks/guard.sh — block destructive commands
set -euo pipefail

read -r INPUT

if echo "$INPUT" | grep -qE 'rm -rf|git push --force|DROP TABLE'; then
  echo "Blocked a potentially destructive command." >&2
  exit 2
fi

exit 0

7. Betrib an Ënnerhalt

Bei On-Call verbënnt de Claude mat dem Code, der Datebank an dem Ticketing-System iwwer MCP, da frot en, en Incident ze triagen, wéi e Senior-Ingenieur et géif:

flowchart LR
    CC[Claude Code] <-->|MCP| GH[GitHub MCP]
    CC <-->|MCP| DB[(Database MCP)]
    CC <-->|MCP| TK[Ticketing MCP]

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost:5432/app"]
    }
  }
}

Wann d'Servere vun der Stang net duerginn, baut Ären eegene mam offiziellen SDK. E Server exponéiert typiséiert Tools, déi de Claude opriffe kann:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import { z } from 'zod'

const server = new McpServer({ name: 'ticketing', version: '1.0.0' })

server.tool(
  'search_tickets',
  'Search support tickets by keyword',
  { query: z.string().describe('Search term') },
  async ({ query }) => {
    const rows = await db.tickets.find({ subject: { $like: `%${query}%` } })
    return { content: [{ type: 'text', text: JSON.stringify(rows, null, 2) }] }
  },
)

const transport = new StdioServerTransport()
await server.connect(transport)

Zum Schluss

Behandelt de Claude Code als Teammember iwwer de ganzen SDLC: kloert Ufuerderungen, sequenzéiert de Plang, iwwerpréift den Design, implementéiert an testt, séchert de Merge a triagéiert an der Produktioun. D'Experten, déi am meeschten erauskréien, sinn déi, déi de Kontext definéieren, hir Standards codéieren an op all Entscheidungspunkt am Loop bleiwen.

Angular fir Experten: modern Architektur an déi neist Features

Wed, 02 Sep 2026 00:00:00 GMT

Angular huet sech an de leschte Versiounen däitlech verännert. Wann Dir Är lescht App mat NgModule, *ngIf a @Injectable-Konstruktore geschriwwen hutt, ass vill dovu mëttlerweil fakultativ. Dëse Guide weist, wéi e modernen, expertniveau Angular-Code haut ausgesäit.

flowchart TD
    C[Component] --> S[Signals]
    C --> T[Template]
    T --> CF[Control flow]
    T --> DF[Defer]
    C --> I[inject services]
    I --> H[HttpClient / resource]
    C --> R[Router]
    R --> LZ[Lazy loading]
    R --> FG[Functional guards]

Standalone-Komponenten

NgModule ass elo fakultativ. Komponenten, Direktiven a Pipes deklaréieren hir eege Ofhängegkeeten iwwer imports, an d'App gëtt mat provide*-Funktiounen verdrout.

import { Component, input, output } from '@angular/core'

@Component({
  selector: 'app-user-card',
  standalone: true,
  imports: [],
  template: `
    <div class="card">
      <h3>{{ name() }}</h3>
      <button (click)="select.emit(id())">Select</button>
    </div>
  `,
})
export class UserCardComponent {
  readonly id = input.required<number>()
  readonly name = input.required<string>()
  readonly select = output<number>()
}

Signals: de Kär vun der Reaktivitéit

Signals ersetzen de gréissten Deel vum alen ChangeDetectionStrategy-Zeremoniell. Si sinn d'Fundament fir Inputs, Outputs an ofgeleet Zoustand.

import { Component, computed, effect, signal } from '@angular/core'

@Component({ /* ... */ })
export class CounterComponent {
  readonly count = signal(0)
  readonly double = computed(() => this.count() * 2)

  constructor() {
    effect(() => console.log('count is now', this.count()))
  }

  increment() {
    this.count.update((n) => n + 1)
  }
}

Modernt Zwee-Wee-Binding benotzt model(), an Queryen benotzen viewChild / contentChild, déi Signals zeréckginn:

readonly value = model(0)
readonly list = viewChild.required(ElementRef)

Fir asynchron Daten ersetzt resource() den manuelle « Lued-Zoustand + Fetch » -Danz:

import { resource, signal } from '@angular/core'

export class UserListComponent {
  readonly search = signal('')

  readonly users = resource({
    request: () => ({ q: this.search() }),
    loader: ({ request }) => fetchUsers(request.q),
  })
}

resource() stellt value(), status(), isLoading() an error() zur Verfügung, sou datt den Template op all Lued-Phas reagéiere kann.

Kontrollfloss a verspéit Lueden

Déi al strukturell Direktiven *ngIf / *ngFor sinn elo agebaute Bléck, déi sech wéi einfachen Template liesen.

@if (user(); as u) {
  <p>Hello {{ u.name }}</p>
} @else {
  <p>Not signed in</p>
}

@for (item of items(); track item.id) {
  <li>{{ item.label }}</li>
} @empty {
  <li>Nothing here</li>
}

@switch (status()) {
  @case ('ok') { <span>OK</span> }
  @case ('error') { <span>Error</span> }
  @default { <span>Unknown</span> }
}

Lued schwéier Deeler nëmmen, wann néideg, mat @defer:

@defer (on viewport) {
  <app-heavy-chart />
} @placeholder {
  <p>Chart appears here…</p>
} @loading (minimum 200ms) {
  <p>Loading…</p>
}

Zoneless Ännerungsdetektioun

Dir kënnt elo komplett op Zone.js verzichten. Stellt d'Zoneless-Detektioun beim Bootstrap zur Verfügung a loosst d'Signals dem Angular soen, wat sech geännert huet.

import { bootstrapApplication } from '@angular/platform-browser'
import { provideZonelessChangeDetection } from '@angular/core'

bootstrapApplication(AppComponent, {
  providers: [provideZonelessChangeDetection()],
})

Zoneless heescht manner Laufzäit-Overhead a manner Iwwerraschungen — awer et erwaart signalbaséierten Zoustand an OnPush-frëndleche Code.

Dependency Injection mat inject()

D'Konstruktor-Injektioun gëtt duerch d'inject()-Funktioun ersat, déi de Code kuerz hält a gutt mat funktionellen APIen zesummespillt.

import { inject, Injectable } from '@angular/core'

@Injectable({ providedIn: 'root' })
export class UserService {
  readonly api = inject(ApiService)
  readonly users = this.api.getUsers()
}

Routing: funktionell Guards a Lazy Loading

Guards, Resolvers an Interceptors sinn elo einfach Funktiounen.

import { inject } from '@angular/core'
import type { CanActivateFn } from '@angular/router'
import type { HttpInterceptorFn } from '@angular/common/http'

// guard
export const authGuard: CanActivateFn = () => inject(AuthService).isLoggedIn()

// interceptor
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const token = inject(AuthService).token()
  return next(req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }))
}

Lazy Loading geschitt pro Route a pro Komponent:

export const routes: Routes = [
  {
    path: 'admin',
    loadChildren: () =>
      import('./admin/admin.routes').then((m) => m.adminRoutes),
  },
  {
    path: 'profile',
    loadComponent: () =>
      import('./profile/profile.component').then((m) => m.ProfileComponent),
  },
]

HTTP mat Signals

HttpClient funktionéiert direkt mat Signals, sou datt e GET e reaktive Wäert ka sinn.

import { HttpClient, provideHttpClient } from '@angular/common/http'

@Injectable({ providedIn: 'root' })
export class UserService {
  private readonly http = inject(HttpClient)

  readonly users = this.http.get<User[]>('/api/users')
}

Fir requestbaséiert Lueden, dat schonn an engem Observable lieft, wéckelt rxResource() den HttpClient direkt an:

import { inject, Injectable, signal } from '@angular/core'
import { HttpClient } from '@angular/common/http'
import { rxResource } from '@angular/core/rxjs-interop'

@Injectable({ providedIn: 'root' })
export class UserService {
  private readonly http = inject(HttpClient)
  readonly query = signal('')

  readonly users = rxResource({
    request: () => this.query(),
    loader: ({ request }) => this.http.get<User[]>(`/api/users?q=${request}`),
  })
}

rxResource() stellt déi selwecht value(), status(), isLoading() an error()-Signals zur Verfügung wéi resource().

State Management mat NgRx

Fir globalen Zoustand bitt NgRx e signalbaséierte SignalStore, deen an de moderne zoneless, signalgedriwwene Modell passt.

import { computed } from '@angular/core'
import { patchState, signalStore, withComputed, withMethods, withState } from '@ngrx/signals'

interface CartState {
  items: CartItem[]
}

export const CartStore = signalStore(
  withState<CartState>({ items: [] }),
  withComputed(({ items }) => ({
    count: computed(() => items().length),
    total: computed(() => items().reduce((sum, item) => sum + item.price, 0)),
  })),
  withMethods((store) => ({
    addItem(item: CartItem) {
      patchState(store, { items: [...store.items(), item] })
    },
    removeItem(id: string) {
      patchState(store, { items: store.items().filter((item) => item.id !== id) })
    },
  })),
)

Stellt de Store zur Verfügung an injizéiert en an de Komponent:

@Component({
  selector: 'app-cart',
  standalone: true,
  providers: [CartStore],
  template: `
    <p>{{ cartStore.count() }} items — {{ cartStore.total() | currency }}</p>
    <button (click)="cartStore.addItem({ id: '1', price: 10 })">Add</button>
  `,
})
export class CartComponent {
  readonly cartStore = inject(CartStore)
}

Fir Kollektiounen liwwert withEntities eng normaliséiert, asazbereet Form:

import { setAllEntities, withEntities } from '@ngrx/signals/entities'

export const UserStore = signalStore(
  withEntities<User>(),
  withMethods((store) => ({
    load(users: User[]) {
      patchState(store, setAllEntities(users))
    },
  })),
)

Fir komplex asynchron Orchestréierung exceléiert de klassesche @ngrx/effects ëmmer nach; createEffect mécht aus Action-Stréim Säiteneffekter.

@Injectable()
export class UserEffects {
  private readonly actions$ = inject(Actions)
  private readonly users = inject(UserService)

  loadUsers$ = createEffect(() =>
    this.actions$.pipe(
      ofType(loadUsers),
      switchMap(() => this.users.getAll().pipe(
        map((users) => loadUsersSuccess({ users })),
      )),
    ),
  )
}

SignalStore ass de modernen Standard fir déi meescht Zoustand; gräift op @ngrx/effects zeréck, wann Dir fortgeschratt asynchron Flëss braucht.

Eng modern Architektur

Eng propper, skaléierbar Angular-App gesäit haut ongeféier sou aus:

Alles standalone — keen NgModule, explizit imports.
Signals fir den Zoustand — signal/computed/effect plus model/input.
inject() iwwerall — komponéierbar, testbar Servicer.
Zoneless + OnPush — virauszeseen Ännerungsdetektioun.
Funktionell Guards/Interceptors — eng dënn, typiséiert Routing-Schicht.
Lazy-Routen + @defer — séieren initiale Lueden.
Ordner no Feature — no Domain gruppéieren, net no Schicht.

src/app/
  auth/
    login.component.ts
    auth.service.ts
    auth.guard.ts
  orders/
    order-list.component.ts
    order.service.ts
  shared/
    ui/
      button.component.ts

Versiounsgeschicht

Eng kompakt Chronologie vun de grousse Versiounen an hire Kärännerungen.

Versioun	Release	Breaking Changes / Neiegkeeten
2.0	Sept 2016	Komplett Neischreifung vun AngularJS: TypeScript, Komponenten, DI
4.0	Mäerz 2017	Versiounssprong (keng 3.x); neien `HttpClient`; Animatiouns-Package
5.0	Nov 2017	Build Optimizer; `HttpClient` stabil
6.0	Mee 2018	Angular CLI Workspaces; RxJS 6; tree-shakable Providers
7.0	Okt 2018	CLI Prompts; CDK Drag & Drop a Virtual Scrolling
8.0	Mee 2019	Ivy (Virschau); Differential Loading; dynameschen Import fir Lazy-Routen
9.0	Feb 2020	Ivy standardméisseg aktivéiert; TestBed Verbesserungen
10.0	Juni 2020	TypeScript 3.9; neien Datumsberäich-Picker
11.0	Nov 2020	Hot Module Replacement; méi streng Typpen
12.0	Mee 2021	View Engine ewechgeholl; modern Sass API; Strict Mode standardméisseg
13.0	Nov 2021	IE11 Ënnerstëtzung gestrach; RxJS 7; keng `entryComponents` méi
14.0	Juni 2022	Standalone-Komponenten (Virschau); typiséiert reaktiv Formulairen; `inject()`
15.0	Nov 2022	Standalone stabil; `NgModule` fakultativ; Directive Composition API
16.0	Mee 2023	Signals (Virschau); esbuild Dev-Server; erfuerderlech Inputs
17.0	Nov 2023	Agebaute Kontrollfloss; `@defer`; Standalone standardméisseg
18.0	Mee 2024	Zoneless (experimentell); `@let` Variabelen; Signal Inputs/Outputs
19.0	Nov 2024	Signals stabil; `resource()`/`rxResource()`; `linkedSignal`
20.0	Mee 2025	Zoneless Ännerungsdetektioun stabil (standardméisseg fir nei Apps)
21.0	Nov 2025	Signal- a Zoneless-Verfeinerungen

Zum Schluss

De Wiessel op Signals, Standalone-Komponenten an Zoneless-Detektioun ass dee gréissten Ëmbroch an der Geschicht vum Angular. En ze adoptéieren — Signals fir den Zoustand, inject() fir Ofhängegkeeten, funktionell Routing a Lazy Loading — gëtt Iech méi kleng Bundles, manner Ännerungsdetektiouns-Bugs an Code, dee vill méi einfach ze verstoen ass.

Design Patterns fir Entwéckler: e frëndleche Guide

Wed, 02 Sep 2026 00:00:00 GMT

Design Patterns si widderverwendbar Léisunge fir heefeg Problemer. Si si keng Copy-Paste-Schabloune — si sinn Iddien, déi een un seng eege Situatioun upasst. Dëse Guide geet duerch zéng vun de nëtzlechsten, gruppéiert no hirer Roll.

flowchart TD
    A[Design patterns] --> B[Creational]
    A --> C[Structural]
    A --> D[Behavioral]
    A --> E[Architectural]
    B --> B1[Singleton]
    B --> B2[Builder]
    C --> C1[Adapter]
    C --> C2[Decorator]
    C --> C3[Facade]
    D --> D1[Strategy]
    D --> D2[Observer]
    D --> D3[Chain of Responsibility]
    E --> E1[MVC]
    E --> E2[MVVM]
    E --> E3[CQRS]
    E --> E4[Event Sourcing]

Strategy (Strategie)

D'Iddi: en Algorithmus zur Laufzäit wielen, ouni de Code z'änneren, deen en oprifft.

Denkt un eng Bezuel-Säit: de Client kann mat Kaart, PayPal oder Iwwerweisung bezuelen. All Optioun ass eng aner Strategie hannert dem selwechte Knäppchen.

public interface IPaymentStrategy
{
    void Pay(decimal amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"Paid {amount} by card");
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"Paid {amount} via PayPal");
}

public class Checkout
{
    private readonly IPaymentStrategy _strategy;

    public Checkout(IPaymentStrategy strategy) => _strategy = strategy;

    public void Complete(decimal amount) => _strategy.Pay(amount);
}

Decorator (Dekorateur)

D'Iddi: engem Objet Verhalen derbäiginn, andeems een en a Schichten ëmwéckelt.

Wéi ee Kaffi mat Extraen: een fänkt mat engem Espresso un a schicht Mëllech, Zocker oder Karamell drop, ouni den Espresso selwer z'änneren.

public interface ICoffee
{
    string Description { get; }
    decimal Cost { get; }
}

public class Espresso : ICoffee
{
    public string Description => "Espresso";
    public decimal Cost => 2.00m;
}

public class MilkDecorator : ICoffee
{
    private readonly ICoffee _inner;

    public MilkDecorator(ICoffee inner) => _inner = inner;

    public string Description => _inner.Description + ", milk";
    public decimal Cost => _inner.Cost + 0.50m;
}

Observer (Observateur)

D'Iddi: en Objet informéiert méi Lauschterer, wann eppes sech ännert.

Wéi en Newsletter: d'Leit abonnéieren sech, an all kritt en Update, wann eng nei Editioun erauskënnt.

public interface IListener
{
    void Notify(string message);
}

public class NewsFeed
{
    private readonly List<IListener> _listeners = new();

    public void Subscribe(IListener listener) => _listeners.Add(listener);

    public void Publish(string message) =>
        _listeners.ForEach(listener => listener.Notify(message));
}

Chain of Responsibility (Verantwortungskette)

D'Iddi: eng Ufro laanscht eng Kette vun Handler weiderginn, bis een se behandelt.

Wéi de Clientssupport: en Ticket gëtt Niveau fir Niveau eskaléiert, bis een e léise kann. All Handler entscheet, ob en d'Ufro behandelt oder weidergëtt.

public interface IHandler
{
    IHandler SetNext(IHandler handler);
    void Handle(string request);
}

public abstract class BaseHandler : IHandler
{
    private IHandler? _next;

    public IHandler SetNext(IHandler handler)
    {
        _next = handler;
        return handler;
    }

    public virtual void Handle(string request)
    {
        _next?.Handle(request);
    }
}

public class AuthHandler : BaseHandler
{
    public override void Handle(string request)
    {
        if (request.StartsWith("auth"))
        {
            Console.WriteLine("Auth passed");
            base.Handle(request);
        }
        else
        {
            Console.WriteLine("Auth failed — stop");
        }
    }
}

public class LoggingHandler : BaseHandler
{
    public override void Handle(string request)
    {
        Console.WriteLine($"Logging: {request}");
        base.Handle(request);
    }
}

var logging = new LoggingHandler();
var auth = new AuthHandler();
logging.SetNext(auth);

logging.Handle("auth:user-42");

All Handler kennt nëmmen deen nächsten, sou datt d'Kette ëmgeordert oder erweidert ka ginn, ouni déi existéierend Handler z'änneren.

Singleton

D'Iddi: garantéieren, datt et genee eng Instanz vun enger Klass gëtt.

Wéi eng eenzeg Astellungsdatei fir eng App — jidderee liest déi selwecht.

public sealed class Configuration
{
    public static Configuration Instance { get; } = new Configuration();

    private Configuration() { }

    public string AppName => "MyApp";
}

Facade (Fassad)

D'Iddi: e komplext System hannert enger einfacher Entrée verstoppen.

Wéi den Zündschlëssel vun engem Auto: een dréint ee Schlëssel a vill Deeler schaffen zesummen ënnendrënner.

public class OrderFacade
{
    private readonly PaymentService _payment = new();
    private readonly InventoryService _inventory = new();

    public void PlaceOrder(Order order)
    {
        _payment.Charge(order);
        _inventory.Reserve(order);
    }
}

Builder (Monteur)

D'Iddi: e komplext Objet Schrëtt fir Schrëtt bauen, amplaz mat engem risege Konstruktor.

Wéi ee personaliséierte Burger bestellen: een wielt d'Brout, de Kéis, d'Extraen — an da gëtt zesummegebaut.

public class Burger
{
    public bool Cheese { get; set; }
    public bool Bacon { get; set; }
}

public class BurgerBuilder
{
    private readonly Burger _burger = new();

    public BurgerBuilder AddCheese() { _burger.Cheese = true; return this; }

    public BurgerBuilder AddBacon() { _burger.Bacon = true; return this; }

    public Burger Build() => _burger;
}

Adapter (Adaptateur)

D'Iddi: zwee inkompatibel Interfaces zesumme schaffe loossen.

Wéi e Reesstecker-Adapter, dee äre Ladegerät an eng auslännesch Steckdous passt.

public interface IShape
{
    double Area();
}

public class LegacyRectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
}

public class RectangleAdapter : IShape
{
    private readonly LegacyRectangle _rect;

    public RectangleAdapter(LegacyRectangle rect) => _rect = rect;

    public double Area() => _rect.Width * _rect.Height;
}

MVC (Model-View-Controller)

D'Iddi: d'Donnéeën, d'Duerstellung an d'Steierungslogik trennen.

De Model hält d'Donnéeën, d'View weist se un, an de Controller reagéiert op d'Aktiounen vum Benotzer.

public class User
{
    public string Name { get; set; } = "Olivier";
}

public class UserController
{
    public string GetUserName() => new User().Name;
}

MVVM (Model-View-ViewModel)

D'Iddi: d'View direkt un e ViewModel bannen, sou datt d'Interface sech automatesch aktualiséiert, wann d'Donnéeë sech änneren.

Beléift an Desktop- a Mobil-Applikatiounen: ee Klick ännert eng Propriétéit an den Ecran spigelt dat, ouni manuell Verdrotung.

public class CounterViewModel : INotifyPropertyChanged
{
    private int _count;

    public int Count
    {
        get => _count;
        set { _count = value; OnPropertyChanged(); }
    }

    public void Increment() => Count++;

    // INotifyPropertyChanged implementation omitted for brevity
}

CQRS (Trennung vu Kommando an Ufro)

D'Iddi: d'Schreiwen (Kommandoen) vum Liesen (Ufroen) trennen.

Liesen a Schreiwen brauchen dacks ënnerschiddlech Modeller a Späicheren. Se ze trennen hält all Säit einfach a skaléierbar.

public record CreateOrderCommand(int Id, decimal Total);

public record GetOrderQuery(int Id);

public class CreateOrderHandler
{
    public void Handle(CreateOrderCommand command) { /* save the order */ }
}

public class GetOrderHandler
{
    public Order Handle(GetOrderQuery query) => /* load the order */ null!;
}

Event Sourcing (Event-Sourcing)

D'Iddi: all Zoustandsännerung als immutabel Event späicheren, an den aktuellen Zoustand nei opbauen, andeems een dës Eventen nei ofspillt.

Amplaz deen aktuelle Saldo ze späicheren, späichert Dir « 100 ageluecht », « 40 ofgehuewen ». De Saldo ass eng Projektioun, déi Dir zu all Moment nei bereche kënnt.

public interface IEvent { }

public record AccountOpened(Guid AccountId, string Owner) : IEvent;
public record MoneyDeposited(Guid AccountId, decimal Amount) : IEvent;
public record MoneyWithdrawn(Guid AccountId, decimal Amount) : IEvent;

public class Account
{
    public Guid Id { get; private set; }
    public decimal Balance { get; private set; }

    public void Apply(IEvent @event)
    {
        switch (@event)
        {
            case AccountOpened e:
                Id = e.AccountId;
                break;
            case MoneyDeposited e:
                Balance += e.Amount;
                break;
            case MoneyWithdrawn e:
                Balance -= e.Amount;
                break;
        }
    }
}

// load = replay the history
var account = new Account();
foreach (var @event in eventStore.Load(accountId))
{
    account.Apply(@event);
}

Event Sourcing gëtt Iech eng komplett Audit-Spur, mécht den Zoustand reproduzéierbar a passt natierlech mat CQRS zesummen — mee et kascht méi Späicher a Komplexitéit.

Zum Schluss

Dir wäert net all Pattern all Dag benotzen — awer se erëmzefannen hëlleft Iech, de Code vun aneren ze liesen, iwwer Designen kloer ze diskutéieren an dat richtegt Handwierksgeschir ze wielen, wann e Problem Iech vertraut virkënnt.

Java an den Spring-Ecosystem fir Experten: Boot, Security, JPA, Kafka, Profiler, Gateway

Wed, 02 Sep 2026 00:00:00 GMT

Java gëtt ëmmer méi kompakt, an den Spring-Ecosystem hëlt ëmmer méi Boilerplate ewech. Dëse Guide deckt d'Sproochfeatures an d'Spring-Moduler of, déi en Expert-Backend-Entwéckler all Dag benotzt, a schléisst mat enger Versiounschronologie.

flowchart TD
    B[Spring Boot] --> S[Spring Security]
    B --> J[Spring Data JPA]
    B --> C[Spring Cloud Stream]
    B --> P[Profiles]
    B --> G[Spring Cloud Gateway]
    B --> BA[Spring Batch]
    C --> K[Kafka Binder]
    BA --> DB[(Database)]

Modernt Java

Lambdas

E Lambda ass eng kompakt Ëmsetzung vun engem funktionellen Interface (en Interface mat enger eenzeger abstrakter Method). Et dreift d'Stream API an déi funktionell DSLen vu Spring.

List<String> names = List.of("Ada", "Bob", "Cara");

// lambda
names.forEach(name -> System.out.println(name));

// method reference
names.forEach(System.out::println);

D'JDK liwwert déi heefeg funktionell Interfaces, Dir schreift se also selten.

Predicate<String> isLong = s -> s.length() > 3;
Function<String, Integer> length = String::length;
Consumer<String> print = System.out::println;
Supplier<String> id = () -> UUID.randomUUID().toString();

Streams

E Stream ass e Pipeline iwwer eng Kollektioun: eng Quell, eng Kette vu faulen Zwëschenoperatiounen, an eng terminal Operatioun, déi e leeft.

List<Order> orders = List.of(/* ... */);

List<String> emails = orders.stream()
  .filter(o -> o.total() > 100)
  .sorted(Comparator.comparing(Order::total).reversed())
  .map(Order::customerEmail)
  .distinct()
  .limit(10)
  .toList();

Heefeg terminal Operatiounen:

double sum = orders.stream().mapToDouble(Order::total).sum();

Map<Status, List<Order>> byStatus =
  orders.stream().collect(Collectors.groupingBy(Order::status));

boolean anyLarge = orders.stream().anyMatch(o -> o.total() > 1000);

filter, map, sorted, distinct a limit si faul; toList, collect, reduce a forEach starten de Pipeline. Streams encouragéieren immutable, deklarativ Dateveraarbechtung.

Records

Records ginn Iech immutable Daten-Droen ouni Boilerplate.

public record User(String name, int age) { }

Pattern Matching

instanceof schränkt d'Variabel direkt an.

if (obj instanceof String s) {
  System.out.println(s.length());
}

Switch Expressions kombinéiere sech mam Pattern Matching fir exhaustiv, typiséiert Logik.

String result = switch (obj) {
  case Integer i -> "int " + i;
  case String s  -> "str " + s;
  default        -> "other";
};

Sealed Classes

Sealed Hierarchie deklaréieren all erlaabten Ënnertyp, sou datt de Compiler d'Exhaustivitéit ka kontrolléieren.

public sealed interface Shape permits Circle, Square { }

public record Circle(double radius) implements Shape { }
public record Square(double side) implements Shape { }

Virtuell Threads

De Projet Loom (stabil zënter Java 21) léisst blockéierende Code mat liichten, bëllege Threads skaléieren.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
  executor.submit(() -> handleRequest());
}

Spring Boot

Spring Boot verdrot eng Applikatioun aus enger eenzeger Annotatioun a vernünftege Standardwäerter, konfiguréiert iwwer application.yml.

@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

Starters bréngen eng ganz Funktioun (Web, Data, Security) mat enger eenzeger Ofhängegkeet, an d'Auto-Configuratioun passt sech un dat un, wat um Classpath ass.

Spring Beans a Komponenten

E Bean ass all Objet, dee vum Spring IoC-Container geréiert gëtt. Komponenten si Klassen, déi duerch Component Scanning iwwer Stereotyp- Annotatiounen automatesch fonnt ginn.

@Component
public class EmailService { }

@Service
public class OrderService { }

@Repository
public class OrderRepository { }

@Controller
public class OrderController { }

@Component ass de generesche Stereotyp; @Service, @Repository an @Controller si Spezialisatiounen, déi Bedeitung an zukünftegt Verhalen derbäisetzen.

Fir Drëtt-Partei- oder manuell gebauten Objeten, deklaréiert e Bean an enger @Configuration-Klass.

@Configuration
public class AppConfig {
  @Bean
  OrderValidator orderValidator() {
    return new OrderValidator();
  }
}

Injizéiert Ofhängegkeeten iwwer de Konstruktor — de modernen, testbaren Standard.

@Service
public class OrderService {
  private final OrderRepository repository;
  private final EmailService email;

  public OrderService(OrderRepository repository, EmailService email) {
    this.repository = repository;
    this.email = email;
  }
}

@Autowired ass déi eeler, annotatiounsgedriwwen Aart. Et kann Felder, Setteren oder Konstruktoren zielen.

@Service
public class OrderService {

  @Autowired
  private OrderRepository repository;

  private EmailService email;

  @Autowired
  public void setEmailService(EmailService email) {
    this.email = email;
  }
}

Feld- a Setter-Injektioun si flexibel, maachen awer Ofhängegkeeten mutabel a méi schwéier ze testen. Léiwer Konstruktor-Injektioun — bei engem eenzege Konstruktor ass @Autowired souguer fakultativ.

Wann méi Beans dee selwechten Typ deelen, wielt @Qualifier de richtegen aus.

@Service
public class CreditCardPayment implements PaymentService { }

@Service
public class PayPalPayment implements PaymentService { }

@Service
public class CheckoutService {

  private final PaymentService payment;

  public CheckoutService(@Qualifier("payPalPayment") PaymentService payment) {
    this.payment = payment;
  }
}

De Qualifier ass de Bean-Numm — standardméisseg de Klassennumm mat engem klengen éischte Buschtaf. Dir kënnt en expliziten Numm mat @Service("paypal") oder @Bean("paypal") setzen.

Spring bitt méi Bean-Scopes. singleton (de Standard) mécht eng Instanz pro Container; prototype mécht bei all Ufro eng nei Instanz; d'Web-Scopes (request, session, application, websocket) sinn un e Web-Kontext gebonnen.

// singleton (default) — one instance per container
@Component
public class SingletonService { }

// prototype — a new instance on every injection
@Component
@Scope("prototype")
public class ShoppingCart { }

// request — one instance per HTTP request
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext { }

// session — one instance per HTTP session
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserSession { }

// application — one instance per ServletContext
@Component
@Scope(value = WebApplicationContext.SCOPE_APPLICATION)
public class AppWideConfig { }

// websocket — one instance per WebSocket session
@Component
@Scope(value = "websocket",
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ChatSession { }

Déi kuerzliewend Scopes (request, session, websocket) brauchen proxyMode = ScopedProxyMode.TARGET_CLASS, fir an méi laang liewend Singletons injizéiert ze kënne ginn.

Spring liwwert Kierzel-Annotatiounen fir déi heefeg Web-Scopes:

@Component
@RequestScope
public class RequestContext { }

@Component
@SessionScope
public class UserSession { }

@Component
@ApplicationScope
public class AppWideConfig { }

@RequestScope a @SessionScope si Kierzel fir d'@Scope-Versioun mat proxyMode = ScopedProxyMode.TARGET_CLASS. Et gëtt kee Kierzel fir prototype oder websocket — benotzt @Scope fir déi.

Hei ass de komplette Set:

Scope	Liewensdauer	Kierzel
`singleton`	Eng Instanz pro Container	Standard
`prototype`	Nei Instanz bei all Ufro	—
`request`	Eng Instanz pro HTTP-Ufro	`@RequestScope`
`session`	Eng Instanz pro HTTP-Session	`@SessionScope`
`application`	Eng Instanz pro `ServletContext`	`@ApplicationScope`
`websocket`	Eng Instanz pro WebSocket-Session	—

Kuerz gesot, d'Kierzel-Annotatioune sinn @RequestScope, @SessionScope an @ApplicationScope. Spring Cloud liwwert och @RefreshScope fir @Scope("refresh"). Et gëtt kee Kierzel fir singleton (de Standard), prototype oder websocket.

@SpringBootApplication aktivéiert de Component Scanning iwwer säi Package, sou datt all annotéiert Klass do automatesch opgeholl gëtt.

Spring Security

Security gëtt iwwer e SecurityFilterChain-Bean konfiguréiert. Den Lambda-DSL ass de modernen, liesbaren Stil.

@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
  return http
    .authorizeHttpRequests(auth -> auth
      .requestMatchers("/api/public/**").permitAll()
      .anyRequest().authenticated())
    .oauth2ResourceServer(oauth -> oauth.jwt(Customizer.withDefaults()))
    .build();
}

JWT Resource Servers sinn de Standard fir stateless APIen; Method-Security (@PreAuthorize) schützt eenzel Service-Opruff. Aktivéiert et mat @EnableMethodSecurity an annotéiert d'Methoden, déi Dir schütze wëllt.

@RestController
@RequestMapping("/api/orders")
public class OrderController {

  private final OrderService orders;

  public OrderController(OrderService orders) {
    this.orders = orders;
  }

  @PreAuthorize("hasRole('ADMIN')")
  @DeleteMapping("/{id}")
  public void cancel(@PathVariable Long id) {
    orders.cancel(id);
  }
}

@PreAuthorize akzeptéiert SpEL: Dir kënnt Rollen (hasRole), Autoritéiten (hasAuthority) oder d'Ufro selwer (#id == authentication.name) prüfen. Benotzt @PostAuthorize, fir de zeréckginnene Wäert no der Ausféierung ze filteren.

Filter vs Interceptors

Béid wéckelen Ufroen an, awer op verschiddene Schichten. E Filter ass Deel vun der Servlet API a leeft ronderëm déi ganz Ufro, virum Spring säin DispatcherServlet. En Interceptor ass Spring MVC a leeft am Dispatcher, mat Zougang zum Zil-Controller.

flowchart LR
    R[Request] --> F[Filter]
    F --> D[DispatcherServlet]
    D --> I[Interceptor]
    I --> C[Controller]

E Filter ass fir Konzerner, déi musse lafen, ier Spring d'Ufro iwwerhaapt gesäit:

@Component
public class RequestLoggingFilter extends OncePerRequestFilter {

  @Override
  protected void doFilterInternal(
      HttpServletRequest request,
      HttpServletResponse response,
      FilterChain chain) throws ServletException, IOException {

    long start = System.currentTimeMillis();
    chain.doFilter(request, response);
    log.info("{} {} took {} ms", request.getMethod(),
        request.getRequestURI(), System.currentTimeMillis() - start);
  }
}

En Interceptor ass fir Konzerner, déi de Controller brauchen, wéi zum Beispill e bestëmmten Handler ze stoppen:

@Component
public class TimingInterceptor implements HandlerInterceptor {

  @Override
  public boolean preHandle(HttpServletRequest request,
      HttpServletResponse response, Object handler) {
    request.setAttribute("startTime", System.currentTimeMillis());
    return true;
  }

  @Override
  public void afterCompletion(HttpServletRequest request,
      HttpServletResponse response, Object handler, Exception ex) {
    long start = (long) request.getAttribute("startTime");
    log.info("Handler {} took {} ms", handler,
        System.currentTimeMillis() - start);
  }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new TimingInterceptor())
        .addPathPatterns("/api/**");
  }
}

	Filter	Interceptor
Schicht	Servlet API	Spring MVC
Leeft	Virum `DispatcherServlet`	Am `DispatcherServlet`
Gesäit de Controller	Nee	Jo (`HandlerMethod`)
Typesch Notzung	Auth, CORS, Encoding, Logging	Timing, Modellattributer, handlerbewosst Logging

Kuerz gesot: Filtere fir d'Containerniveau, Interceptore fir d'MVC-Niveau.

@RestController vs @Controller

@Controller ass de klasseschen MVC-Stereotyp: seng Methode ginn en View-Numm zeréck, dee vun engem ViewResolver opgeléist gëtt. @RestController ass d'Kombinatioun vu @Controller + @ResponseBody, sou datt seng Methode Donnéeën zeréckginn, déi op JSON serialiséiert ginn.

@Controller
public class PageController {

  @GetMapping("/")
  public String home() {
    return "index"; // view name, not JSON
  }
}

@RestController
@RequestMapping("/api/users")
public class UserController {

  private final UserService users;

  public UserController(UserService users) {
    this.users = users;
  }

  @GetMapping
  public List<User> list() {
    return users.findAll(); // serialized to JSON
  }
}

@GetMapping, @PostMapping, @PutMapping an @DeleteMapping si Kierzel fir @RequestMapping(method = ...). Benotzt @Controller fir servergerendert Säiten an @RestController fir APIen.

Spring Data JPA

Entitéite mappen Klasse op Tabellen, an Repository-Interfaces generéieren d'Querien aus de Methodennimm.

@Entity
@Table(name = "customer")
public class Customer {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false)
  private String name;
}

public interface CustomerRepository extends JpaRepository<Customer, Long> {
  List<Customer> findByNameContainingIgnoreCase(String name);

  Page<Customer> findByNameContainingIgnoreCase(String name, Pageable pageable);
}

D'Paginéierung benotzt Pageable mat Page oder Slice:

Page<Customer> page = repository.findByNameContainingIgnoreCase(
    "a", PageRequest.of(0, 20, Sort.by("name")));

List<Customer> content = page.getContent();
long total = page.getTotalElements();
int pages = page.getTotalPages();

PageRequest.of(page, size) entsprécht offset = page * size an limit = size. Page mécht eng zousätzlech COUNT-Ufro fir den Total; benotzt Slice, fir se ze spueren, wann Dir nëmmen en « huet et eng Säit méi »-Indikateur braucht.

Benotzt @Transactional op de Service-Grenzen, fir datt méi Schreibvirstellungen zesumme committéiert oder zeréckgerullt ginn.

@Service
public class OrderService {

  private final OrderRepository orders;
  private final PaymentService payments;

  public OrderService(OrderRepository orders, PaymentService payments) {
    this.orders = orders;
    this.payments = payments;
  }

  @Transactional
  public Order placeOrder(Order order) {
    Order saved = orders.save(order);
    payments.charge(order.getTotal());
    return saved;
  }
}

Wann ee Schrëtt eng RuntimeException werft, gëtt déi ganz Method zeréckgerullt. Passt et mat rollbackFor (fir Checked Exceptions), readOnly = true (fir Read-Only-Querien) a propagation (fir eng Transaktioun bäizetrieden oder eng nei ze verlaangen) un.

Lombok a MapStruct

Lombok

Lombok hëlt Boilerplate mat Compile-Zäit-Annotatiounen ewech. @Getter/@Setter generéieren Accessoren, @Builder e Builder a @Slf4j e Logger.

@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Customer {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;
}

@RequiredArgsConstructor generéiert e Konstruktor fir final-Felder, wat perfekt mat der Konstruktor-Injektioun zesummegeet.

@Service
@RequiredArgsConstructor
public class OrderService {
  private final OrderRepository orders;
  private final PaymentService payments;

  public void place(Order order) {
    orders.save(order);
  }
}

@Data bündelt d'Accessoren mat equals/hashCode/toString, awer vermeit et op JPA-Entitéiten, wou de generéierten equals sech op mutablem Zoustand schlecht behuele kann.

MapStruct

MapStruct generéiert type-sécher Mapper tëscht DTOen an Entitéiten zur Compile-Zäit. Deklaréiert en Interface an et produzéiert d'Ëmsetzung.

@Mapper(componentModel = "spring")
public interface CustomerMapper {

  CustomerDto toDto(Customer customer);

  @Mapping(target = "id", ignore = true)
  Customer toEntity(CreateCustomerRequest request);
}

Mat componentModel = "spring" ass de Mapper e Spring Bean, deen Dir injizéiere kënnt.

@Service
@RequiredArgsConstructor
public class CustomerService {
  private final CustomerRepository repository;
  private final CustomerMapper mapper;

  public CustomerDto create(CreateCustomerRequest request) {
    return mapper.toDto(repository.save(mapper.toEntity(request)));
  }
}

Am Géigesaz zu Reflexiouns-Mapper ass MapStruct type-sécher a feelt zur Compile-Zäit, wann d'Felder net iwwereneestëmmen.

Spring Cloud Stream mam Kafka Binder

Cloud Stream abstrahéiert d'Messaging-Infrastruktur hannert engem Binding-Modell, sou datt Äre Code Funktiounen schwätzt, net Kafka-Clients.

@Bean
Function<Order, Order> processOrder() {
  return order -> {
    // validate, enrich, or transform
    return order;
  };
}

spring:
  cloud:
    stream:
      bindings:
        processOrder-in-0:
          destination: orders
        processOrder-out-0:
          destination: orders-processed
      kafka:
        binder:
          brokers: localhost:9092

Wiesselt de Binder (Kafka, Rabbit, Kafka Streams) ouni d'Funktioun ze beréieren.

Profiler

Profiler luede pro Ëmfeld eng aner Configuratioun. D'Dateien heeschen application-{profile}.yml, an spring.profiles.active wielt se aus.

spring:
  profiles:
    active: dev

# application-dev.yml
server:
  port: 8080

Méi Profiler lueden

Profiler sinn additiv an uerdentlech — aktivéiert méi gläichzäiteg:

spring:
  profiles:
    active: dev,local

Lued-Regelen:

E spéidere Profil iwwerschreift e frësche Profil.
All application-{profile}.yml iwwerschreift d'Basis-application.yml.
Ouni aktive Profil benotzt Spring de default-Profil (application.yml nëmmen).
Aktivéiert se vu baussen iwwer d'Ëmfeldvariabel SPRING_PROFILES_ACTIVE oder --spring.profiles.active=dev,local.

E Profil kann anerer mat include eraopzéien:

spring:
  profiles:
    include: common,metrics

Dir kënnt Beans och mat @Profile gaten.

@Component
@Profile("!prod")
public class DevDataSeeder { }

Spring Cloud Gateway

D'Gateway route Ufroen op Downstream-Servicer mat Predicates a Filteren.

spring:
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://ORDER-SERVICE
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=1

Predicates passen d'Ufro un; Filteren transforméieren se (Pad ëmschreiwen, Header derbäisetzen, Circuit Breaker). Mat engem Discovery-Client verdeelt lb:// d'Laascht iwwer d'Instanzen.

Spring Batch

Spring Batch verschafft grouss, geplangt Dateveraarbechtung: a Bléck liesen, veraarbechten, schreiwen, mat Restart a Retry agebaut. E Job besteet aus chunkorientéierte Schrëtt.

@Configuration
@EnableBatchProcessing
public class BatchConfig {

  @Bean
  public Job importUsersJob(JobRepository jobRepository, Step step) {
    return new JobBuilder("importUsersJob", jobRepository)
        .start(step)
        .build();
  }

  @Bean
  public Step step(JobRepository jobRepository,
      PlatformTransactionManager transactionManager,
      ItemReader<User> reader,
      ItemProcessor<User, User> processor,
      ItemWriter<User> writer) {
    return new StepBuilder("step", jobRepository)
        .<User, User>chunk(100, transactionManager)
        .reader(reader)
        .processor(processor)
        .writer(writer)
        .build();
  }

  @Bean
  public ItemReader<User> reader() {
    return new FlatFileItemReaderBuilder<User>()
        .name("userReader")
        .resource(new FileSystemResource("users.csv"))
        .delimited()
        .names("name", "email")
        .targetType(User.class)
        .build();
  }

  @Bean
  public ItemProcessor<User, User> processor() {
    return user -> {
      user.setEmail(user.getEmail().toLowerCase());
      return user;
    };
  }
}

Job — de ganze Batch-Prozess.
Step — eng Phas; hei e Chunk-Schrëtt, dee liest, transforméiert a schreift.
Reader / Processor / Writer — de Chunk-Pipeline.
chunk(100) — veraarbecht 100 Elementer pro Transaktioun, sou datt e Feeler ee Chunk zeréckrullt, net de ganze Job.

Spring Batch protokolléiert de Job- a Schrëtt-Status an engem Metadaten-Späicher, sou datt Jobs do kënne weiderfueren, wou se feelgeschloe sinn.

Java Versiounsgeschicht

Eng kompakt Chronologie vun de grousse Versiounen an hire Kärännerungen.

Versioun	Release	Breaking Changes / Neiegkeeten
8	Mäerz 2014	Lambdas, Streams, `Optional`, `java.time`; PermGen ewechgeholl (Metaspace)
9	Sept 2017	Modulsystem (JPMS/Jigsaw), JShell, `List.of`/`Map.of`
10	Mäerz 2018	`var` Typinferenz fir lokal Variabelen
11	Sept 2018	LTS; `HttpClient`, `var` a Lambdas; Java EE & CORBA Moduler ewechgeholl
12	Mäerz 2019	Switch Expressions (Virschau), Shenandoah GC
13	Sept 2019	Text Blocks (Virschau), ZGC
14	Mäerz 2020	Switch Expressions standard; Records & Pattern Matching (Virschau)
15	Sept 2020	Text Blocks standard; Sealed Classes (Virschau)
16	Mäerz 2021	Records standard; Pattern Matching fir `instanceof` standard
17	Sept 2021	LTS; Sealed Classes standard; staark Enkapsulatioun vun den JDK-Internen
18	Mäerz 2022	UTF-8 Standard Charset; einfachen Webserver
19	Sept 2022	Virtuell Threads (Virschau); Record Patterns (Virschau)
20	Mäerz 2023	Record Patterns standard; Virtuell Threads (2. Virschau)
21	Sept 2023	LTS; Virtuell Threads standard, Pattern Matching fir Switch, Sequenced Collections
22	Mäerz 2024	Onbenannt Variabelen & Mustern; Aussoen virun `super()`
23	Sept 2024	Modul-Import-Deklaratiounen (Virschau); primitiv Mustern (Virschau)
24	Mäerz 2025	Kompakt Objet-Header, Class-File API, Stream Gatherers
25	Sept 2025	LTS; Strukturéiert Concurrency & Scoped Values stabil

Zum Schluss

Modernt Java verléisst sech op Records, Pattern Matching, Sealed Types a Virtuell Threads, fir Boilerplate ze reduzéieren an ze skaléieren. Den Spring-Ecosystem leet d'Auto-Configuratioun vu Boot, d'Filterkette vu Security, d'Repositories vu JPA, d'Bindings vu Cloud Stream, Profiler an eng Gateway drop. Zesummen ginn se Iech e Produktiouns-Backend, dee kompakt, typiséiert an einfach ze verstoen ass.

Laang lafend Workflows mat MassTransit-Sagas orchestrieren

Wed, 02 Sep 2026 00:00:00 GMT

De Problem mat enger eenzeger Transaktioun

E Checkout ass selten an enger Ufro fäerdeg. D'Geld muss agezunn, de Stock muss reservéiert an d'Lager muss iwwer d'Liwwerung informéiert ginn. Dat alles an eng eenzeg verdeelt Transaktioun ze wéckelen — en Zwee-Phase-Commit iwwer Servicer — gesäit op Pabeier propper aus, brécht awer an der Realitéit séier zesummen.

D'Problem ass, datt kee Service viraussoe kann, wéi laang en anere braucht. E Bezuel-Provider ka waarden, bis eng Fraud-Prüfung duerch ass, an eng Stock-Kontroll ka bei Laascht lues sinn. Spären iwwer verschidde Systemer sou laang opzehalen ass onpraktesch a kann déi ganz Plattform bremsen.

E Saga ëmgeet dat, andeems de Flux a lokal Schrëtt opgedeelt gëtt, déi séier fäerdeg sinn an eenzel réckgängeg gemaach kënne ginn.

Wat e Saga wierklech ass

E Saga ass eng Kette vu lokalen Aktiounen, wou all Schrëtt eng passend kompenséierend Aktioun huet, déi e réckgängeg mécht, wann e spéidere Schrëtt feelgeet. Amplaz vun enger atomarer Operatioun gëtt d'Aarbecht a kleng, onofhängeg erholbar Stécker opgedeelt.

Huelt eng Bestellung als Beispill:

sequenceDiagram
    participant Client
    participant Saga
    participant Payments
    participant Inventory
    Client->>Saga: OrderSubmitted
    Saga->>Payments: ChargePayment
    Payments-->>Saga: PaymentSettled
    Saga->>Inventory: AllocateInventory
    Inventory-->>Saga: InventoryAllocated
    Saga->>Client: FinalizeOrder

Wann de Stock-Schrëtt mellt, datt en Artikel ausverkaaft ass nodeems d'Bezuelung scho duerch ass, léist de Saga eng Réckzuelung aus, fir d'Geld zeréckzeginn. All Deel ass entkoppelt, an näischt bleift de ganze Wee gespaart.

MassTransit-Sagas si State-Machinen

MassTransit setzt Sagas iwwer eng State-Machine ëm, eng Approche, déi vun Automatonymous ierft. Ier ee Code schreift, hëlleft et, déi véier Deeler vum Modell ze kennen:

Staaten — d'Positiounen, an deenen e Workflow ka sinn
Eventer — Messagen, déi de Workflow vun engem Staat an en anere réckelen
Behavioren — d'Aarbecht, déi ausgefouert gëtt, wann en Event an engem bestëmmte Staat ukënnt
Instanz — den persistéierten Datensaz mat den Daten vun enger eenzeger Konversatioun

All State-Machine huet gratis en Initial- an e Final-Staat. Eng nei Instanz fänkt am Initial un, a Final z'erreechen heescht, datt de Saga fäerdeg ass.

Hei ass d'State-Machine, déi mir baue wäerten:

stateDiagram-v2
    [*] --> ProcessingPayment: OrderSubmitted
    ProcessingPayment --> ReservingInventory: PaymentSettled
    ProcessingPayment --> Failed: OrderDeclined
    ReservingInventory --> Completed: InventoryAllocated
    ReservingInventory --> Failed: OrderDeclined
    Completed --> [*]
    Failed --> [*]

D'Saga-Instanz

D'Instanz ass d'Entitéit, déi MassTransit tëscht de Messagen persistéiert. Se hält de Korrelatiounsschlëssel, den aktuellen Staat an d'Business-Daten, déi d'Schrëtt brauchen.

public class OrderState : SagaStateMachineInstance
{
    public Guid CorrelationId { get; set; }
    public string CurrentState { get; set; } = string.Empty;

    public decimal Total { get; set; }
    public string? PaymentReference { get; set; }
    public DateTime? PlacedAt { get; set; }
    public string? BuyerEmail { get; set; }
}

CorrelationId ass den Identifikateur, deen all erakommende Message mat der richteger Instanz verbënnt, iwwerdeems CurrentState festhält, wou de Workflow grad steet. Déi reschtlech Eegenschaften droen d'Daten, déi de Prozess ënnerwee brauch.

D'Eventer

Eventer sinn d'Messagen, déi Iwwergäng ausléisen. All eenzel muss iwwer en gemeinsamen Identifikateur mat enger bestëmmter Instanz korreléiert sinn.

public record OrderSubmitted(Guid OrderId, decimal Total, string Email);

public record PaymentSettled(Guid OrderId, string PaymentReference);

public record InventoryAllocated(Guid OrderId);

public record OrderDeclined(Guid OrderId, string Reason);

Dës Records lafen iwwer de Bus; de Saga reagéiert dorop a kann als Äntwert nei Commande publizéieren.

D'State-Machine bauen

D'State-Machine verbënnt Staaten, Eventer a Behavioren an deklaréiert, wéi eng Iwwergäng erlaabt sinn.

public class OrderStateMachine : MassTransitStateMachine<OrderState>
{
    public OrderStateMachine()
    {
        InstanceState(x => x.CurrentState);

        Event(() => OrderSubmitted, x => x.CorrelateById(c => c.Message.OrderId));
        Event(() => PaymentSettled, x => x.CorrelateById(c => c.Message.OrderId));
        Event(() => InventoryAllocated, x => x.CorrelateById(c => c.Message.OrderId));
        Event(() => OrderDeclined, x => x.CorrelateById(c => c.Message.OrderId));

        Initially(
            When(OrderSubmitted)
                .Then(c =>
                {
                    c.Saga.Total = c.Message.Total;
                    c.Saga.BuyerEmail = c.Message.Email;
                    c.Saga.PlacedAt = DateTime.UtcNow;
                })
                .PublishAsync(c => c.Init<ChargePayment>(new
                {
                    OrderId = c.Saga.CorrelationId,
                    Amount = c.Saga.Total
                }))
                .TransitionTo(ProcessingPayment)
        );

        During(ProcessingPayment,
            When(PaymentSettled)
                .Then(c => c.Saga.PaymentReference = c.Message.PaymentReference)
                .PublishAsync(c => c.Init<AllocateInventory>(new
                {
                    OrderId = c.Saga.CorrelationId
                }))
                .TransitionTo(ReservingInventory),
            When(OrderDeclined)
                .TransitionTo(Failed)
                .Finalize()
        );

        During(ReservingInventory,
            When(InventoryAllocated)
                .PublishAsync(c => c.Init<FinalizeOrder>(new
                {
                    OrderId = c.Saga.CorrelationId
                }))
                .TransitionTo(Completed)
                .Finalize(),
            When(OrderDeclined)
                .PublishAsync(c => c.Init<ReimbursePayment>(new
                {
                    OrderId = c.Saga.CorrelationId,
                    Amount = c.Saga.Total
                }))
                .TransitionTo(Failed)
                .Finalize()
        );

        SetCompletedWhenFinalized();
    }

    public State ProcessingPayment { get; private set; } = null!;
    public State ReservingInventory { get; private set; } = null!;
    public State Completed { get; private set; } = null!;
    public State Failed { get; private set; } = null!;

    public Event<OrderSubmitted> OrderSubmitted { get; private set; } = null!;
    public Event<PaymentSettled> PaymentSettled { get; private set; } = null!;
    public Event<InventoryAllocated> InventoryAllocated { get; private set; } = null!;
    public Event<OrderDeclined> OrderDeclined { get; private set; } = null!;
}

Opgepasst op d'Kompensatiounslogik: wann de Stock-Schrëtt nom Bezuelen feelgeet, publizéiert de Saga ReimbursePayment, fir de Betrag zeréckzebezuelen. De gléckleche Wee an de Feelerwee ginn niewentenee deklaréiert, wat de Workflow einfach liesbar mécht.

D'Consumer

De Saga ass de Koordinator, net den Ausféierer. Déi richteg Aarbecht läit an de Message-Consumer, déi Commande veraarbechten an iwwer Eventer zeréckmellen.

public class ChargePaymentConsumer(
    IPaymentGateway gateway,
    ILogger<ChargePaymentConsumer> logger) : IConsumer<ChargePayment>
{
    public async Task Consume(ConsumeContext<ChargePayment> context)
    {
        try
        {
            var result = await gateway.ChargeAsync(
                context.Message.OrderId,
                context.Message.Amount);

            if (result.Succeeded)
            {
                await context.Publish<PaymentSettled>(new
                {
                    OrderId = context.Message.OrderId,
                    PaymentReference = result.Reference
                });
            }
            else
            {
                await context.Publish<OrderDeclined>(new
                {
                    OrderId = context.Message.OrderId,
                    Reason = result.RejectionReason
                });
            }
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Payment failed for order {OrderId}", context.Message.OrderId);

            await context.Publish<OrderDeclined>(new
            {
                OrderId = context.Message.OrderId,
                Reason = "Payment gateway error"
            });
        }
    }
}

D'Verantwortungen esou ze trennen erlaabt all Service, sech op seng eege Roll ze konzentréieren, wärend de Saga de ganze Prozess an déi richteg Richtung beweegt.

Mat Azure Service Bus opbauen

De Saga-Staat ze persistéieren brauch en Repository. Mir benotzen Entity Framework Core op SQL Server, mat Azure Service Bus als Transport.

Als éischt déi néideg Packagen:

Install-Package MassTransit.EntityFrameworkCore
Install-Package MassTransit.Azure.ServiceBus.Core
Install-Package Microsoft.EntityFrameworkCore.SqlServer

Definéiert en DbContext an e Class-Map fir d'Saga-Instanz:

public class OrderSagaDbContext : SagaDbContext
{
    public OrderSagaDbContext(DbContextOptions options) : base(options) { }

    protected override IEnumerable<ISagaClassMap> Configurations
    {
        get { yield return new OrderStateMap(); }
    }
}

public class OrderStateMap : SagaClassMap<OrderState>
{
    protected override void Configure(EntityTypeBuilder<OrderState> entity, ModelBuilder model)
    {
        entity.Property(x => x.CurrentState).HasMaxLength(64);
        entity.Property(x => x.BuyerEmail).HasMaxLength(256);
        entity.Property(x => x.PaymentReference).HasMaxLength(64);
    }
}

Zum Schluss alles an der Applikatioun registréieren:

builder.Services.AddDbContext<OrderSagaDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("SqlServer")));

builder.Services.AddMassTransit(x =>
{
    x.AddSagaStateMachine<OrderStateMachine, OrderState>()
        .EntityFrameworkRepository(r =>
        {
            r.ConcurrencyMode = ConcurrencyMode.Pessimistic;
            r.AddDbContext<DbContext, OrderSagaDbContext>();
        });

    x.UsingAzureServiceBus((context, cfg) =>
    {
        cfg.Host(builder.Configuration.GetConnectionString("ServiceBus"));
        cfg.ConfigureEndpoints(context);
    });
});

Firwat Sagas huelen

Resilienz — all Schrëtt kann eenzel nei probéiert ginn, a Feeler léisen Kompensatioun aus, amplaz de System hallef fäerdeg hannerloossen.
Visibilitéit — den aktuellen Staat seet genee, wou all Bestellung steet, wat Debuggen an Iwwerwaachung vereinfacht.
Loos Kopplung — Servicer kommunizéieren iwwer Messagen a kënne sech separat weiderentwéckelen, ouni de ganze Flux ze briechen.
Maintainabilitéit — eng Ännerung an engem Schrëtt schléit net op déi aner duerch.

D'State-Machine zwéngt de Business-Prozess och, explizit ze sinn. All Staat an Iwwergank ass kloer festgehalen, wat aus engem opaken verdeelte Flux eppes mécht, dat en neie Teammember novollzéie kann.

Resumé

E Checkout als MassTransit-Saga ze modelléieren gëtt koordinéiert, erholbar Workflows ouni de Péng vun de verdeelten Transaktiounen. Definéiert d'Staaten an d'Eventer, persistéiert d'Instanz a loosst Azure Service Bus d'Messagen droen. D'Resultat ass e Prozess, dee kloer, observéierbar an nohalteg ass, wann eppes schif geet.

Python fir d'Finanz: NumPy, pandas an d'Tools vun der quantitativer Analyse

Wed, 02 Sep 2026 00:00:00 GMT

Python ass déi dominant Sprooch vun der moderner Finanz, well säin Ecosystem alles ofdeckt, vum Datenopraumen bis zur Monte-Carlo-Simulatioun. Dëse Guide geet duerch d'Kärbibliothéiken mat reale Beispiller.

flowchart TD
    P[Python] --> N[NumPy]
    P --> PD[pandas]
    P --> M[matplotlib]
    Y[yfinance] --> PD
    PD --> R[Returns & indicators]
    N --> R
    R --> V[Visualization]
    R --> PF[Portfolio metrics]

NumPy: vectoriséiert Finanz-Mathematik

NumPy gëtt Iech séier, vectoriséiert Arrays — d'Fundament fir all Finanzberechnung.

import numpy as np

prices = np.array([100, 102, 101, 105, 107])

# simple returns
returns = np.diff(prices) / prices[:-1]
print(returns)  # [ 0.02   -0.0098  0.0396  0.0190]

# log returns
log_returns = np.log(prices[1:] / prices[:-1])

# annualized volatility
volatility = returns.std() * np.sqrt(252)

Alles ass elementweis, sou datt Dir Python-Schleifen vermeit an d'Mathematik séier hält.

pandas: DataFrames an Zäitserien

pandas wéckelt d'Daten an en DataFrame mat mächtegen Zäitserie-Operatiounen.

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2026-01-01', periods=5, freq='D'),
    'close': [100, 102, 101, 105, 107],
})

df['returns'] = df['close'].pct_change()
df['cum_return'] = (1 + df['returns']).cumprod() - 1

Resamplet, rullt a verschitt Zäitserien mat agebaute Methoden:

df['sma_3'] = df['close'].rolling(3).mean()
df['prev_close'] = df['close'].shift(1)

Maartdaten mat yfinance kréien

yfinance luet historesch Präisser direkt vun Yahoo Finance erof.

import yfinance as yf

ticker = yf.Ticker('AAPL')
history = ticker.history(period='1y', interval='1d')

prices = history['Close']
returns = prices.pct_change().dropna()

Dir kënnt och méi Tickers gläichzäiteg mat yf.download lueden.

Rendementer a Portfolio-Metriken

Aus de Rendementer berechent d'Haaptrisikometriken.

def sharpe_ratio(returns, risk_free_rate=0.0):
    excess = returns - risk_free_rate / 252
    return excess.mean() / returns.std() * np.sqrt(252)

sharpe = sharpe_ratio(returns)
vol = returns.std() * np.sqrt(252)
ann_return = (1 + returns.mean()) ** 252 - 1

print(f"Return: {ann_return:.2%}, Vol: {vol:.2%}, Sharpe: {sharpe:.2f}")

Korrelatioun tëscht zwee Acteuren:

a = yf.Ticker('AAPL').history(period='1y')['Close'].pct_change()
b = yf.Ticker('MSFT').history(period='1y')['Close'].pct_change()

corr = a.corr(b)

Technesch Indikatoren

Moyenne Mobilité si puer pandas-Opruff.

df['sma_20'] = df['close'].rolling(20).mean()
df['ema_20'] = df['close'].ewm(span=20, adjust=False).mean()
df['signal'] = np.where(df['sma_20'] > df['ema_20'], 1, 0)

rolling gëtt eng einfach Fënster; ewm eng exponentiell. De Crossover vun enger kuerzer iwwer eng laang Moyenne ass e klassescht Signal.

Visualiséierung mat matplotlib

Zeechent Präisser an Indikatoren, fir d'Daten z'iwwerpréiwen.

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.plot(df['date'], df['close'], label='Close')
plt.plot(df['date'], df['sma_20'], label='SMA 20')
plt.plot(df['date'], df['ema_20'], label='EMA 20')
plt.legend()
plt.show()

Monte-Carlo-Simulatioun

Simuléiert vill zukünfteg Präispied, andeems Dir zoufälleg Schocken sampelt.

def monte_carlo(initial_price, mu, sigma, days=252, simulations=1000):
    dt = 1 / 252
    paths = np.zeros((days, simulations))
    paths[0] = initial_price
    for t in range(1, days):
        shocks = np.random.normal(mu * dt, sigma * np.sqrt(dt), simulations)
        paths[t] = paths[t - 1] * (1 + shocks)
    return paths

paths = monte_carlo(100, mu=0.07, sigma=0.20)

final_prices = paths[-1]
value_at_risk = np.percentile(final_prices, 5)

Dat ënnerleet Risikomoossen wéi Value-at-Risk an d'Optiounspräisser.

Zum Schluss

NumPy mécht d'Mathematik, pandas formt d'Daten, yfinance liwwert se a matplotlib weist se. Wann Dir déi véier beherrscht, kënnt Dir Rendementer, Indikatoren a Monte-Carlo-Simulatiounen berechnen — d'Réckgrat vun der quantitativer Finanz a Python.

Relationell Datenbanke fir Experten: ACID, Schlësselen, Triggers an Indexen

Wed, 02 Sep 2026 00:00:00 GMT

Relationell Datenbanken dreuwen déi meescht Applikatiounen aus engem gudde Grond: si ginn Iech staark Garantien an e klore Modell. Dëse Guide geet duerch d'Konzepter, op déi sech all Expert-DBA verléisst, mat SQL-Beispiller an Diagrammer.

erDiagram
    CUSTOMER ||--o{ ORDER : places
    ORDER ||--|{ ORDER_LINE : contains
    PRODUCT ||--o{ ORDER_LINE : "ordered as"

ACID

ACID beschreift déi véier Garantien, déi eng Transaktioun bitt.

flowchart LR
    T[Transaction] --> A[Atomicity]
    T --> C[Consistency]
    T --> I[Isolation]
    T --> D[Durability]

Atomicitéit — all Aussoen erfollegen oder keng.
Konsistenz — d'Datebank wiesselt vun engem gültege Zoustand an en aneren.
Isolatioun — parallel Transaktioune stéieren sech net.
Durabilitéit — committéiert Daten iwwerliewen e Crash.

stateDiagram-v2
    [*] --> Active
    Active --> Committed: COMMIT
    Active --> Aborted: ROLLBACK
    Committed --> [*]
    Aborted --> [*]

BEGIN;

UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;

COMMIT;

Primärschlësselen

E Primärschlëssel identifizéiert all Zeil eendeiteg. En ass ëmmer NOT NULL an eendeiteg. Léiwer e Surrogat-Schlëssel (Identity, UUID) wéi en natierleche Schlëssel, dee sech ännere kann.

CREATE TABLE customer (
  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  email VARCHAR(255) NOT NULL UNIQUE
);

Kompositschlësselen identifizéieren eng Zeil iwwer méi Spalten zesummen — dee klassesche Fall vun enger Join-Tabelle.

CREATE TABLE order_line (
  order_id BIGINT NOT NULL,
  product_id BIGINT NOT NULL,
  quantity INT NOT NULL,
  PRIMARY KEY (order_id, product_id)
);

Friemschlësselen

E Friemschlëssel garantéiert d'referenziell Integritéit: all Wäert muss an der referenzéierter Tabelle existéieren. ON DELETE / ON UPDATE soen der Engine, wat se maache soll, wann den Elter sech ännert.

CREATE TABLE "order" (
  id BIGINT PRIMARY KEY,
  customer_id BIGINT NOT NULL
    REFERENCES customer(id) ON DELETE CASCADE
);

CASCADE läscht d'Kand, wann den Elter verschwënnt; SET NULL läscht d'Spalt; RESTRICT blockéiert d'Ännerung.

SQL-Commande: DDL, DQL, DML, DCL, TCL

SQL deelt sech a fënnef Commandefamillen op.

DDL — Data Definition Language

Definéiert an ännert de Schema.

CREATE TABLE product (
  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  price NUMERIC(10, 2) NOT NULL
);

ALTER TABLE product ADD COLUMN active BOOLEAN DEFAULT true;

DROP TABLE product;

DQL — Data Query Language

Liest Daten. Et ass einfach SELECT.

SELECT id, name, price
FROM product
WHERE active
ORDER BY price DESC;

DML — Data Manipulation Language

Ännert d'Donnéeën: INSERT, UPDATE, DELETE.

INSERT INTO product (name, price) VALUES ('Keyboard', 89.90);

UPDATE product SET price = 79.90 WHERE name = 'Keyboard';

DELETE FROM product WHERE id = 1;

UPDATE an DELETE mussen eng WHERE-Klausel droen — ouni si betreffen se all Zeil.

DCL — Data Control Language

Geréiert Permissiounen mat GRANT a REVOKE.

GRANT SELECT, INSERT, UPDATE ON product TO app_user;
REVOKE DELETE ON product FROM app_user;

TCL — Transaction Control Language

Kontrolléiert Transaktioune mat COMMIT, ROLLBACK a SAVEPOINT.

BEGIN;

UPDATE accounts SET balance = balance - 100 WHERE id = 1;
SAVEPOINT before_credit;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;

ROLLBACK TO before_credit;
COMMIT;

Joins (Jointuren)

Joins kombinéieren Zeilen aus zwou oder méi Tabellen iwwer eng Join-Bedingung.

-- INNER JOIN: only matching rows
SELECT c.name, o.id AS order_id, o.total
FROM customer c
JOIN "order" o ON o.customer_id = c.id;

-- LEFT JOIN: all customers, even without orders (NULL on the right)
SELECT c.name, o.id AS order_id
FROM customer c
LEFT JOIN "order" o ON o.customer_id = c.id;

-- RIGHT JOIN: all orders, even without a customer (NULL on the left)
SELECT c.name, o.id AS order_id
FROM customer c
RIGHT JOIN "order" o ON o.customer_id = c.id;

-- FULL OUTER JOIN: both sides, NULL where missing
SELECT c.name, o.id AS order_id
FROM customer c
FULL OUTER JOIN "order" o ON o.customer_id = c.id;

-- CROSS JOIN: every combination of rows
SELECT c.name, p.name
FROM customer c
CROSS JOIN product p;

-- self join: employees and their managers
SELECT e.name AS employee, m.name AS manager
FROM employee e
LEFT JOIN employee m ON m.id = e.manager_id;

Joins passen natierlech mat Aggregatioun zesummen:

-- order totals from line items
SELECT o.id, SUM(ol.quantity * p.price) AS total
FROM "order" o
JOIN order_line ol ON ol.order_id = o.id
JOIN product p ON p.id = ol.product_id
GROUP BY o.id;

Benotzt Table-Aliase (c, o) fir d'Liesbarkeet, an haalt d'Join-Bedingung am ON amplaz am WHERE, fir datt d'Intent kloer bleift.

Indexen

En Index beschleunegt Lookups op Käschte vu Schreifperformance a Späicher. Déi meescht Datebanke benotzen e B-tree, deen d'Daten sortéiert hält fir séier Equality- a Range-Scans.

flowchart TD
    R[Root] --> N1[Node 10 - 20]
    R --> N2[Node 20 - 30]
    N1 --> L1[Leaf 10]
    N1 --> L2[Leaf 15]
    N2 --> L3[Leaf 20]
    N2 --> L4[Leaf 25]

Unique Index — setzt Eendeitegkeet duerch wéi en Unique Constraint.
Kompositindex — deckt méi Spalten, vu lénks no riets.
Covering Index — späichert zousätzlech Spalten, fir d'Tabelle ni ze beréieren.
Partiellen Index — indexéiert nëmmen d'Zeilen, déi eng Bedingung erfëllen.

CREATE UNIQUE INDEX idx_customer_email ON customer(email);

CREATE INDEX idx_order_customer ON "order"(customer_id);

CREATE INDEX idx_order_line_product
  ON order_line(product_id) INCLUDE (quantity);

Eng einfach Reegel: indexéiert d'Spalten, déi Dir filtert (WHERE), joint (JOIN) a sortéiert (ORDER BY).

Triggers

En Trigger leeft automatesch virun oder no INSERT, UPDATE oder DELETE. Si sinn ideal fir Audit-Loggen an ofgeleet Spalten. A PostgreSQL lieft d'Logik an enger Trigger-Funktioun.

CREATE FUNCTION audit_order() RETURNS trigger AS $$
BEGIN
  INSERT INTO audit_log (table_name, row_id, action, changed_at)
  VALUES ('order', COALESCE(NEW.id, OLD.id), TG_OP, now());
  RETURN COALESCE(NEW, OLD);
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER order_audit
AFTER INSERT OR UPDATE OR DELETE ON "order"
FOR EACH ROW EXECUTE FUNCTION audit_order();

Funktiounen

Funktiounen si widderverwendbar, komponéierbar Stécker Logik, déi e Wäert zeréckginn.

Eng Skalarfunktioun:

CREATE FUNCTION order_total(order_id BIGINT) RETURNS NUMERIC AS $$
  SELECT COALESCE(SUM(price * quantity), 0)
  FROM order_line
  JOIN product ON product.id = order_line.product_id
  WHERE order_line.order_id = order_total.order_id;
$$ LANGUAGE sql;

Eng Table-Funktioun (gëtt e Set vun Zeilen zeréck):

CREATE FUNCTION customer_orders(customer_id BIGINT)
RETURNS TABLE(order_id BIGINT, total NUMERIC, placed_at TIMESTAMPTZ) AS $$
  SELECT id, total, placed_at
  FROM "order"
  WHERE customer_id = customer_orders.customer_id;
$$ LANGUAGE sql;

Stored Procedures

Proceduren sinn ewéi Funktiounen, kënnen awer hir eege Transaktioune geréieren a mussen kee Wäert zeréckginn. Benotzt se fir méi-Schrëtt-, transaktional Operatiounen.

CREATE PROCEDURE transfer(from_acc BIGINT, to_acc BIGINT, amount NUMERIC)
LANGUAGE plpgsql
AS $$
BEGIN
  UPDATE accounts SET balance = balance - amount WHERE id = from_acc;
  UPDATE accounts SET balance = balance + amount WHERE id = to_acc;
  COMMIT;
END;
$$;

Isolatiounsniveauen

Isolatioun kontrolléiert, wéi vill parallel Transaktioune vunenee gesinn.

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;

Read uncommitted — kann net-committéiert Daten liesen (dirty reads).
Read committed — all Ausso gesäit e stabilen Snapshot.
Repeatable read — déi ganz Transaktioun gesäit ee Snapshot.
Serializable — Transaktioune behuele sech, wéi wa se eng no där anerer lafen.

Wichteg Praktiken

Benotzt Stored Procedures fir de CRUD — zentraliséiert d'Datelogik op enger Plaz a gëtt Zougang op d'Prozedur amplaz op d'Tabelle.
Benotzt parametriséiert Querien — concatenéiert ni Benotzerinput an SQL; bindt Wäerter als Parameter, fir SQL-Injektioun ze verhënneren.
Gitt Permissiounen — loosst Benotzer CRUD-Prozeduren ausféieren, ouni direkten Tabellenzougang.

-- parameterized query: the value is bound as data, not SQL
SELECT id, name FROM customer WHERE email = $1;

-- grant execution through a procedure, not the table
GRANT EXECUTE ON PROCEDURE create_customer TO app_user;
REVOKE ALL ON customer FROM app_user;

Parametriséiert Aussoen trennen de SQL vun de Wäerter, sou datt Input als Daten behandelt gëtt. Kombinéiert mat Prozedurniveau-Permissioune bleift d'Uewerfläch kleng an auditéierbar.

Zum Schluss

ACID gëtt Iech Korrektheet; Schlësselen ginn Integritéit; Indexe ginn Tempo; Triggers, Funktiounen a Prozedure ginn eng widderverwendbar, duerchgesat Logik. Dat alles ze beherrschen — an d'Kompromësser ze kennen — ënnerscheet en DBA vun engem Entwéckler, deen zoufälleg SQL schreift.

Tailwind CSS fir Experten: Best Practices an Tools fir eng schéin UI

Wed, 02 Sep 2026 00:00:00 GMT

Tailwind CSS v4 ass op eng CSS-first Configuratioun an e méi séieren Engine gewiesselt. Dëse Guide deckt d'Musteren an d'Tools of, déi eng Tailwind-Codebasis propper, skaléierbar an ugehueleg halen.

Tailwind CSS v4

Versioun 4 gëtt komplett am CSS konfiguréiert. Kee tailwind.config.js; Dir importéiert en einfach an deklaréiert Är Design Tokens.

@import "tailwindcss";

@theme {
  --color-primary: #6366f1;
  --font-sans: 'Inter', ui-sans-serif, system-ui, sans-serif;
  --radius-lg: 0.75rem;
}

Eegen Utilities a Variante ginn am selwechte Fichier deklaréiert.

@utility container {
  margin-inline: auto;
  padding-inline: 1rem;
}

@custom-variant dark (&:where(.dark, .dark *));

Design Tokens

Definéiert Tokens eemol a referenzéiert se iwwerall, fir datt Faarwen an Ofstänn konsequent bleiwen. Arbiträr Wäerter wéi bg-[#6366f1] sinn fir Eemolegkeeten, net fir en Design System.

@theme {
  --color-primary-500: #6366f1;
  --color-primary-600: #4f46e5;
  --spacing-18: 4.5rem;
}

Da funktionéieren bg-primary-500, p-18 an text-primary-600.

Utility-first Best Practices

Komponéiert kleng Utilities amplaz eegent CSS ze schreiwen, awer extrahéiert e Muster, soubal et sech widderhëlt.

<button class="inline-flex items-center gap-2 rounded-lg bg-primary-600 px-4 py-2 text-sm font-medium text-white hover:bg-primary-500">
  Save
</button>

Reegele fir et erhalbar ze halen:

Benotzt Tokens, keng réi Wäerter.
Sortéiert d'Klassen automatesch (kuckt de Prettier-Plugin drënner).
Léiwer gap/space-* wéi manuell Margen.
Haalt responsive- an Zoustandsvariante no bei de Basisklassen.

Widderverwendbar Komponenten

Wann e Muster sech widderhëlt, extrahéiert et. Tailwind bitt dräi Niveauen.

Komponentklassen mat @apply:

.btn {
  @apply inline-flex items-center gap-2 rounded-lg px-4 py-2 text-sm font-medium;
}
.btn-primary {
  @apply bg-primary-600 text-white hover:bg-primary-500;
}

Klassvariante mat class-variance-authority (gutt fir React/Solid):

import { cva, type VariantProps } from 'class-variance-authority'

const button = cva('inline-flex items-center rounded-lg font-medium', {
  variants: {
    variant: {
      primary: 'bg-primary-600 text-white hover:bg-primary-500',
      ghost: 'border border-gray-300 text-gray-700',
    },
    size: {
      sm: 'px-3 py-1.5 text-sm',
      md: 'px-4 py-2 text-base',
    },
  },
  defaultVariants: { variant: 'primary', size: 'md' },
})

Klassen zesummeféieren mat clsx + tailwind-merge:

import { clsx, type ClassValue } from 'clsx'
import { twMerge } from 'tailwind-merge'

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

// later conflicting class wins
cn('px-4', 'px-2') // 'px-2'

Den Komponenten-Ecosystem

Dir musst net all Primitiv vun Null bauen.

shadcn/ui — Copy-Paste-Komponenten, op Radix baséiert, déi Dir besëtzt an editéiert.
Radix UI / Headless UI — accessibel, ongestylt Primitiver.
daisyUI — fäerdeg, thematiséierbar Komponentklassen.

Kombinéiert se mat Tailwind fir voll Kontroll ouni d'Accessibilitéitslaascht.

Tooling

@tailwindcss/vite — de Vite-Plugin (eemol addéieren, vergiessen).
prettier-plugin-tailwindcss — sortéiert Utility-Klassen fir eng konsequent Reiefolleg.
clsx + tailwind-merge — komponéieren an deduplizéieren.
class-variance-authority — typiséiert Komponentvariante.

npm install -D tailwindcss @tailwindcss/vite prettier-plugin-tailwindcss
npm install clsx tailwind-merge class-variance-authority

Schéin maachen

Eng schéin UI ass virun allem Konsequenz, net Dekoratioun.

Typographie — eng Fontskala, eng gemittlech Zeilenhéicht, e begrenzten Mooss.
Ofstänn — bleift op der 4px-Skala; alignéiert op e Gitter.
Faarf — eng kleng Palette mat engem Akzent; kontrolléiert de Kontrast.
Beweegung — kuerz, subtil Iwwergäng (transition, duration-150).
Dark Mode — designéiert béid, gedriwwen duerch d'dark-Variante.

Fäerdeg Produktiounsbeispiller

E komplette, kopéierbare Setup: Design Tokens, en cn-Hëllefsmëttel a typiséiert Komponenten.

Theme Tokens (theme.css):

@import "tailwindcss";

@theme {
  --color-brand-50: #eef2ff;
  --color-brand-500: #6366f1;
  --color-brand-600: #4f46e5;
  --color-brand-700: #4338ca;

  --color-surface: #ffffff;
  --color-ink: #0f172a;
  --color-muted: #64748b;

  --font-sans: 'Inter', ui-sans-serif, system-ui, sans-serif;
  --shadow-card: 0 1px 2px rgb(15 23 42 / 0.06), 0 4px 12px rgb(15 23 42 / 0.08);
}

@custom-variant dark (&:where(.dark, .dark *));

Button (button.tsx) mat typiséierte Varianten:

import { cva, type VariantProps } from 'class-variance-authority'
import { cn } from './cn'

const buttonVariants = cva(
  'inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-brand-500 disabled:pointer-events-none disabled:opacity-50',
  {
    variants: {
      variant: {
        primary: 'bg-brand-600 text-white hover:bg-brand-500',
        secondary: 'border border-slate-200 bg-surface text-ink hover:bg-slate-50',
        ghost: 'text-ink hover:bg-slate-100',
        destructive: 'bg-red-600 text-white hover:bg-red-500',
      },
      size: {
        sm: 'h-8 px-3 text-xs',
        md: 'h-10 px-4',
        lg: 'h-12 px-6 text-base',
      },
    },
    defaultVariants: { variant: 'primary', size: 'md' },
  },
)

export interface ButtonProps
  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
    VariantProps<typeof buttonVariants> {}

export function Button({ className, variant, size, ...props }: ButtonProps) {
  return (
    <button
      className={cn(buttonVariants({ variant, size }), className)}
      {...props}
    />
  )
}

Card an Input (card.tsx, input.tsx):

export function Card({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) {
  return (
    <div
      className={cn(
        'rounded-md border border-slate-200 bg-surface p-6 shadow-card',
        className,
      )}
      {...props}
    />
  )
}

export function Input({ className, ...props }: React.InputHTMLAttributes<HTMLInputElement>) {
  return (
    <input
      className={cn(
        'h-10 w-full rounded-md border border-slate-200 bg-surface px-3 text-sm text-ink placeholder:text-muted focus:outline-none focus:ring-2 focus:ring-brand-500',
        className,
      )}
      {...props}
    />
  )
}

Dës Tokens a Komponente bilden d'Basis vun engem richtegen Design System: konsequent Faarwen, typiséiert Varianten an eng eenzeg Quell vun der Wourecht.

Zum Schluss

Dem Tailwind v4 säi CSS-first Setup, Design Tokens a Komponentenextraktioun (mat cva a cn) ginn Iech e System, deen skaléiert. Füügt shadcn/Radix fir Primitiver an de Prettier-Plugin fir d'Reiefolleg derbäi, an Dir kritt eng schéin, erhalbar UI.

TypeScript a JavaScript fir Experten: modern Features an Architektur

Wed, 02 Sep 2026 00:00:00 GMT

JavaScript kritt dauernd kleng, prezis Features, an TypeScript mécht aus Runtime-Feeler ëmmer méi Compile-Zäit-Feeler. Dëse Guide deckt dat of, wat haut fir Front-End-Code an der Produktioun wichteg ass, mat Beispiller.

flowchart TD
    JS[JavaScript] --> A[Modern built-ins]
    A --> A1[toSorted / at / groupBy]
    A --> A2[Promise.withResolvers]
    TS[TypeScript] --> B[The type system]
    B --> B1[Discriminated unions]
    B --> B2[Utility types]
    TS --> C[Architecture]
    C --> C1[Result types]
    C --> C2[Exhaustive checks]

JavaScript: déi modern Essentiell

Optional Chaining an Nullish Coalescing

Verschachtelt Daten liesen ouni ze explodéieren, an nëmmen op null/undefined zréckfalen.

const city = user?.address?.city
const label = name ?? 'Anonymous'
const retries = config?.retries ?? 3

Logesch Zouwäisung

Eng Variabel nëmmen ännere, wann se falsch, nullish oder wouer ass.

user.nickname ||= user.firstName
settings.theme ??= 'dark'

Net-mutéierend Array-Methoden

toSorted, toReversed, toSpliced a with ginn nei Arrays zeréck amplaz ze mutéieren, wat perfekt mat immutablem Zoustand zesummegeet.

const sorted = items.toSorted((a, b) => a.score - b.score)
const reversed = items.toReversed()
const first = items.at(0)
const last = items.at(-1)

Gruppéieren a Klonen

Object.groupBy verdeelt eng Kollektioun an enger Zeil, an structuredClone macht eng déif Kopie ouni JSON-Gefuddel.

const byStatus = Object.groupBy(orders, (o) => o.status)

const copy = structuredClone(original)

Promise-Hëllefen

Promise.withResolvers gëtt Iech d'resolve/reject-Funktiounen, ouni eng Promise an e Konstruktor ze wéckelen.

const { promise, resolve, reject } = Promise.withResolvers<string>()

async function nextMessage(): Promise<string> {
  return promise
}

Array.fromAsync mécht aus engem asynchrone Iterable en Array.

const lines = await Array.fromAsync(stream)

Promises an Observables

Promises

Eng Promise representéiert e Wäert, deen méi spéit verfügbar ass. async/await flaacht d'Callbacken of.

function fetchUser(id: number): Promise<User> {
  return fetch(`/api/users/${id}`).then((res) => res.json())
}

async function loadUser(id: number): Promise<User | null> {
  try {
    return await fetchUser(id)
  } catch (error) {
    console.error('failed to load user', error)
    return null
  }
}

Lausst onofhängeg Aarbecht parallel an sammelt d'Resultater:

const [a, b, c] = await Promise.all([
  fetchUser(1),
  fetchUser(2),
  fetchUser(3),
])

Observables

Observables (RxJS) modelléieren e Stroum vu Wäerter iwwer d'Zäit. Baut Pipelines aus Operatoren an deabonnéiert Iech ëmmer.

import { from, fromEvent } from 'rxjs'
import { debounceTime, filter, map, switchMap } from 'rxjs/operators'

const search$ = fromEvent<InputEvent>(input, 'input').pipe(
  debounceTime(300),
  map((event) => (event.target as HTMLInputElement).value),
  filter((term) => term.length >= 3),
  switchMap((term) =>
    from(fetch(`/api/search?q=${term}`).then((res) => res.json())),
  ),
)

const subscription = search$.subscribe({
  next: (results) => console.log(results),
  error: (err) => console.error(err),
})

subscription.unsubscribe()

Eng Promise produzéiert ee Wäert; en Observable produzéiert méi iwwer d'Zäit. Benotzt Promise fir eenzel Resultater, Observables fir Eventer a Stréim.

TypeScript: den Typsystem, deen zielt

`unknown` schléit `any`

any schalt den Typprüfer aus; unknown zwéngt Iech, fir d'éischt anzeschränken.

function parse(value: unknown): string {
  if (typeof value === 'string') return value
  throw new Error('not a string')
}

`satisfies` an `as const`

satisfies prüft en Objet géint en Typ ouni en ze verbreeden, an as const sperrt d'Wäerter op hir Literaltypen.

const palette = {
  primary: '#c770f0',
  danger: '#ef4444',
} satisfies Record<string, string>

const routes = ['/', '/about', '/blog'] as const
type Route = (typeof routes)[number]

Discriminated Unions

Modelléiert all Zoustand mat engem gemeinsame kind-Feld, an de Compiler schränkt fir Iech an — d'Fundament vun typiséierte Reduceren a State-Machinen.

type State =
  | { kind: 'idle' }
  | { kind: 'loading' }
  | { kind: 'success'; data: User[] }
  | { kind: 'error'; message: string }

function render(state: State): string {
  switch (state.kind) {
    case 'idle': return 'Waiting…'
    case 'loading': return 'Loading…'
    case 'success': return state.data.map((u) => u.name).join(', ')
    case 'error': return state.message
  }
}

Type Predicates

Schränkt unknown sécher op eng konkret Form an.

function isUser(value: unknown): value is User {
  return typeof value === 'object' && value !== null && 'id' in value
}

Template Literal Types

Baut String-Typen aus Unione — ideal fir typiséiert Routen an API-Pied.

type Route = `/api/${'users' | 'orders'}/${string}`

`const` Typparameter

Haalt Tuple-Literale prezis, ouni iwwerall as const ze verstreien.

function preserve<const T>(items: T[]): T[] {
  return items
}

const pair = preserve([1, 'two']) // [number, string]

Utility Types

Komponéiert nei Typen aus existéierende, amplaz se vun Hand ze schreiwen.

type UserInput = Omit<User, 'id' | 'createdAt'>
type PartialUser = Partial<User>
type ReadonlyUser = Readonly<User>

Rezent TypeScript-Features

Standard Decorators

Decorators sinn elo Deel vun der Sprooch, ouni experimentelle Fändel.

function logged(target: unknown, context: ClassMethodDecoratorContext) {
  // wrap the method
}

class Service {
  @logged
  fetchData() {
    /* ... */
  }
}

Explizit Ressourcemanagement

using mécht d'Opraumen deterministesch iwwer Symbol.dispose.

function readFile(path: string) {
  using handle = openFile(path)
  return handle.read()
}

`NoInfer`

Verhënnert, datt de Compiler en Typargument op enger bestëmmter Positioun inferéiert.

declare function createPair<T>(first: T, second: NoInfer<T>): T

const result = createPair('a', 'b') // T is inferred from the first arg only

Architekturmuster

Result Types amplaz Exceptions

Stellt Erfolleg a Feelerschlag am Typ duer, sou datt Oprufer d'Feelerbehandlung net vergiesse kënnen.

type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E }

function divide(a: number, b: number): Result<number> {
  if (b === 0) return { ok: false, error: new Error('division by zero') }
  return { ok: true, value: a / b }
}

Exhaustiv Checks

En never-Hëllefsmëttel garantéiert, datt all Fall behandelt gëtt, wann d'Unioun wiisst.

function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`)
}

// switch (state.kind) { ... default: assertNever(state) }

Branded Types

Verhënnert, datt een Identifikateure vermëscht, déi de selwechte Basistyp deelen.

type UserId = string & { readonly __brand: 'UserId' }
type OrderId = string & { readonly __brand: 'OrderId' }

function toUserId(id: string): UserId {
  return id as UserId
}

Immutabilitéit standardméisseg

Léiwer readonly, as const an net-mutéierend Methoden, sou datt Zoustandsännerungen explizit sinn.

interface Config {
  readonly apiUrl: string
  readonly retries: number
}

ESM an Tree-Shaking

Benotzt ES-Moduler an named Imports, fir datt Bundler onbenotzte Code kënnen ewechhuelen, a léiwer Type-Only-Imports, fir datt Typpen ni an d'Runtime-Bundles kommen.

import type { User } from './models'
import { fetchUsers } from './api'

Zum Schluss

De modernen Front-End-Expert verléisst sech op déi nei JavaScript-APIen fir Dateveraarbechtung, an op TypeScript seng Discriminated Unions, Utility Types a Result Types, fir Feeler op d'Compile-Zäit ze verleeën. Wann Dir dës Muster adoptéiert, gëtt Äre Code méi kleng, méi sécher a vill méi einfach ze verstoen.

D'SOLID-Prinzipien an der Praxis

Sat, 15 Aug 2026 00:00:00 GMT

D'SOLID-Prinzipie sinn e Set vu fënnef Design-Regelen, déi hëllefen, erhalbar a skaléierbar Software ze produzéieren.

Prinzip	Fokus
SRP	Nëmmen ee Grond fir ze änneren
OCP	Oppen fir Extensioun, zou fir Ännerung
LSP	Subtypen mussen austauschbar sinn
ISP	Kleng, geziilt Interfaces
DIP	Vun Abstraktiounen ofhänken, net vu Konkretiounen

Single Responsibility

Eng Klass soll nëmmen ee Grond hunn, fir sech z'änneren.

class Invoice {
    void calculateTotal() { /* ... */ }
    void print() { /* violates SRP */ }
}

Splitt print() an eng eege InvoicePrinter-Klass an all Concern kann sech onofhängeg weiderentwéckelen.

Open/Closed Principle (OCP)

E Modul soll oppen fir Extensioun sinn, awer zou fir Ännerung — neit Verhalen kënnt duerch neie Code derbäi, net duerch Ëmschreiwe vum existéierende.

public interface IDiscount
{
    decimal Apply(Order order);
}

public class SeasonalDiscount : IDiscount
{
    public decimal Apply(Order order) => order.Total * 0.10m;
}

public class LoyaltyDiscount : IDiscount
{
    public decimal Apply(Order order) => order.Total * 0.15m;
}

Eng nei Remiss-Art derbäisetzen heescht eng nei Klass derbäisetzen; déi existéierend bleiwen onverännert.

Liskov Substitution (LSP)

Objeten vun engem Subtyp mussen iwwerall gebraucht kënne ginn, wou den Elterentyp erwaart gëtt, ouni iwwerraschend Verhalen.

public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
}

public class Square : Rectangle
{
    public override int Width { set { base.Width = value; base.Height = value; } }
    public override int Height { set { base.Width = value; base.Height = value; } }
}

E Square ass keen treien Ersatz fir e Rectangle — eng Säit änneren ännert heimlech och déi aner. Modelléiert se getrennt oder hannert enger gemeinsamer Abstraktioun.

Interface Segregation (ISP)

E Client soll net gezwonge sinn, vu Methoden ofzehänken, déi en ni benotzt. Léiwer méi schmuel Interfaces wéi eent breet.

// one fat interface
public interface IWorker
{
    void Work();
    void Eat();
}

// focused interfaces
public interface IWorkable
{
    void Work();
}

public interface IEatable
{
    void Eat();
}

Elo implementéiert all Klass nëmmen dat, wat se wierklech brauch.

Dependency Inversion

Héich-Niveau-Module sollen net vun Déif-Niveau-Modulen ofhänken. Béid sollen vun Abstraktiounen ofhänken.

public interface IClock
{
    DateTime UtcNow { get; }
}

public class SystemClock : IClock
{
    public DateTime UtcNow => DateTime.UtcNow;
}

D'Business-Logik bleift esou testbar an decoupled vun der Auer.

Méi detailléiert Artikele kommen nach — dësen mécht just den Optakt.

Mermaid-Diagrammer an Ären Artikelen

Sun, 12 Jul 2026 00:00:00 GMT

All Code-Blöck mat dem Tag mermaid gëtt als SVG-Diagramm gerëndert. Hei ass en Iwwerbléck iwwer dat, wat verfügbar ass.

Flowchart

flowchart LR
    A[Start] --> B{Logged in?}
    B -- Yes --> C[Dashboard]
    B -- No --> D[Login page]
    D --> E[Submit credentials]
    E --> B

Sequenz

sequenceDiagram
    autonumber
    participant U as User
    participant A as API
    participant D as Database
    U->>A: POST /orders
    A->>D: INSERT order
    D-->>A: ok
    A-->>U: 201 Created

Klassendiagramm

classDiagram
    class Order {
        +id: string
        +total: number
        +submit()
    }
    class LineItem {
        +sku: string
        +qty: number
    }
    Order "1" --> "*" LineItem

Zoustanksdiagramm

stateDiagram-v2
    [*] --> Draft
    Draft --> Published: publish()
    Published --> Archived: archive()
    Archived --> [*]

Entitéits-Bezéiung

erDiagram
    CUSTOMER ||--o{ ORDER : places
    ORDER ||--|{ LINE_ITEM : contains
    PRODUCT ||--o{ LINE_ITEM : "ordered as"

Gantt-Diagramm

gantt
    title Release plan
    dateFormat YYYY-MM-DD
    section Backend
    API design       :a1, 2026-07-01, 7d
    Implementation   :a2, after a1, 14d
    section Frontend
    UI design        :b1, 2026-07-01, 7d
    Implementation   :b2, after b1, 14d

Kreesdiagramm

pie title Tech stack usage
    "Java" : 40
    "C#" : 35
    "Python" : 15
    "Other" : 10

Git-Graph

gitGraph
    commit id: "init"
    branch feature
    checkout feature
    commit id: "feat: parser"
    checkout main
    commit id: "fix: typo"
    merge feature

Mindmap

mindmap
  root((Blog))
    Content
      Markdown
      Frontmatter
    Rendering
      Code highlighting
      Mermaid

Zäitlinn

timeline
    title Project milestones
    2026 Q2 : Kickoff
    2026 Q3 : Beta release
    2026 Q4 : General availability

Setzt ee vun dëse Beispiller an e mermaid-Block an et gëtt op der Säit gerëndert.

E CI/CD-Pipeline mat GitHub Actions designen

Fri, 05 Jun 2026 00:00:00 GMT

Äre Delivery-Pipeline ze automatiséieren ewechzehuelen manuell Schrëtt a mécht all Merge reproduzéierbar. Hei ass de Pipeline, deen ech fir Nieweprojeten benotzen.

Iwwerbléck

flowchart TD
    P[Push to main] --> L[Lint]
    L --> T[Unit tests]
    T --> S[SonarQube scan]
    S --> B[Build image]
    B --> V[Vulnerability scan]
    V --> D{Pass?}
    D -- Yes --> E[Deploy]
    D -- No --> R[Notify & block]

D'Workflow-Datei

name: ci

on:
  push:
    branches: [main]
  pull_request:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npm run lint
      - run: npm run test -- --coverage
      - run: npm run build

Release-Prozess

Releases ginn aus Tags geschnidden a verfollegen e stufenweise Rollout.

gantt
    title Release rollout
    dateFormat  YYYY-MM-DD
    section Deploy
    Tag release        :2026-06-01, 1d
    Staging            :2d
    Canary (5%)        :2d
    Full rollout       :2d

Rollback-Sequenz

Wann eng Release brécht, ass de Rollback komplett automatiséiert.

sequenceDiagram
    participant M as Monitoring
    participant O as Orchestrator
    participant K as Kubernetes
    M->>O: error rate > 1%
    O->>K: kubectl rollout undo
    K-->>O: rollout reverted
    O-->>M: healthy again

Haalt de Pipeline séier, deterministesch an observéierbar — alles anert kënnt dann eleng.

Wëllkomm op mengem technesche Blog

Tue, 02 Jun 2026 00:00:00 GMT

Firwat e Blog?

Ech hunn dëse Raum gebaut, fir d'Notizen a Lektiounen ze deelen, déi ech beim Schaffen un Nieweprojeten a Produktiounssystemer sammelen. Et gi déif Ablécker iwwer SolidJS, .NET, Java, Angular an d'Tools dohannert.

D'Kraaft vu Markdown

D'Artikele ginn als Markdown geschriwwen, sou datt ech mech op den Inhalt konzentréiere kann. De Renderer ënnerstëtzt dat Wichtegst:

Iwwerschrëften, Lëschten an Zitater
Tabellen
Linken a Biller
Code-Bléck mat Syntax-Highlighting
Mermaid-Diagrammer

Syntax-Highlighting

Code-Bléck ginn automatesch no der Sprooch gefierft:

export interface Feature<T> {
  run(input: T): Promise<T>
}

export const identity = <T,>(value: T): T => value

public sealed class Greeter
{
    public string Hello(string name) => $"Hello, {name}!";
}

Mermaid-Diagrammer

Diagrammer ginn aus engem mermaid-Block gerëndert:

flowchart TD
    A[Write Markdown] --> B{Contains mermaid?}
    B -- Yes --> C[Render SVG diagram]
    B -- No --> D[Render plain HTML]
    C --> E[Show article]
    D --> E

Sequenz-Diagrammer funktionéieren och:

sequenceDiagram
    participant Client
    participant API
    participant Cache
    Client->>API: GET /posts
    API->>Cache: lookup
    alt hit
        Cache-->>API: data
    else miss
        API-->>API: build response
        API->>Cache: store
    end
    API-->>Client: 200 OK

Zum Schluss

Dat war d'Basis. Bleift drun fir méi detailléiert technesch Artikelen.