Update over_the_wire.md

Author: oblomov-dev

docs/advanced/technical/over_the_wire.md

@@ -1,18 +1,16 @@
 # Key Idea: Over-the-Wire in abap2UI5
 
 The key idea of **abap2UI5** is to apply the principles of **Over-the-Wire (OtW)** web development to the SAP ecosystem.  
-Over-the-Wire refers to a pattern where the **server is responsible for rendering the user interface (UI)** and sends **ready-to-render HTML fragments** to the browser.  
-This avoids complex client-side frameworks and keeps the frontend lean and maintainable.
+
+Over-the-Wire refers to a pattern where the **server is responsible for rendering the user interface (UI)** and sends **ready-to-render HTML fragments** to the browser. This avoids complex client-side frameworks and keeps the frontend lean and maintainable.
 
 While this approach is widely used in frameworks like Hotwire, Livewire, or Phoenix LiveView, **abap2UI5 adapts this idea for SAP**, using the SAPUI5 runtime to render the UI based on server-provided definitions.
 
-#### Historical Context: From SSR to Over-the-Wire
+### History: From SSR to Over-the-Wire
 
-In the early days of web development, **Server-Side Rendering (SSR)** was the standard approach.  
-Every user interaction triggered a request to the server, which returned a fully rendered HTML page.
+In the early days of web development, **Server-Side Rendering (SSR)** was the standard approach. Every user interaction triggered a request to the server, which returned a fully rendered HTML page.
 
-With the rise of **Single Page Applications (SPAs)**, UI rendering shifted to the browser.  
-SPAs request **raw data (e.g., JSON)** from the server and build the UI dynamically using JavaScript frameworks like React, Angular, or Vue.
+With the rise of **Single Page Applications (SPAs)**, UI rendering shifted to the browser. SPAs request **raw data (e.g., JSON)** from the server and build the UI dynamically using JavaScript frameworks like React, Angular, or Vue.
 
 While SPAs enable rich client-side experiences, they also introduce significant complexity:
 - API layers and data contracts
@@ -24,17 +22,17 @@ As a response to this complexity, the **Over-the-Wire approach re-emerged**:
 - The **browser simply inserts those fragments** into the page.
 - The frontend remains simple and declarative.
 
-Frameworks like **Hotwire (Rails)**, **Livewire (Laravel)**, and **Phoenix LiveView (Elixir)** are modern implementations of this concept.
-
-#### Architectural Comparison
+###### Architectural Comparison
 
 | Approach | Data Flow | Rendering Location | Time |
 |----------|-----------|-------------------|-------------|
 | **SSR** | Full-page HTML responses | Entirely on the server | 1990s – 2010s |
 | **SPA** | Raw data (JSON), client builds UI | Client-side (JavaScript framework) | 2010s – today |
 | **Over-the-Wire** | HTML fragments for partial updates | Server renders, browser inserts | 2020s (re-emerging) |
 
-#### Over-the-Wire Frameworks
+###### Over-the-Wire Frameworks
+
+The followring frameworks are modern implementations of this concept.
 
 | Framework | Key Use Case | Technology |
 |-----------|--------------|------------|
@@ -46,7 +44,7 @@ Frameworks like **Hotwire (Rails)**, **Livewire (Laravel)**, and **Phoenix LiveV
 | **[Blazor Server](https://learn.microsoft.com/en-us/aspnet/core/blazor/)** | Server-side UI rendering with SignalR | .NET / C# |
 | **[Inertia.js](https://inertiajs.com/)** | SPA-like experience with server-driven UI | JavaScript + Laravel/Rails |
 
-#### Over-the-Wire in abap2UI5
+### Over-the-Wire in abap2UI5
 
 **abap2UI5** adopts the Over-the-Wire principle but tailors it to SAP's technical environment:
 
@@ -56,28 +54,28 @@ Frameworks like **Hotwire (Rails)**, **Livewire (Laravel)**, and **Phoenix LiveV
 - The frontend code itself is **never generated dynamically**. It remains stable and generic.
 - All business logic, UI definitions, and dynamic behavior are maintained on the backend.
 
-#### Key Characteristics:
-- **Frontend code is static** (SAPUI5 components).
-- **Backend fully controls UI definitions and logic**.
-- No separate frontend development needed.
-- Aligns with SAP's technology stack while following Over-the-Wire principles.
+###### Key Characteristics:
+- Frontend code is astatic UI5 app and send with the first request
+- Backend fully controls UI definitions and logic
+- No separate frontend development needed, all apps are pure backend abap artifacts
+- Aligns with SAP's technology stack (ABAP & UI5) while following Over-the-Wire principles
 
-#### Benefits for SAP Applications
+###### Benefits for SAP Applications
 
 - **Reduced Frontend Complexity**: No need for custom JavaScript development per app.
-- **Faster Development Cycles**: UI and logic are controlled via ABAP.
+- **Faster Development Cycles**: UI and logic are controlled via ABAP in the backend
 - **Maintainable Architecture**: Reuse of SAPUI5 runtime, minimal frontend code.
-- **Seamless SAP Integration**: abap2UI5 fits into existing SAP systems.
+- **Seamless SAP Integration**: abap2UI5 app fits into existing ABAP Stacks on any release
 - **Ideal for Business Applications**: CRUD-heavy apps, forms, dashboards, transactions.
 
-#### Limitations to Consider
+###### Limitations to Consider
 
 While Over-the-Wire (and abap2UI5) offers many advantages, it may not be suitable for:
 * Highly interactive, real-time collaboration tools (e.g., design apps, chat platforms)
 * Applications requiring offline capabilities or rich client-side interactions
 * Scenarios where frontend and backend are developed by separate, independent teams
 
-#### Conclusion
+### Conclusion
 
 The **key idea of abap2UI5** is to apply the simplicity of the Over-the-Wire approach to the SAP world.  
 It enables building efficient, maintainable business applications by shifting UI control back to the backend, while using SAPUI5 as a stable frontend runtime.