Update dx.md

Author: oblomov-dev

docs/advanced/technical/dx.md

@@ -1,14 +1,14 @@
-# Developer Experience: Keeping It Simple
+# Developer Experience: Keeping Things Simple
 
-Developer Experience describes how efficient, and intuitive it is for developers to work with tools, frameworks, and systems.
+Developer Experience refers to how intuitive and productive it feels for developers to work with a framework and its tooling.
 
-Good Developer Experience means writing code feels natural, testing changes is fast, and the tools stay out of your way. It includes minimal boilerplate, easy debugging, straightforward deployment, and code that’s simple to understand, reuse, and share.
+Good Developer Experienc means writing code is fast, testing changes is instant, and the tooling never gets in your way. It involves minimal boilerplate, easy debugging, simple deployment, and code that’s easy to understand, reuse, and share.
 
-This page explores familiar ABAP technologies and coding patterns that offer a smooth developer experience — and shows how these ideas have influenced the design of abap2UI5.
+This page explores familiar ABAP frameworks and and snippets serving a nice developer experience — and shows how these ideas have influenced APIs and its usage of abap2UI5.
 
-### Output - if_oo_adt_classrun
+### API I: Output with if_oo_adt_classrun
 
-One of the most fundamental tasks in any development environment is to output data. In ABAP, the cleanest and cloud-compatible way to do this is via the IF_OO_ADT_CLASSRUN interface. It provides a simple, class-based entry point that works in both ABAP Cloud and on-premise systems.
+One of the most fundamental development tasks is outputting data. In ABAP, the cleanest way to do this is with the IF_OO_ADT_CLASSRUN interface. It offers a simple, class-based approach immediatly outputting data into ADT:
 
 ```abap
 CLASS zcl_app_adt DEFINITION PUBLIC CREATE PUBLIC.
@@ -25,11 +25,10 @@ ENDCLASS.
 Why this improves Developer Experience:
 - The entire app lives in a single file — fast to navigate, easy to debug
 - No boilerplate: just a class and one method
-- Works identically in all modern ABAP environments
-- Integrates perfectly with abapGit for versioning and sharing
-
-This simple design directly inspired abap2UI5. Here's the equivalent app implemented in abap2UI5:
+- Works identically in `ABAP Cloud` and `Standard ABAP`
+- abapGit compatible for versioning and sharing
 
+This simple design inspired abap2UI5. Here's the equivalent functionality implemented in abap2UI5:
 ```abap
 CLASS zcl_app_ui5 DEFINITION PUBLIC CREATE PUBLIC .
   PUBLIC SECTION.
@@ -42,24 +41,24 @@ CLASS zcl_app_ui5 IMPLEMENTATION.
   ENDMETHOD.
 ENDCLASS.
 ```
-Additional DX Benefits in abap2UI5:
+
+Additional Benefits in abap2UI5:
 - Runs in any browser — no ADT installation required
-- Accessible by end users with proper authorization
-- Output uses UI5 components that conform to SAP Fiori guidelines
+- Accessible by end users
+- Output uses UI5 beeing conform to SAP Fiori Design guidelines
 
-This example sets the tone for the rest of the framework: minimal setup, full backend control, and great compatibility.
 
-### Input - Selection Screen
+### API II: Input with Selection Screen
 
-A key part of developer productivity is how quickly one can gather user input. Traditional ABAP offers a dead-simple approach with selection screens:
+Traditional ABAP offers a fast way to collect user input using selection screens:
 
 ```abap
 REPORT zre_app_input.
   PARAMETERS pa_arbgb TYPE t100-arbgb DEFAULT 'MDG_TR'.
 START-OF-SELECTION.
   MESSAGE |Input: { pa_arbgb }| type 'I'.
 ```
-abap2UI5 brings this idea into the browser with a view-based UI:
+abap2UI5 brings this concept into the browser:
 ```abap
 CLASS zcl_app_input DEFINITION PUBLIC CREATE PUBLIC.
   PUBLIC SECTION.
