Add missing explanations for key concepts across documentation

- hello_world.md: show z2ui5_if_app interface definition, explain client object,
  document roundtrip lifecycle, and explain CASE abap_true dispatcher pattern
- model.md: explain path = abap_true parameter for _bind/_bind_edit
- events.md: document $source vs $parameters vs $event prefixes with descriptions,
  explain difference between _event (backend) and _event_client (frontend)
- expression_binding.md: explain {= ... } syntax and JavaScript operators (===)
- view.md: explain what stringify() does (XML serialization)
- performance.md: add code example for view_model_update vs view_display,
  fix incorrect method names in suggestions (model_update → view_model_update)

https://claude.ai/code/session_01AaA4EMw83KMzGP6kaDZPJU

Author: claude

docs/configuration/performance.md

@@ -10,10 +10,38 @@ Frontend logic is kept to a minimum: no business logic runs in the browser. Ever
 
 abap2UI5 has been successfully tested with tables containing large numbers of entries and columns. So, you can confidently develop your app — performance shouldn't be a concern.
 
+### view_display vs view_model_update
+
+The most impactful optimization is choosing the right update method:
+
+- **`client->view_display( )`** — sends a new XML view and model to the frontend. UI5 destroys the current view and creates a new one from scratch. Use this only on initialization or when the view structure changes.
+- **`client->view_model_update( )`** — sends only updated model data. UI5 refreshes the existing view via data binding — only the changed controls are re-rendered. This preserves UI state (scroll position, focus, etc.) and is significantly faster.
+
+```abap
+METHOD z2ui5_if_app~main.
+
+  CASE abap_true.
+
+    WHEN client->check_on_init( ).
+      DATA(view) = z2ui5_cl_xml_view=>factory(
+        )->page( `My App`
+        )->text( client->_bind( mv_text )
+        )->button( text = `update` press = client->_event( `UPDATE` ) ).
+      client->view_display( view->stringify( ) ).
+
+    WHEN client->check_on_event( `UPDATE` ).
+      mv_text = `new value`.
+      client->view_model_update( ).
+
+  ENDCASE.
+
+ENDMETHOD.
+```
+
 ### Suggestions
 Want to optimize your app even more? Here are a few tips:
-* Only call the `client->view_display` method when necessary. Instead, prefer using `client->model_update` so the UI5 framework only re-renders the controls that have actually changed
-* Prefer using `client->bind` and use `client->bind_edit` only when users need to make changes that are processed in the backend. Otherwise, it leads to unnecessary data transfers
+* Only call `client->view_display` when necessary. Prefer `client->view_model_update` so the UI5 framework only re-renders controls that have actually changed
+* Prefer `client->_bind` and use `client->_bind_edit` only when users need to make changes that are processed in the backend. Otherwise, it leads to unnecessary data transfers
 * Declare public attributes in your app class only for variables displayed in the frontend. This helps prevent the framework from accessing unused values
 * Follow standard ABAP best practices, such as reducing loops and using sorted tables, as you would in any other ABAP development project
 

docs/development/events.md

@@ -27,7 +27,13 @@ METHOD z2ui5_if_app~main.
  
 ENDMETHOD.
 ```
-If the backend needs additional information about the specific event, use parameters like `$event`, `$source`, and `$params` to send further details. Use the t_arg parameter to include these details. Check out [this documentation](https://openui5.hana.ondemand.com/#/topic/b0fb4de7364f4bcbb053a99aa645affe) for more information, and refer to sample `Z2UI5_CL_DEMO_APP_167`.
+If the backend needs additional information about the specific event, use the `t_arg` parameter to include additional details. Three special prefixes are available:
+
+- **`$source`** — the UI5 control that triggered the event (e.g. `${$source>/text}` returns the button text)
+- **`$parameters`** — the event parameters as defined by the UI5 control (e.g. `${$parameters>/id}` returns the element ID)
+- **`$event`** — the UI5 event object itself (e.g. `$event>sId` returns the event type like `press`)
+
+Check out [this documentation](https://openui5.hana.ondemand.com/#/topic/b0fb4de7364f4bcbb053a99aa645affe) for more information, and refer to sample `Z2UI5_CL_DEMO_APP_167`.
 
 #### Source
 Send properties of the event source control to the backend:
@@ -127,7 +133,14 @@ This is just a demonstration. In this case, it would be easier to access `name`
 :::
 
 ### Frontend
-If you don't want to process the event in the backend, you can also directly trigger actions at the frontend. The following frontend events are available:
+If you don't want to process the event in the backend, you can directly trigger actions at the frontend using `client->_event_client`. The difference between the two methods:
+
+- **`client->_event( )`** — triggers a backend roundtrip, the event is processed in the `main` method
+- **`client->_event_client( )`** — executes an action directly in the browser, no backend call
+
+To use a frontend event on a UI5 control property (like `press`), wrap `_event_client` inside `_event`. To execute a frontend event after backend processing, pass `_event_client` to `client->follow_up_action`.
+
+The following frontend events are available:
 ```abap
   CONSTANTS:
     BEGIN OF cs_event,

