Autor: Marco Günzel

  • Das 4-Level-Modell beim Clean Core: Strategie und Umsetzung im S/4HANA On-Premise System

    Kategorie: Architecture & Strategy | Lesezeit: ca. 8 Min.

    Wer über S/4HANA-Transformationsstrategien spricht, kommt an einem Begriff nicht mehr vorbei: Clean Core. Das Ziel ist klar – der digitale Kern soll frei von Modifikationen und proprietärem Legacy-Code bleiben, um unterbrechungsfreie Upgrades zu ermöglichen. Doch während Cloud-Editionen diesen Weg strikt erzwingen, stehen Entwickler und Architekten im S/4HANA On-Premise-Umfeld vor der Herausforderung, gewachsene Erweiterungen Schritt für Schritt zu strukturieren. Das 4-Level-Modell bietet hierfür den idealen Kompass.

    1. Das 4-Level-Modell im Überblick

    Das 4-Level-Modell klassifiziert Erweiterungen (Extensions) nach ihrer Nähe zum SAP-Standard und ihrer Auswirkung auf die Upgrade-Fähigkeit. Es teilt Anpassungen in vier klare Stufen ein:

    LevelErweiterungstypTechnologie / MethodeUpgrade-Impact
    Level 1Clean Core Native (On-Stack & Side-by-Side)ABAP Cloud, RAP, Public APIs (C1-released), SAP BTP (CAP)Null (Vollständig upgrade-stabil)
    Level 2Key User ExtensibilityIn-App Extensibility (Custom Fields & Logic, Fiori Tools)Minimal (Absolut upgrade-stabil)
    Level 3Classic Extension (Z-Code nach Clean-Richtlinien)Classic ABAP (ABAP OO, CDS), aber strikte Nutzung frei gegebener APIsGering (Geringer Nacharbeitsaufwand)
    Level 4Legacy / Modification (Non-Clean)Modifikationen, Direct Database Access, unreleased APIs, BAPIs/FUBAHoch (Hoher Nacharbeits- & Testaufwand)

    2. Das 4-Level-Modell in der Praxis: Umgang im S/4HANA On-Premise System

    Im Gegensatz zu S/4HANA Cloud Public Edition lässt die On-Premise-Laufzeitumgebung (sowie die Private Cloud) technisch weiterhin klassische ABAP-Entwicklungen zu. Genau hier liegt das Risiko: Wenn die Syntax nicht eingeschränkt ist, entstehen schleichend wieder Level-4-Erweiterungen. Der pragmatische Umgang mit den vier Leveln im On-Premise-Backend sieht wie folgt aus:

    Level 1: Das primäre Ziel für Neuentwicklungen

    Neuentwicklungen im On-Premise-System sollten konsequent nach den Sprachregeln von ABAP Cloud und dem ABAP RESTful Application Programming Model (RAP) gebaut werden. Entwickler greifen dabei ausschließlich auf frei gegebene Schnittstellen (C1-Release-Status) zu. Werden Erweiterungen ausgegliedert, geschieht dies als Side-by-Side Extensibility auf der SAP Business Technology Platform (BTP) via CAP oder RAP.

    Level 2: Erschließen von In-App-Potentialen

    Kleine Feldweiterungen, einfache Validierungen oder UI-Passungen müssen im On-Premise-System nicht mehr durch klassische Dynpro-Modifikationen oder Z-Tabellen gelöst werden. Fiori-In-App-Tools erlauben es Key-Usern oder Entwicklern, upgrade-sichere Logiken direkt auf dem Stack zu konfigurieren.

    Level 3: Die kontrollierte Übergangszone

    In realen On-Premise-Landschaften fehlen für spezialisierte Branchenprozesse gelegentlich C1-released APIs. In diesem Fall greift Level 3: Es wird im klassischen ABAP OO entwickelt, jedoch strikt gekapselt. Sobald die SAP für ein genutztes Modul ein offizielles API nachliefert, kann eine Level-3-Entwicklung sauber durch ein Wrapper-Refactoring auf Level 1 angehoben werden.

    Level 4: Die rote Zone (Isolieren & Eliminieren)

    Level 4 umfasst alten Z-Code, direkte Zugriffe auf SAP-Standardtabellen (z. B. direktes Lesen/Schreiben auf VBAK oder MARA statt via CDS View) und Modifikationen. Für das On-Premise-Team gilt hier das Motto: Einfrieren und schrittweise abbauen.

    3. Konkrete Maßnahmen zur Steuerung im On-Premise-System

    Damit das 4-Level-Modell im Team kein theoretisches Gebilde bleibt, lassen sich in On-Premise-Systemen technische Leitplanken verankern:

    1. ABAP Language Version durchsetzen: Für neue Pakete im ABAP Development Tools (ADT / Eclipse) wird die ABAP Language Version explizit auf ABAP Cloud gesetzt. Der Syntax-Checker verhindert damit automatisch den Zugriff auf unreleased APIs.
    2. ABAP Test Cockpit (ATC) aktivieren: Durch Einbinden der Release-Check-Variant im ATC werden Verweise auf veraltete BAPIs oder direkte Tabellenzugriffe bereits beim Transportauftrag geblockt.
    3. Statische Code-Analyse via abaplint: Nutzen Sie CI/CD-Pipelines (z. B. abapGit in Kombination mit abaplint), um den Quellcode automatisiert auf Clean-Core-Konformität zu prüfen.

    Fazit

    Clean Core im S/4HANA On-Premise-Umfeld bedeutet nicht, über Nacht jeden bestehenden Z-Code neu zu schreiben. Das 4-Level-Modell gibt Entwicklern und Architekten eine klare Orientierung: **Kein neuer Level-4-Code mehr**, Neuentwicklungen konsequent auf **Level 1**, und bestehende Altlasten durch gezielte Refactorings Schritt für Schritt in Richtung Level 3 und 1 verschieben.

  • SAP TechEd 2026: Agentic AI im Reality-Check und was Entwickler jetzt wissen müssen

    Kategorie: Architecture & Strategy | Lesezeit: ca. 6 Min.

    Die SAP TechEd stand ganz im Zeichen der automatisierten Transformation: Mit der Weiterentwicklung von Joule Work, dem Joule Studio und autonomen Multi-Agenten-Workflows rückt Agentic AI in den Mittelpunkt der SAP-Strategie. Doch wie viel Substanz steckt hinter den Versprechungen für Enterprise-Architekten und ABAP-Entwickler wirklich?

    Ein nüchterner Blick auf die diesjährigen Ankündigungen zeigt: Autonome KI-Agenten funktionieren nur dann, wenn die Hausaufgaben in der Systemarchitektur gemacht sind.

    1. Agentic AI & Joule Studio im Reality-Check

    Mit dem Joule Studio stellt SAP Werkzeuge bereit, um eigene autonome Agenten zu orchestrieren, die komplexe Geschäftsprozesse eigenständig analysieren und ausführen können. Aus architektonischer Sicht gibt das Anlass zu folgenden kritischen Fragen:

    • Nicht-Determinismus vs. Transaktionssicherheit: ERP-Prozesse erfordern absolute Verlässlichkeit. Autonome Agenten neigen zu probabilistischen Entscheidungen – im Kernprozess (z. B. Finanzbuchhaltung oder Materialwirtschaft) ist das ein inhärentes Risiko.
    • Die „Context Layer“-Hürde: Ein Agent ist nur so gut wie seine Datenbasis. Historisch gewachsene, inkonsistente Stammdaten im Backend lassen selbst den intelligentesten Agenten scheitern.
    • Governance & IT-Sicherheit: Ohne zentrale Leitplanken droht durch No-Code-Agenten-Baukästen eine neue Welle der Schatten-IT.

    2. Das Bindeglied: Model Context Protocol (MCP)

    Damit KI-Assistenten und Agenten überhaupt sicher auf Entwicklungsumgebungen und Code-Strukturen zugreifen können, setzt die SAP-Welt zunehmend auf standardisierte Protokolle wie das Model Context Protocol (MCP).

    Statt Quellcode unkontrolliert in Chats zu kopieren, binden MCP-Server (ob lokal via abapGit oder über gehostete Endpunkte) Entwicklungsumgebungen wie VS Code und Eclipse ADT kontrolliert und standardisiert an.

    3. Das Fundament bleibt: RAP, OData V4 & Clean Core

    Bei allen KI-Innovationen machten die TechEd-Sessions eines unmissverständlich klar: Jede automatisierte Interaktion im SAP-System greift am Ende auf standardisierte Schnittstellen und Programmiermodelle zu.

    Das ABAP RESTful Application Programming Model (RAP) und OData V4 bilden das unverzichtbare technische Fundament. Wer heute saubere, C1-released APIs und BDEFs baut, schafft die Voraussetzung dafür, dass Agentic AI morgen überhaupt auf dem Backend operieren kann.

    Vertiefende Artikel & Praxis-Guides

    Vertiefende Einblicke in die genannten Architekturelemente finden Sie in unseren Fachbeiträgen:

    • Entwickler-Tooling: Lesen Sie im Beitrag zur MCP-Einrichtung für VS Code und Eclipse, wie Sie KI-Kontext in Ihre IDE holen.
    • Protokoll-Vergleich: Warum OData V4 gegenüber V2 architektonisch überlegen ist, erfahren Sie in unserer Gegenüberstellung.
    • Modernes ABAP: Wie RAP Side Effects für dynamische Fiori-UIs sorgen, zeigt unser Praxis-Guide.

    Fazit

    Die TechEd zeigt eine klare Richtung: Die Zukunft gehört intelligenten Workflows. Doch der Weg dorthin führt über klassische Architekturausrichtung. Wer heute konsequent auf Clean Core, RAP und standardisiertes Tooling setzt, baut das Fundament für die autonome Enterprise von morgen.

  • OData V4 vs. V2 im SAP-Umfeld: Architektonischer Vergleich und Entscheidungshilfe

    Kategorie: Architecture & Strategy | Lesezeit: ca. 6 Min.

    Im modernen SAP-Ökosystem ist das Open Data Protocol (OData) der de facto Standard für die Kommunikation zwischen Backend, Fiori-Oberflächen und externen Cloud-Services. Während OData V2 jahrelang das Fundament der Fiori-Welt bildete, markiert OData V4 den technologischen Standard für moderne S/4HANA-Architekturen. Doch wo liegen die architektonischen Kernunterschiede?

    Die Evolution: Von OData V2 zu V4

    OData V2 wurde von Microsoft als Open Specification Promise gestartet und prägte die frühe S/4HANA- und SAP-Gateway-Ära ab 2013. OData V4 wurde hingegen von OASIS und der ISO standardisiert, bringt eine deutlich schlankere Architektur mit und ist das native Fundament für das ABAP RESTful Application Programming Model (RAP).

    Kernunterschiede im architektonischen Vergleich

    Architektur-MerkmalOData V2 (Gateway / SEGW)OData V4 (RAP / S/4HANA)
    JSON-Payload-StrukturSehr geschwätzig (verbose SAP-Envelope mit d.results)Schlankes, standardkonformes JSON ohne Redundanzen
    Query-CapabilitiesEingeschränkt auf Root-Entities; rudimentäre FilterErweitert auf $expand (inkl. $filter/$top), Lambda-Expressions (any/all), Server-Aggregation ($apply)
    HTTP-Methoden für UpdatesNutzt POST mit Header X-HTTP-METHOD: MERGENutzt standardisiertes HTTP PATCH für Teil-Aktualisierungen (Edit-Semantik)
    DatentypenVeralteter Edm.DateTime-Typ ohne ZeitzonenhandlingPräzise Trennung in Edm.DateTimeOffset, Edm.Date und Edm.TimeOfDay
    Delta Queries / SyncNicht nativ unterstützt (erfordert Custom Logic)Natives Delta-Query-Framework für inkrementelle Daten-Synchronisation

    Architektonische Vorteile von OData V4 im SAP-Kontext

    1. Performance & Bandbreite: Dank des optimierten JSON-Formats und gezielter Metadaten-Kontrolle (minimal, full, none) sinkt das Payload-Volumen drastisch. Das schont Netzwerke und beschleunigt Fiori-Clients.
    2. Präzise Trennung von Funktionen & Aktionen: Während V2 Function Imports oft überladen waren, unterscheidet V4 sauber zwischen Functions (lesend, ohne Side Effects) und Actions (datenändernd). Dies spiegelt sich exakt in RAP-Verhaltensdefinitionen (BDEF) wider.
    3. Erweiterte Abfrage-Möglichkeiten ($expand): In V4 können verschachtelte Relationen direkt mit Filtern und Sortierungen versehen werden (z. B. Liefere Kunden mit den Top-5-Aufträgen absteigend sortiert).

    Wann sollte welcher Standard eingesetzt werden? (Entscheidungsmatrix)

    In der Praxis stellt sich oft nicht die Frage des reinen Reißbrett-Designs, sondern des Bestandsstatus:

    • Neuentwicklungen (Greenfield): Setzen Sie kompromisslos auf OData V4. SAP generiert neue Services über das RAP standardmäßig in V4. Es ist zukunftssicher und bildet die Basis für aktuelle Fiori-Elements-Apps.
    • Erweiterungen bestehender Landschaften (Brownfield): Wenn Sie bestehende SAP-Gateway-Services (SEGW) erweitern oder tief in klassische ERP-/ECC-Prozesse integrieren, bleibt OData V2 oft prozessual notwendig. Ein Versionswechsel im laufenden Betrieb alter Apps erzeugt unnötigen Migrationsaufwand.
    • Schnittstellen zu Drittsystemen: Für moderne Cloud-zu-Cloud-Integrationen (z. B. SAP BTP zu externen APIs) bietet V4 durch Delta-Queries und saubere REST-Semantik klare Vorteile.

    Fazit

    OData V4 ist kein bloßes Versions-Update, sondern ein architektonischer Sprung nach vorn. Wer heute neue S/4HANA-Erweiterungen mit dem RAP entwirft, plant konsequent mit V4. Es reduziert Netzwerk-Overhead, bietet moderne Typisierungen und fügt sich nahtlos in die Clean-Core-Strategie der SAP ein.

  • ABAP Development Tools (ADT) in Visual Studio Code

    Kategorie: Tech Notes | Serie: VS Code für ABAP | Lesezeit: ca. 4 Min.

    Kann Visual Studio Code die klassische Eclipse-IDE im täglichen ABAP-Entwicklungsalltag bereits ersetzen? Während Eclipse ADT nach wie vor der offizielle Standard der SAP für S/4HANA, Clean Core und RAP-Entwicklung ist, hat sich im VS-Code-Ökosystem extrem viel getan.

    In dieser fortlaufenden Artikel-Serie beleuchten wir regelmäßig den **aktuellen Stand, neue Extensions und Praxis-Erfahrungen** rund um die ABAP-Entwicklung in VS Code.

    Der Status Quo: Welches Potenzial hat VS Code für ABAP?

    Die Grundlage für ABAP in VS Code basiert im Wesentlichen auf Community-Projekten (wie den bekannten Open-Source-Extensions von Marcell Lerch / abaplint) sowie offiziellen SAP-Tools für Fiori und CAP. Während für Cloud Application Programming (CAP) und SAPUI5/Fiori Studio bereits VS Code das Werkzeug der Wahl ist, wird der ABAP-Core traditionell über Eclipse bedient.

    Dennoch bietet VS Code für bestimmte ABAP-Anwendungsfälle bereits heute enorm schnelle und schlanke Workflows.

    Die wichtigsten Extensions im Überblick

    1. ABAP Remote Development (ADT Client): Ermöglicht das Verbinden mit ABAP-Systemen (On-Premise via Cloud Connector oder Steampunk / BTP ABAP Environment), das Durchsuchen des Repository-Baums sowie das Editieren und Aktivieren von Objekten.
    2. abaplint & ABAP Syntax Highlighting: Bietet blitzschnelles Syntax-Highlighting, statische Code-Analysen und Linter-Regeln direkt im Editor – ohne bei jedem Tastenanschlag auf den Server zugreifen zu müssen.
    3. ABAP Git / abapGit Integration: Erleichtert die Arbeit mit abapGit-Repositories direkt aus der Git-Oberfläche von VS Code heraus.

    Stärken vs. Einschränkungen im Vergleich zu Eclipse

    BereichEclipse ADT (Standard)VS Code (Extensions)
    Performance & StartzeitSchwerfälliger, höherer RAM-BedarfExtrem schnell, schlank & sofort startklar
    CDS Views & RAP ToolingVolle Unterstützung (Graphical Editors, Previews)Grundlegendes Syntax-Highlighting, eingeschränkte Toolings
    DebuggingUmfangreicher ABAP Debugger & ProfilerGrundlegendes Remote Debugging verfügbar
    Code Analysis & RefactoringQuick Fixes, ABAP Test Cockpit (ATC) nativSehr gut via abaplint (statische Regeln)

    Für welche Anwendungsfälle lohnt sich VS Code heute schon?

    • Quick Fixes & Code Reviews: Schnell mal eine Klasse oder ein Function Module einsehen und kleine Logikfehler korrigieren, ohne eine schwere Eclipse-Instanz starten zu müssen.
    • Full-Stack-Entwicklung (CAP + ABAP): Wer gleichzeitig an CAP-Node.js-Services / Fiori UIs und ABAP-Backends arbeitet, schätzt eine einheitliche IDE-Oberfläche.
    • CI/CD Pipelines & abaplint: Für automatisierte Code-Quality-Checks in Git-Workflows ist VS Code in Kombination mit CLI-Tools unschlagbar.

    Serien-Updates & Ausblick

    Dieser Artikel wird regelmäßig aktualisiert, sobald neue Major-Updates für die ABAP-Extensions erscheinen oder SAP neue offizielle VS-Code-Funktionen ankündigt.

    Stand dieses Beitrags: Q4 2026 | Nächstes Review geplant: Q1 2027

  • Die 10 wichtigsten Eclipse ADT Shortcuts für ABAP-Entwickler

    Kategorie: Tech Notes | Lesezeit: ca. 3 Min.

    Wer in S/4HANA-Projekten, bei der RAP-Entwicklung oder beim Erstellen von CDS Views mit den ABAP Development Tools (ADT) in Eclipse arbeitet, merkt schnell: Die Maus ist der größte Geschwindigkeitskiller. Mit den richtigen Shortcuts navigerst du nicht nur schneller durch den Code, sondern nutzt das volle Potenzial der IDE.

    Hier sind die 10 wichtigsten Tastenkombinationen, die jeder ABAP-Entwickler im täglichen Arbeitsalltag im Kopf haben sollte.

    1. Ctrl + Shift + A – Das universelle Suchfeld (Open ABAP Development Object)

    Der wichtigste Shortcut überhaupt. Egal ob CDS View, Klassenbibliothek, Interface, Tabelle oder Data Element: Über diese Suche findest du jedes Objekt im System innerhalb von Sekunden – ohne dich durch den Project Explorer zu klicken.

    💡 Tipp: Nutze Wildcards wie zcl_*rap* oder camelCase-Kürzel (z. B. ZCL_BP_M), um die Suche gezielt einzuschränken.

    2. F3 – Navigation zur Definition (Open Declaration)

    Positioniere den Cursor auf eine Methode, eine Variable, einen Typen oder ein CDS-Interface und drücke F3. Eclipse springt sofort an die Stelle, an der das Objekt deklariert wurde. Mit Alt + Links-Pfeil springst du genauso schnell wieder zurück.

    3. Ctrl + 1 – Quick Assist / Quick Fix

    Der „Zauberstab“ in Eclipse. Sobald eine Warnung oder ein Fehler im Editor erscheint (oder du Code refactorn möchtest), zeigt Ctrl + 1 passende Lösungsvorschläge an – z. B. automatisches Anlegen von fehlenden Methoden-Implementierungen, Einfügen von Typdeklarationen oder Importieren von Interfaces.

    4. Ctrl + F3 – Aktivieren (Activate)

    Das Äquivalent zu Strg + F3 in der SE80. Aktiviert das aktuell geöffnete Objekt. Um alle geänderten Objekte im Arbeitsbereich auf einmal zu aktivieren, hilft die Kombination Ctrl + Shift + F3.

    5. Ctrl + Space – Auto-Completion (Code Completion)

    Unverzichtbar für sauberen ABAP Code und CDS Annotations. Zeigt dir passende Methoden, Parameter, lokale Variablen sowie freigegebene C1-Released-APIs an. Bei CDS Views schlägt Ctrl + Space auch direkt die verfügbaren Annotations und Association-Namen vor.

    6. Ctrl + Shift + F – ABAP Source Code Formatter

    Formatiert den aktuellen Quellcode automatisch gemäß den hinterlegten Pretty-Printer- bzw. Clean-ABAP-Regeln. Ein kurzer Druck auf diese Kombination sorgt sofort für einheitliche Einrückungen und saubere Lesbarkeit.

    7. Ctrl + O – Schnellanzeige der Elementstruktur (Quick Outline)

    Öffnet ein kleines Pop-up im Editor, das alle Methoden, Attribute, Interfaces und Types der aktuellen Klasse aufzulisten scheint. Tippe einfach die ersten Buchstaben ein, um direkt zur gewünschten Methode zu springen – extrem nützlich bei umfangreicheren Klassen.

    8. Ctrl + Alt + H – Hierarchie der Aufrufe (Call Hierarchy)

    Du möchtest wissen, an welchen Stellen im System eine bestimmte Methode aufgerufen oder ein CDS View genutzt wird? Ctrl + Alt + H zeigt dir den vollständigen Aufrufbaum übersichtlich an – perfekt für Impact-Analysen vor dem Refactoring.

    9. F8 – ABAP Profiler / Ausführen (Run)

    Führt die aktuelle Konsolenanwendung (z. B. Klassen mit dem Interface IF_OO_ADT_CLASSRUN) oder die Datenvorschau für einen CDS View direkt aus. Beim Debugging dient F8 dazu, bis zum nächsten Breakpoint weiterzulaufen.

    10. Ctrl + Shift + / (bzw. Ctrl + /) – Code aus- und einkommentieren

    Markiere einen oder mehrere Absätze und kommentiere sie sofort mit " bzw. // aus. Ein erneutes Drücken entfernt die Kommentarzeichen wieder. Das spart das manuelle Tippen von Anführungszeichen in jeder Zeile.

    Spickzettel für die Praxis (Cheat Sheet)

    ShortcutFunktionEinsatzbereich
    Ctrl + Shift + AObjekt suchenGlobale Suche
    F3Zur Deklaration springenCode-Navigation
    Ctrl + 1Quick Assist / Quick FixRefactoring & Fehlerbehebung
    Ctrl + F3AktivierenBuild & Transport
    Ctrl + SpaceAuto-CompletionCDS & ABAP Code
    Ctrl + Shift + FSource Code FormatterCode-Style / Clean Code
    Ctrl + OQuick OutlineKlassen-Struktur
    Ctrl + Alt + HCall HierarchyVerwendungsnachweis
    F8Ausführen / RunPreview & Testing
    Ctrl + /AuskommentierenCode-Editing

    Hinweis für macOS-Nutzer: Ersetze Ctrl durch die Befehlstataste (Cmd ⌘).

    Fazit

    Es dauert meist nur wenige Tage, sich diese Shortcuts anzugewöhnen – der Gewinn an Entwicklungsgeschwindigkeit und Fokus ist jedoch spürbar. Wer diese 10 Tastenkombinationen verinnerlicht hat, beherrscht die Grundwerkzeuge für effizientes Arbeiten im modernen ABAP-Umfeld.

  • Was ist ein ADR (Architecture Decision Record) und warum braucht jedes SAP-Projekt einen?

    Kategorie: Architecture & Strategy | Lesezeit: ca. 4 Min.

    In komplexen SAP-Transformations- und S/4HANA-Projekten stehen Architekten und Entwickler täglich vor wegweisenden Fragen: Nutzen wir RAP Managed oder Unmanaged? Implementieren wir die Geschäftslogik On-Stack oder Side-by-Side in CAP? Wie gestalten wir das Eventing über die SAP Integration Suite?

    Oft werden diese Entscheidungen in langen Meetings getroffen, in E-Mails oder Teams-Chats besprochen – und sind sechs Monate später für das Team kaum mehr nachvollziehbar.

    Hier kommen Architecture Decision Records (ADRs) ins Spiel: ein leichtgewichtiges, aber extrem wirkungsvolles Werkzeug für die Architekturdokumentation.

    Was ist ein Architecture Decision Record (ADR)?

    Ein Architecture Decision Record (ADR) ist ein kurzes, prägnantes Dokument, das eine einzelne, bedeutende Architekturentscheidung festhält. Es beschreibt nicht nur, was entschieden wurde, sondern vor allem warum und in welchem Kontext.

    Gute ADRs sind:

    • Kurz und fokussiert: Meist nicht länger als 1–2 Seiten (Markdown/Text).
    • Historisch unveränderlich: Ein bestehendes ADR wird nicht überschrieben. Ändert sich die Architektur, ersetzt ein neues ADR das alte („ADR-005 supersedes ADR-002“).
    • Nah am Team: Idealerweise werden sie im Git-Repository oder zentralen Dev-Wiki als Plain-Text gespeichert.

    Der klassische Aufbau eines ADRs

    Ein bewährtes und simples Format ist das MADR-Schema (Markdown Architectural Decision Records):

    1. Titel & Status: Eindeutige Nummerierung, prägnanter Name und aktueller Status (Proposed, Accepted, Rejected, Superseded).
    2. Kontext (Context): Welches Problem muss gelöst werden? Welche Rahmenbedingungen (z. B. Clean Core Vorgaben, Budget, Performance) schränken uns ein?
    3. Betrachtete Optionen (Options): Welche Alternativen stehen zur Auswahl?
    4. Entscheidung (Decision): Welche Option wählen wir und warum?
    5. Konsequenzen (Consequences): Welche positiven Auswirkungen hat die Entscheidung und welche Kompromisse (Trade-offs) gehen wir bewusst ein?

    Praxisbeispiel: ADR im SAP S/4HANA Context

    Hier ist ein einfaches Beispiel für ein ADR aus der SAP-Praxis:

    # ADR-003: Wahl der Extensibility-Strategie für Custom Partner-Logik
    
    * Status: Accepted
    * Datum: 2026-10-24
    * Entscheider: SAP Architecture Team
    
    ## Kontext
    Für ein neues Modul zur Partner-Validierung benötigen wir erweiterte Geschäftslogik. 
    Gemäß unseren Clean Core Richtlinien sollen Modifikationen am SAP-Standard vermieden werden.
    Die Logik erfordert Lese- und Schreibzugriff auf Business Partner Stammdaten.
    
    ## Betrachtete Optionen
    1. Option 1: Classic ABAP Enhancement (User-Exit / BAdI direkt im Core)
    2. Option 2: Developer Extensibility (RAP On-Stack Extension auf S/4HANA)
    3. Option 3: Side-by-Side Extensibility (CAP App auf der SAP BTP)
    
    ## Entscheidung
    Wir entscheiden uns für Option 2: Developer Extensibility (RAP On-Stack).
    
    Begründung:
    * Hohe Performance durch direkten DB-Zugriff ohne zusätzliche Netzwerk-Latenz.
    * Vollständig Clean-Core-konform durch Nutzung freigegebener C1-Schnittstellen (Released APIs).
    * Die Komplexität einer separaten BTP-Laufzeitumgebung ist für diesen Use Case nicht gerechtfertigt.
    
    ## Konsequenzen
    * Positiv: Schnelle Umsetzung, volle Abdeckung durch RAP Framework.
    * Negativ: Entwickler müssen im ABAP RESTful Application Programming Model geschult sein.

    Warum ADRs die Zusammenarbeit im Entwicklerteam verändern

    • Kein „Warum haben die das damals so gebaut?“ mehr: Neue Entwickler oder Berater im Projekt verstehen sofort die Historie des Systems.
    • Weniger Grundsatzdiskussionen: Wenn eine Entscheidung einmal fundiert dokumentiert ist, muss sie nicht bei jedem Personalwechsel neu diskutiert werden.
    • Fokus auf Clean Core: ADRs zwingen dazu, Abweichungen vom SAP-Standard oder der Referenzarchitektur explizit zu begründen.

    Fazit für sapdev.de

    Auf diesem Blog werden Sie in Zukunft immer wieder ADR-Formate finden. Wenn wir konkrete Architekturdilemmata behandeln (z. B. OData v2 vs. v4, CAP vs. RAP oder Event Mesh vs. Direct Webhook), nutzen wir genau dieses Schema – kurz, transparent und nachvollziehbar.

  • Dynamisches Field Control im ABAP RAP

    Problem: In einem ABAP RAP Business Objekt sollen bestimmte Eingabefelder im Fiori Frontend dynamisch schreibgeschützt (Read-Only) werden, sobald der Datensatz den Status APPROVED erreicht hat.

    1. Verhalten in der BDEF definieren

    In der Behavior Definition (BDEF) wird das Feld mit dem Zusatz features : instance markiert:

    define behavior for ZI_MY_ENTITY alias MyEntity
    persistent table zmy_table
    lock master
    authorization master ( instance )
    {
      // Feld für dynamisches Feature Control markieren
      field ( features : instance ) Amount, OrderDescription;
      
      field ( readonly ) OrderID;
    }

    2. Implementierung in der Local Types Class

    In der Behavior Pool Klasse (Local Types) wird die Methode get_instance_features überschrieben:

    METHOD get_instance_features.
      " 1. Lesen der relevanten Entitäten
      READ ENTITIES OF ZI_MY_ENTITY IN LOCAL MODE
        ENTITY MyEntity
          FIELDS ( Status ) WITH CORRESPONDING #( keys )
        RESULT DATA(lt_orders).
    
      " 2. Dynamischen Status auswerten und Feature Control setzen
      result = VALUE #( FOR ls_order IN lt_orders (
        %key = ls_order-%key
        %field-Amount           = COND #( WHEN ls_order-Status = 'APPROVED'
                                          THEN if_abap_behv=>fc-f-read_only
                                          ELSE if_abap_behv=>fc-f-unrestricted )
        %field-OrderDescription = COND #( WHEN ls_order-Status = 'APPROVED'
                                          THEN if_abap_behv=>fc-f-read_only
                                          ELSE if_abap_behv=>fc-f-unrestricted )
      ) ).
    ENDMETHOD.

    Fazit / Key Takeaway

    Durch die Trennung von BDEF-Deklaration und Feature-Control-Methode bleibt das UI flexibel. Das Fiori Launchpad übernimmt die Sperrung der Felder im GUI automatisch, ohne dass man manuell im Frontend JavaScript anpassen muss.

  • Clean Core in der Praxis: Wann lohnt sich CAP für Side-by-Side Extensions?

    Clean Core in der Praxis: Wann lohnt sich CAP für Side-by-Side Extensions?

    Beim Übergang zu S/4HANA steht das Paradigma „Clean Core“ an oberster Stelle. Doch ab wann sollte eine Erweiterung On-Stack (RAP) bleiben und wann ist eine Side-by-Side Extension mit dem SAP Cloud Application Programming Model (CAP) die bessere Wahl?

    1. On-Stack Extensibility (RAP & CDS)

    Die In-App Extensibility sowie Developer Extensibility auf dem S/4HANA-System direkt über das ABAP RESTful Application Programming Model (RAP) sind ideal, wenn:

    • Echtzeit-Zugriff auf bestehende Geschäftsdaten ohne Latenz erforderlich ist.
    • Transaktionale Konsistenz direkt in den Kerntabellen der SAP-Anwendung garantiert werden muss.
    • Die Zielgruppe primär im Fiori Launchpad des Hauptsystems arbeitet.

    2. Side-by-Side Extensibility (CAP)

    Das Cloud Application Programming Model (CAP) entfaltet seine Stärken, wenn Erweiterungen aus dem Kern gelöst werden sollen:

    • Entlastung des Kernsystems: Anwendungsfälle mit hoher Nutzerzahl oder vielen Lesezugriffen werden ausgelagert.
    • Entkoppelte Release-Zyklen: Die Applikation kann unabhängig von SAP-Systemupdates weiterentwickelt werden.
    • Event-driven Architecture: Anbindung an die SAP Integration Suite via Events (z. B. Event Mesh).

    Beispiel: Entwurfsentscheidung

    Eine einfache Faustregel für die Architektur-Entscheidung:

    KriteriumEmpfohlener Ansatz
    Eng gekoppelte Logik & TabellenOn-Stack RAP
    Hohe User-Last (z. B. Lieferanten)Side-by-Side CAP
    Schnittstellen-Monitoring/LogsSide-by-Side CAP

    In den nächsten Artikeln werde ich konkrete Code-Muster für den sicheren Datenaustausch zwischen CAP und S/4HANA OData-Services beleuchten.