Schlagwort: ABAP

  • 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.

  • 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.