docs/development/model/expression_binding.md

@@ -2,6 +2,8 @@
 
 Expression Binding lets you compute values directly in XML views using JavaScript-like expressions. This is especially useful in abap2UI5, as it can reduce server roundtrips by moving calculations, logical conditions, and string operations to the frontend.
 
+The syntax `{= ... }` marks a UI5 expression binding. Inside the expression, you can use JavaScript operators (like `===` for strict equality or `Math.max`) and reference model properties with `$` followed by a binding path. Note: `===` is the JavaScript strict equality operator (not an ABAP operator) — it is required because UI5 evaluates these expressions in the browser.
+
 #### Calculate the Maximum Value at the Frontend
 
 ```abap

docs/development/model/model.md

@@ -66,3 +66,13 @@ ENDCLASS.
 ::: tip **Data in Public Attributes**
 When using One-Way or Two-Way binding, ensure your data is stored in the public attributes of your class. This allows the framework to access it from outside. This is similar to the PBO/PAI logic, where data had to be stored in global variables.
 :::
+
+#### Path Parameter
+Both `_bind` and `_bind_edit` accept an optional parameter `path = abap_true`. By default, these methods return the full binding expression (e.g. `{/XX/NAME}`). With `path = abap_true`, only the raw model path is returned (e.g. `/XX/NAME`), which is useful when you need to embed it in complex binding expressions like UI5 types or expression binding:
+```abap
+"default - returns full binding expression: {/XX/QUANTITY}
+client->_bind( quantity )
+
+"with path - returns only the model path: /XX/QUANTITY
+client->_bind( val = quantity path = abap_true )
+```

docs/development/view.md

@@ -20,7 +20,7 @@ In abap2UI5, the UI is rendered from a UI5 XML view that you build in your ABAP
 
 ENDMETHOD.
 ```
-You can use any UI5 control available in the [UI5 SDK](https://sapui5.hana.ondemand.com). However, writing raw XML quickly gets cumbersome. A more practical approach is to use the `Z2UI5_CL_XML_VIEW` helper class, which provides a fluent API for building views:
+You can use any UI5 control available in the [UI5 SDK](https://sapui5.hana.ondemand.com). However, writing raw XML quickly gets cumbersome. A more practical approach is to use the `Z2UI5_CL_XML_VIEW` helper class, which provides a fluent API for building views. The `stringify( )` method at the end serializes the view tree into an XML string that the framework sends to the frontend:
 
 ```abap
   METHOD z2ui5_if_app~main.

docs/get_started/hello_world.md

@@ -3,8 +3,19 @@ outline: [2, 4]
 ---
 # Hello World
 
+### The Interface
+Every abap2UI5 app implements the `Z2UI5_IF_APP` interface. It has a single method `main` with one parameter — `client` of type `Z2UI5_IF_CLIENT`:
+```abap
+INTERFACE z2ui5_if_app PUBLIC.
+  METHODS main
+    IMPORTING
+      client TYPE REF TO z2ui5_if_client.
+ENDINTERFACE.
+```
+The `client` object is your only access point to the framework. Use it to display views, handle events, exchange data, and navigate between apps.
+
 ### Basic Example
-Every abap2UI5 app implements the `Z2UI5_IF_APP` interface. Create a new class with the following code:
+Create a new class with the following code:
 ```abap
 CLASS zcl_app_hello_world DEFINITION PUBLIC.
 
@@ -44,7 +55,13 @@ ENDCLASS.
 ```
 
 ### Event Handler
-Next, we extend the app with a button and an event handler. To ensure that the view is only rendered at the start, we also check for the `on_init` event:
+The `main` method is called on every roundtrip — that is, on initialization and after every user interaction (button press, input submit, etc.). To control what happens when, use `CASE abap_true` to distinguish between lifecycle events:
+
+- `client->check_on_init( )` — first call when the app starts
+- `client->check_on_event( )` — user triggered an event (e.g. button press)
+- `client->check_on_navigated( )` — returned from another app via navigation
+
+This pattern works because each `check_*` method returns `abap_true` only for its specific phase, making `CASE abap_true` act as a dispatcher:
 ```abap
 CLASS zcl_app_hello_world DEFINITION PUBLIC.
   PUBLIC SECTION.