@@ -87,10 +86,10 @@ Why this improves Developer Experience:
 - Easy to test: reload the page, enter input, press the button
 - Everything is still in a single class — no external UI tooling needed
 
+### API III: Output Tables with ABAP List Viewer
 
-### Output Tables - ABAP List Viewer
+CL_SALV_TABLE brought major productivity gains to classic ABAP:
 
-In classical ABAP, CL_SALV_TABLE was a major step forward in developer productivity:
 ```abap
 REPORT zre_app_alv.
 
@@ -106,7 +105,7 @@ cl_salv_table=>factory(
     t_table        = gt_t100 ).
 go_salv->display( ).
 ```
-Fifteen lines, a single file, and ready for productive use. Unfortunately, it's not cloud-ready. abap2UI5 offers a functionally similar alternative that’s cloud-ready:
+While this is compact and effective, it's not cloud-ready. abap2UI5 provides a browser-based, cloud-compatible alternative:
 ```abap
 CLASS zcl_app_alv DEFINITION PUBLIC.
   PUBLIC SECTION.
@@ -142,10 +141,11 @@ ENDCLASS.
 Why this improves Developer Experience:
 - Data binding is straightforward and localized
 - Table layout and content are configured inline
-- Fully works in browser and on any device, no GUI dependencies
+- Fully works in browser and on any device, no SAP GUI dependencies
+
+### API IV: popup_to_confirm
+Classic ABAP uses `POPUP_TO_CONFIRM` for simple decisions:
 
-### popup_to_confirm
-Classical ABAP uses POPUP_TO_CONFIRM to ask users for simple confirmations:
 ```abap
 REPORT zre_app_alv.
 
@@ -165,6 +165,7 @@ CASE event.
 ENDCASE.
 ```
 abap2UI5 offers a matching approach using z2ui5_cl_pop_to_confirm:
+
 ```abap
 CLASS zcl_app_alv_event DEFINITION PUBLIC.
   PUBLIC SECTION.
@@ -200,73 +201,48 @@ Why this improves Developer Experience:
 - The flow mimics classic ABAP screen logic with modern UI5 behavior
 
 
-### Deployment – Transport Without Pain
-
-One of the most overlooked aspects of Developer Experience is deployment. Even a beautifully written app is frustrating to work with if it’s hard to deploy.
+### Deployment
 
-Classic ABAP deployments often rely on transport requests and manual steps through SE01, which can become tedious and error-prone — especially for small, iterative apps.
+One overlooked aspects of Developer Experience is deployment. Even a beautifully written app is frustrating to work with if it’s hard to deploy. But in abap2UI5 all apps are just classes and can be deployed via activation, transport into production goes over the TOC system known from the rest of the abap world.
 
-**abap2UI5 improves this by being fully abapGit-compatible.** All apps are just classes and can be committed, versioned, and transported via Git-based workflows. This is fully supported in both ABAP Cloud and classic systems.
-
-**Why this improves Developer Experience:**
-- No Z-transaction creation, Web Dynpro configuration, or ICF setup required
-- Code changes are instantly visible via browser without deployment steps
-- Clean Git history, easier code reviews, and fully scriptable CI/CD possible
-
-### Cache – Reliable During Iteration
-
-A common frustration in SAP development is the UI cache, especially when working with BSP applications or Fiori Elements apps. You make a change — and nothing happens due to cached artifacts.
+Why this improves Developer Experience:
+- No separated Frontend deployment and build pipelines
+- Code changes are instantly deployed and can be tested by consultants
+- Every app is an abapGit fully compatible Project without separated frontend artifacts
+  
+### Cache
 
-**abap2UI5 eliminates this problem** by not caching UI definitions at all. The UI is dynamically built in each request from ABAP code. Every refresh reflects the latest code.
+A common frustration in SAP development is the UI cache, especially when working with BSP applications or Fiori Elements apps. There are a lot of different cahe incalvidation transactions etc. You make a change — and nothing happens due to cached artifacts. abap2UI5 eliminates this problem by not caching UI definitions at all. The UI is dynamically built in each request from ABAP code. Every browser refresh always reflects the latest code.
 
