docs: archive outdated reports and organize references

Archived several outdated reports (`Ping-Service_Impl_01-2026.md`, `Frontend_Integration_Status.md`, etc.) and added archival notes and references to updated documents. Introduced a centralized reference structure for tech stack documentation, consolidating files under `01_Architecture/Reference/Tech_Stack`. Added new resources (`Gradle_Kotlin_DSL_Primer`, `Kotlin_2-3-0_ReleaseNotes`) for improved project organization and clarity.
This commit is contained in:
2026-01-23 13:34:20 +01:00
parent e8124c047a
commit aba5b5c7a0
29 changed files with 816 additions and 3598 deletions
@@ -0,0 +1,115 @@
---
type: Reference
status: ACTIVE
owner: DevOps Engineer
tags: [gradle, kotlin, dsl, build]
---
# Gradle Kotlin DSL Primer
**Quelle:** [Original Gradle Documentation](https://docs.gradle.org/current/userguide/kotlin_dsl.html)
**Kontext:** Dieses Dokument dient als Referenz für die im Projekt verwendete Gradle Kotlin DSL. Es fasst die wichtigsten Konzepte und Syntax-Elemente zusammen.
---
Gradles Kotlin DSL offers an alternative to the traditional Groovy DSL, delivering an enhanced editing experience in supported IDEs.
## Key Concepts
### Script File Names
* Groovy DSL: `.gradle`
* Kotlin DSL: `.gradle.kts`
To activate the Kotlin DSL, use the `.gradle.kts` extension for your build scripts, settings file (`settings.gradle.kts`), and initialization scripts (`init.gradle.kts`).
### Type-safe Model Accessors
The Kotlin DSL replaces Groovy's dynamic resolution with type-safe model accessors for elements contributed by plugins (configurations, tasks, extensions). This provides better IDE support (code completion, refactoring).
**Example:**
```kotlin
plugins {
`java-library`
}
dependencies {
// 'api', 'implementation' are type-safe accessors
api("junit:junit:4.13")
implementation("org.apache.commons:commons-lang3:3.12.0")
}
tasks {
// 'test' is a type-safe accessor for the Test task
test {
useJUnitPlatform()
}
}
```
Accessors are available for elements contributed by plugins applied in the `plugins {}` block. For elements created dynamically later in the script, you must fall back to string-based lookups:
```kotlin
configurations.create("custom")
dependencies {
"custom"("com.google.guava:guava:32.1.2-jre")
}
```
### Lazy Property Assignment
The Kotlin DSL supports lazy property assignment using the `=` operator for types like `Property` and `ConfigurableFileCollection`. This is the preferred way over the `set()` method.
```kotlin
// Instead of:
// javaVersion.set(JavaLanguageVersion.of(17))
// Use:
javaVersion = JavaLanguageVersion.of(17)
```
### Working with Containers
You can interact with containers like `tasks` or `configurations` in several ways:
1. **Container API (using `named` and `register`):**
```kotlin
tasks.named<Test>("test") {
testLogging.showExceptions = true
}
tasks.register<Copy>("myCopy") {
from("source")
into("destination")
}
```
2. **Delegated Properties (using `by existing` and `by registering`):**
```kotlin
val test by tasks.existing(Test::class) {
testLogging.showStackTraces = true
}
val myCopy by tasks.registering(Copy::class) {
from("source")
into("destination")
}
```
### Extra Properties
Access project or task-level extra properties via delegated properties:
```kotlin
// Define an extra property
val myNewProperty by extra("initial value")
// Read an existing extra property
val myExtraProperty: String by extra
```
### Kotlin DSL Plugin (`kotlin-dsl`)
This plugin is essential for developing build logic in Kotlin (e.g., in `buildSrc` or for convention plugins). It automatically applies the Kotlin plugin and adds necessary dependencies like `kotlin-stdlib` and `gradleKotlinDsl()`.
```kotlin
// buildSrc/build.gradle.kts
plugins {
`kotlin-dsl`
}
repositories {
mavenCentral()
}
```
@@ -0,0 +1,79 @@
---
type: Reference
status: ACTIVE
owner: Lead Architect
tags: [kotlin, java, configuration, setup]
---
# Tech-Stack Referenz: Kotlin 2.3.0 & Java 25 (KMP)
**Kontext:** Dieses Dokument beschreibt die notwendigen Konfigurationen, um Kotlin 2.3.0 mit Java 25 in einem Kotlin Multiplatform (KMP) Projekt mit Gradle 9.x zu verwenden.
---
### 1. Kern-Spezifikationen
| Komponente | Version | Status |
| --- |----------| --- |
| **Kotlin** | `2.3.0` | Stabil (K2 Compiler standardmäßig aktiv) |
| **Java (JDK)** | `25` | LTS (Long-Term Support) |
| **Gradle** | `9.2.1` | Erforderlich für JDK 25 Support |
| **Android Plugin (AGP)** | `8.8.0+` | Empfohlen für Gradle 9.x Kompatibilität |
---
### 2. Gradle Konfiguration (`build.gradle.kts`)
Für ein **Kotlin Multiplatform (KMP)** Projekt ist die Java Toolchain-Konfiguration entscheidend, um sicherzustellen, dass der Kotlin-Compiler und die JVM-Targets Java 25 korrekt ansprechen.
```kotlin
plugins {
kotlin("multiplatform") version "2.3.0"
id("com.android.library") version "8.8.0" // Falls Android Target genutzt wird
}
kotlin {
// Globale Toolchain-Definition für alle JVM/Android Targets
jvmToolchain {
languageVersion.set(JavaLanguageVersion.of(25))
}
jvm {
compilations.all {
compilerOptions.configure {
jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_25)
}
}
}
// Weitere Targets (Beispiel iOS)
iosArm64()
iosSimulatorArm64()
}
```
---
### 3. Gradle Wrapper Update
Damit das Projekt Java 25 erkennt, muss der Wrapper auf dem neuesten Stand sein:
**Terminal-Befehl:**
```bash
./gradlew wrapper --gradle-version 9.2.1 --distribution-type all
```
---
### 4. Wichtige Kompatibilitätshinweise
* **IDE-Version:** IntelliJ IDEA 2025.3 (oder neuer) wird für die volle Unterstützung von JDK 25 und dem Kotlin 2.3.0 Plugin empfohlen.
* **K2 Compiler:** Kotlin 2.3.0 nutzt den K2-Compiler.
* **Bytecode:** Java 25 Bytecode wird nur generiert, wenn das `jvmTarget` explizit auf `25` gesetzt ist.
---
### 5. Bekannte Features in diesem Setup
* **Java 25 Features:** Unterstützung für die finalen Versionen von *Scoped Values* und *Structured Concurrency*.
* **Kotlin 2.3.0 Features:** Nutzung von `explicit backing fields` und dem verbesserten `unused return value` Checker.
@@ -0,0 +1,73 @@
---
type: Reference
status: ACTIVE
owner: Lead Architect
tags: [kotlin, release-notes, tech-stack]
---
# What's new in Kotlin 2.3.0
**Quelle:** [Original Kotlin Documentation](https://kotlinlang.org/docs/whatsnew23.html)
**Datum des Dokuments:** 16. Dezember 2025
**Kontext:** Dieses Dokument dient als Referenz für die im Projekt verwendete Kotlin-Version.
---
The Kotlin 2.3.0 release is out! Here are the main highlights:
* **Language:** More stable and default features, unused return value checker, explicit backing fields, and changes to context-sensitive resolution.
* **Kotlin/JVM:** Support for Java 25.
* **Kotlin/Native:** Improved interop through Swift export, faster build time for release tasks, C and Objective-C library import in Beta.
* **Kotlin/Wasm:** Fully qualified names and new exception handling proposal enabled by default, as well as new compact storage for Latin-1 characters.
* **Kotlin/JS:** New experimental suspend function export, `LongArray` representation, unified companion object access, and more.
* **Gradle:** Compatibility with Gradle 9.0 and a new API for registering generated sources.
* **Compose compiler:** Stack traces for minified Android applications.
* **Standard library:** Stable time tracking functionality and improved UUID generation and parsing.
## Language
Kotlin 2.3.0 focuses on feature stabilization, introduces a new mechanism for detecting unused return values, and improves context-sensitive resolution.
### Stable features
The following features have now graduated to Stable:
* Support for nested type aliases
* Data-flow-based exhaustiveness checks for `when` expressions
### Features enabled by default
* Support for `return` statements in expression bodies with explicit return types is now enabled by default.
### Experimental: Unused return value checker
Kotlin 2.3.0 introduces the unused return value checker to help prevent ignored results.
### Experimental: Explicit backing fields
A new syntax for explicitly declaring the underlying field that holds a property's value, simplifying the common backing properties pattern.
## Kotlin/JVM: Support for Java 25
Starting with Kotlin 2.3.0, the compiler can generate classes containing Java 25 bytecode.
## Kotlin/Native
* **Improved Swift Export:** Direct mapping for native enum classes and variadic function parameters.
* **C and Objective-C Library Import is in Beta:** Better diagnostics for binary compatibility issues.
* **Faster Build Time:** Up to 40% faster release builds, especially for iOS targets.
## Kotlin/Wasm
* **Fully Qualified Names Enabled by Default:** `KClass.qualifiedName` is now available at runtime without extra configuration.
* **Compact Storage for Latin-1 Characters:** Reduces metadata and binary size.
* **New Exception Handling for `wasmWasi`:** Enabled by default for better compatibility with modern WebAssembly runtimes.
## Kotlin/JS
* **Experimental Suspend Function Export:** Export suspend functions directly to JavaScript using `@JsExport`.
* **`BigInt64Array` for `LongArray`:** Simplifies interop with JavaScript APIs that use typed arrays.
* **Unified Companion Object Access:** Consistent access to companion objects in interfaces across all JS module systems.
## Gradle
* Fully compatible with Gradle 7.6.3 through 9.0.0.
* New experimental API for registering generated sources.
## Standard library
* **Stable Time Tracking:** `kotlin.time.Clock` and `kotlin.time.Instant` are now stable.
* **Improved UUID Generation:** New functions like `Uuid.parseOrNull()`, `Uuid.generateV4()`, and `Uuid.generateV7()`.
## Compose compiler
* **Stack Traces for Minified Android Apps:** The compiler now outputs ProGuard mappings for Compose stack traces when applications are minified by R8.