-**Why this improves Developer Experience:**
+Why this improves Developer Experience:
 - No need to clear browser cache or invalidate server caches
-- True WYSIWYG iteration — edit the code, refresh, and test
-- Enables rapid experimentation without hidden state issues
+- Fast dewvelopment iteration — edit the code, refresh, and test
 
-### Tools – You Already Know Them
+### Tools
 
-Great DX means you don’t have to learn new tools just to be productive.
+Great Developer Experience also means you can use the tools you like and are not forced into certain tooling. With abap2UI5, development happens entirely within **SE80**, **ADT**, or any IDE of your choice. It only based on ABAP classes giving you the freedom of choice and has a complete compatibility to all tools.
 
-With abap2UI5, development happens entirely within **SE80**, **ADT**, or any **ABAP IDE** of your choice. No Node.js, no Web IDE, no special CLI tools.
-
-**Why this improves Developer Experience:**
+Why this improves Developer Experience:
 - Works out of the box in any ABAP system — no extra setup
-- Familiar tooling: SE80, class editor, debugger
 - Smooth transition for teams already comfortable with ABAP
 
+### Debugging
 
-### Debugging – It Just Works
-
-Debugging frontend-heavy applications often requires navigating between browser tools, JavaScript breakpoints, and network logs — not ideal for ABAP developers.
+Debugging frontend-heavy applications often requires navigating between browser tools, JavaScript breakpoints, and network logs — not ideal for ABAP developers. In abap2UI5, the UI is comes fully out of ABAP code. There is no JavaScript to debug. If you want to see what happens when a button is pressed, set a breakpoint in the ABAP class — that’s it.
 
-In **abap2UI5**, the UI is just a projection of ABAP code. There is no JavaScript to debug. If you want to see what happens when a button is pressed, set a breakpoint in the ABAP class — that’s it.
-
-**Why this improves Developer Experience:**
-- Backend-only debugging using the classic ABAP debugger
+Why this improves Developer Experience:
+- Backend-only debugging using the classic ABAP debugger or ADT
 - No browser dev tools needed
-- Reproducible, testable flows — event handlers run like regular ABAP methods
 
----
+### Sharing
 
-### Sharing – Built for abapGit
+Sharing solutions across systems or with other developers is essential — especially in open source or multi-system landscapes. Since abap2UI5 apps are just classes, they are naturally compatible with abapGit or can be just copy & pasted. There are no special configuration files, manifests, or bundling steps.
 
-Sharing solutions across systems or with other developers is essential — especially in open source or multi-system landscapes.
-
-Since **abap2UI5 apps are just classes**, they are naturally compatible with **abapGit**. There are no special configuration files, manifests, or bundling steps.
-
-**Why this improves Developer Experience:**
+Why this improves Developer Experience:
 - Easy to clone and test others’ apps
 - Ideal for team collaboration and code review
 - Encourages modular, reusable components through shared repositories
 
-
 ### Summary
 
-abap2UI5 brings back the simplicity of classic ABAP workflows with a modern, browser-based UI. By preserving familiar ABAP patterns (like output via WRITE, selection screens, ALV display, and popups) and wrapping them in clean, class-based interfaces, abap2UI5 delivers a developer experience that is:
-- Fast to start — apps are created in minutes
-- Simple to debug — logic and UI are together
-- Easy to share — via abapGit and browser-based access
-- Cloud-compliant — works in Steampunk and on-prem
-
-Each code snippet on this page shows how classic patterns are reimagined for modern ABAP development. That’s what great Developer Experience is about.
+abap2UI5 was a lot inspired by the classics like output via WRITE, selection screens, ALV display, and popups and for the rest it got very lucky that the ui5 framework can that easy be gesteuert with abap only leveringing a lot of additonal benefits like Deployement, cahce, debugging, tooling or sharing giving abap2UI5 a smooth Developer expereince.