Update from SAP DITA CMS (squashed):

commit 5dcf57faf0cde3813f72041308d45ecd0a4f3eb6
Author: REDACTED
Date:   Thu Oct 17 17:46:09 2024 +0000

    Update from SAP DITA CMS 2024-10-17 17:46:09
    Project: dita-all/wyj1697728549568
    Project map: 70ba5157e83045a1b0358310c2a3416f.ditamap
    Output: loio76c486d4b83b48f39289c7c52ca024b2
    Language: en-US
    Builddable map: 078455e002054fe1a1fbed95b658fd0e.ditamap

commit f5926acdda012a3b6b4472f9bcbd49d42c026d7c
Author: REDACTED
Date:   Thu Oct 17 17:30:43 2024 +0000

    Update from SAP DITA CMS 2024-10-17 17:30:43
    Project: dita-all/ktj1709647758412
    Project map: 70ba5157e83045a1b0358310c2a3416f.ditamap
    Output: loio76c486d4b83b48f39289c7c52ca024b2
    Language: en-US
    Builddable map: 078455e002054fe1a1fbed95b658fd0e.ditamap

commit 60199d7e304bad121d250340581f9a344c6988e8
Author: REDACTED
Date:   Thu Oct 17 15:45:58 2024 +0000

    Update from SAP DITA CMS 2024-10-17 15:45:58
    Project: dita-all/wyj1697728549568
    Project map: 70ba5157e83045a1b0358310c2a3416f.ditamap
    Output: loio76c486d4b83b48f39289c7c52ca024b2
    Language: en-US
    Builddable map: 078455e002054fe1a1fbed95b658fd0e.ditamap

##################################################
[Remaining squash message was removed before commit...]

docs/abap-cloud-9aaaf65.md

@@ -0,0 +1,64 @@
+<!-- loio9aaaf650d02e42afba0e4b09e2991d78 -->
+
+# ABAP Cloud
+
+
+
+<a name="loio9aaaf650d02e42afba0e4b09e2991d78__section_sgv_1hw_czb"/>
+
+## Overview
+
+The technological core of [ABAP Cloud](https://help.sap.com/docs/abap-cloud/abap-cloud/why-abap-cloud) defines the design-time and runtime architecture of all extensions, services, and applications. The main ABAP Cloud elements are:
+
+-   ABAP Core Data Services \(CDS\) for the data model and for embedded analytics
+
+-   The ABAP RESTful Application Programming Model \(RAP\)
+
+-   The cloud-optimized ABAP language for the business logic
+
+-   Mandatory public SAP APIs and extension points to allow automated cloud operations and lifecycle stable extensibility
+
+-   ABAP Development Tools \(ADT\) for Eclipse as the ABAP-integrated development environment
+
+
+Building on these key elements, you can use ABAP Cloud to cover the following scenarios:
+
+-   **Transactional \(OLTP\)**: With ABAP Cloud you can build business objects and expose them as services, to consume them in UIs and integration scenarios. All standard behavior is supported \(create, read, update, delete\).
+
+-   **Analytical \(OLAP\)**: ABAP Cloud is equally equipped for creating services and UIs for data analysis, and for drilling down in multiple dimensions, like integrating the data in SAP Analytics Cloud.
+
+-   **Integration**: Both previous aspects are complemented by strong data and application integration to cater to today’s service-oriented environments.
+
+
+The development model has two additional key differentiators:
+
+-   The **reuse services and libraries** with core business services like number ranges, application jobs, an ABAP-integrated SAP Fiori launchpad, and UI repository to deploy SAPUI5 and SAP Fiori elements user interfaces.
+
+-   The **built-in qualities** offering end-to-end extensibility in the programming model, major cloud qualities like scalability and upgrade stable APIs, and many more.
+
+
+
+
+<a name="loio9aaaf650d02e42afba0e4b09e2991d78__section_rjg_xgw_czb"/>
+
+## Use Cases for Developing with ABAP Cloud
+
+With ABAP Cloud, you can cover a variety of use cases for different scenarios. The development path is structured according to the consumers: Either the consumer is a user or system, meaning either you want to create an app to manipulate or display data or you want to exchange data between systems with different protocols to create business processes with system-to-system communication.
+
+With ABAP Cloud, you can develop transactional and analytical apps. Transactional applications have transactional characteristics to create, update or delete data records whereas analytical applications only read and display data in charts or dashboards.
+
+All applications and services developed with ABAP Cloud are by default multitenant enabled. Partners can use the [SAP BTP, ABAP environment](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/abap-environment) Software-as-a-Service tooling to easily build, deploy, and operate Software-as-a-Service solutions on their own.
+
+Integration services enable system-to-system communication for different protocols. In ABAP Cloud, integration services can be used for process integration or data integration. With process integration, the communication is structured along a predefined business process like, for example, order-to-cash. In contrast, data integration focuses on transferring raw data without any relation to a business process.
+
+**Related Information**  
+
+
+[Design](design-314ae3e.md "")
+
+[Develop](develop-c8906e4.md "")
+
+[Deploy](deploy-d7aec3c.md "")
+
+[Operating with SAP Cloud ALM](operating-with-sap-cloud-alm-f7f2977.md "")
+

docs/deliver-3efbd5b.md

@@ -0,0 +1,23 @@
+<!-- loio3efbd5b6b8fd46648a1f75db6196dae0 -->
+
+# Deliver
+
+Now that you have completed your design for the required user experience of your application along with the appropriate application architecture, it’s time to deliver what you have designed. In other words, set up the development and test landscape, develop and test your application and finally release it to the productive environment. See:
+
+-   You start by **setting up the landscape** in SAP BTP. See [Set Up](set-up-3b774f8.md).
+
+-   Then, you continue with the development, choosing the **programming language, programming model, runtimes, tools** and others. Have in mind that depending on the programming model, there are some specifics. See
+
+    -   [Develop](develop-and-build/develop-7e30686.md)
+
+    -   [Programming Model Specifics](programming-model-specifics-cc37b7a.md)
+
+
+-   There are **sample applications** presented in tutorials and end-to-end scenarios, called missions:
+
+    -   [Tutorials for ABAP Cloud](tutorials-for-abap-cloud-fd87aaa.md)
+
+    -   [Tutorials for SAP Cloud Application Programming Model](tutorials-for-sap-cloud-application-programming-model-eb7420a.md#loioeb7420a2c752457687fb39ed01509ef5)
+
+
+

docs/deploy-45d5acf.md

@@ -0,0 +1,41 @@
+<!-- loio45d5acf602064061843da43f0b800e1e -->
+
+# Deploy
+
+SAP Cloud Application Programming Model \(CAP\) applications can be deployed in the SAP BTP, Cloud Foundry runtime or in the SAP BTP, Kyma runtime. Both runtimes can be used to host and run your custom code, while at the same time being connected to SAP BTP Multi-Cloud Services and your on-premise systems. Depending on your use case and the skill set of your developers, choose the runtime that fits your needs. See [Comparison: SAP BTP, Kyma Runtime and SAP BTP, Cloud Foundry Runtime](https://help.sap.com/docs/btp/comparison-kyma-runtime-and-cloud-foundry-runtime/runtime-comparison?version=Cloud).
+
+
+
+<a name="loio45d5acf602064061843da43f0b800e1e__section_k1z_rrv_czb"/>
+
+## Deploy in Cloud Foundry Runtime
+
+After completing the functional implementation of the CAP application by following the best practices, you can deploy your application in the cloud for productive usage. The essential steps are illustrated in the following graphic:
+
+![](images/Deploy_a_CAP_Application_in_Cloud_Foundry_Runtime_50243ce.png)
+
+With our recommended approach, the actual deployment in your SAP BTP, Cloud Foundry runtime is performed either by your [Continuous Integration and Delivery \(CI/CD\)](develop-and-build/continuous-integration-and-delivery-ci-cd-fe74df5.md) pipeline \(such as provided by SAP Continuous Integration and Delivery service\) or handled by transports \(via [SAP Cloud Transport Management](https://help.sap.com/docs/cloud-transport-management?version=Cloud), optionally orchestrated by SAP Cloud ALM\).
+
+If you want to perform a manual deployment in the SAP BTP, Cloud Foundry runtime, see [Deploy in Cloud Foundry](https://cap.cloud.sap/docs/guides/deployment/to-cf).
+
+
+
+<a name="loio45d5acf602064061843da43f0b800e1e__section_knx_xrv_czb"/>
+
+## Deploy in Kyma Runtime
+
+Kyma is a Kubernetes-based platform to run containerized workloads. The service's files are provided as a container image, commonly referred to as a Docker image. In addition, the containers to be run on Kubernetes, their configuration and everything else that is needed to run them, are described in the Kubernetes resources.
+
+In consequence, two kinds of artifacts are needed to run applications on Kubernetes:
+
+-   Container images
+
+-   Kubernetes resources
+
+
+The following diagram shows the steps to run on the SAP BTP, Kyma runtime:
+
+![](images/Deploy_a_CAP_Application_in_the_Kyma_Runtime_d3a3414.png)
+
+For detailed steps to deploying your application in the SAP BTP, Kyma runtime, see[Deploy in Kyma Runtime](https://cap.cloud.sap/docs/guides/deployment/deploy-to-kyma).
+

docs/deploy-d7aec3c.md

@@ -0,0 +1,62 @@
+<!-- loiod7aec3cb76c24cc8b4f1869633bfdfe7 -->
+
+# Deploy
+
+
+
+<a name="loiod7aec3cb76c24cc8b4f1869633bfdfe7__section_alv_mtw_bzb"/>
+
+## Common Setup
+
+The deployment of developed ABAP Cloud objects and entire applications is supported by administration apps delivered with SAP BTP, ABAP environment. The respective ABAP systems run on Gardener or Kubernetes-based infrastructure, but such technical details are hidden for developers and administrators. The important part of the deployment strategy is the definition and setup of the respective System Landscape. A typical system landscape consists of three ABAP systems for development, test and productive use. See [System Landscape/Account Model](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/concepts#loio4ca756395fc24e56a42b77632a6bd862).
+
+The basic entity for the deployment are software components. Software components are maintained with the administrators app Manage Software Components. A hidden Git repo is automatically managed per software component based on gCTS for transport management. Software components can be imported into test and productive systems. This process can be automated via Piper pipelines including steps like automated test using ABAP Test Cockpit \(ATC\). You can also use SAP Cloud Transport Management to handle the propagation of your changes in SAP BTP, ABAP environment.
+
+The common setup is sufficient for customers to run their own applications.
+
+For more information, see:
+
+-   [Software Components](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/software-components)
+
+-   [Manage Software Components](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/manage-software-components)
+
+-   [ABAP Environment Pipeline](https://www.project-piper.io/pipelines/abapEnvironment/introduction/)
+
+
+
+
+<a name="loiod7aec3cb76c24cc8b4f1869633bfdfe7__section_xj3_ntw_bzb"/>
+
+## Additional Considerations for Partners
+
+There are two different models for offering and deploying your solution.
+
+1.  As a multitenant SaaS solution:
+
+    -   You offer a cloud service
+
+    -   Your customers can subscribe to your service and get an own tenant in your central provider system
+
+    -   The application monitoring is in your responsibility and so is managing the infrastructure costs
+
+    -   Even for this scenario, Field Extensibility and Custom Logic is offered for key users on customer side \(tenant-aware\)
+
+
+2.  As an installable product:
+
+    -   You offer the product as an Add-on; the product can also be an SDK
+
+    -   Your customers need to have an own SAP BTP, ABAP environment instance
+
+    -   The installation of the product and patches is in the responsibility of your customers
+
+    -   The installation will be possible via Landscape Portal on customer side
+
+    -   The customer can extend your product via ADT. See the developer extensibility option in the [Development Use Cases](understanding-available-technology-c1f21a4.md#loio4efd0bc86ade42c28bf4c4c8dbc4451b) page.
+
+
+
+For both models, partners can build solutions based on software components with the help of the Landscape Portal to set up multitenant SaaS solutions or to offer installable products like SDKs for other customers and partners.
+
+The Landscape Portal is a collection of administrator apps and is part of the SAP BTP, ABAP environment. See [Landscape Portal](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/landscape-portal).
+

docs/design-314ae3e.md

@@ -0,0 +1,54 @@
+<!-- loio314ae3eac1244588b15dd146f1aa0a51 -->
+
+# Design
+
+
+
+<a name="loio314ae3eac1244588b15dd146f1aa0a51__section_c5g_mb3_tyb"/>
+
+## ABAP Cloud Design Principles
+
+ABAP Cloud is based on a model-driven architecture approach that focuses on improving development efficiency through standardization and formalization of the programming model and the tooling environment ensuring efficiency and scalability. Programming models generally define the design time software architecture with specific technologies, concepts, and development objects. It essentially defines a standard architecture for app and service development from the database to the business service exposure.
+
+ABAP Cloud builds on the strengths of powerful frameworks and a standardized architecture for different use cases, aiming at saving as much implementation time as possible while providing you with flexibility - you can model your business processes with apps and services based on your business requirements along predefined technical processes. As much as possible is handled by the frameworks to decrease the probability of consistency errors during runtime. This standardized and consistent architecture across all apps and services developed with ABAP Cloud has many advantages from development perspective:
+
+-   Efficiency increase and scalability
+
+    The developer efficiency is increased because standard architecture patterns are easily scalable. Once you are familiar with developing with the ABAP Cloud development model, the additional effort decreases with each developed service or application.
+
+-   Adaptability and maintenance
+
+    A standardized architecture fosters code quality and thus testability and code maintenance. ABAP Cloud comes with specific mock-frameworks for data models and events that support the code quality assurance and avoid regressions on all test levels.
+
+-   High abstraction level
+
+    The development model executes all low-level technical and infrastructure-related tasks.
+
+
+The cloud-optimized ABAP languages like Data Definition Language or the Entity Manipulation Language match the data modeling requirements and are designed to support the modeling and ABAP-specific development process as closely as possible.
+
+
+
+<a name="loio314ae3eac1244588b15dd146f1aa0a51__section_c2s_mb3_tyb"/>
+
+## Benefits of the Model-Driven Approach
+
+A standardized architecture approach saves you time and scales easily with multiple apps or services. In case of ABAP Cloud, also ensures the separation of concerns between data model behavior, and service exposure ensuring interoperability between different use cases, so that you can reuse data models for different purposes like analytical reports and transactional apps at the same time.
+
+
+
+<a name="loio314ae3eac1244588b15dd146f1aa0a51__section_ynz_z43_tyb"/>
+
+## Transactional Consistency Across Applications and Services
+
+Interoperability is guaranteed because all implementations adhere to the same technical rule set, and the framework determines the technical contracts and process flows. This enables you to design end-to-end processes without having to worry about how to implement an authorization or locking concept for only for one specific part of the process. Instead, you make process design decisions that incorporate the technological advantages of the different ABAP Cloud technologies, frameworks, and building blocks in each step of a process. For more details about transactional consistency, see Transactional Consistency.
+
+**Related Information**  
+
+
+[Design a Transactional Application](design-a-transactional-application-608432c.md "")
+
+[Design an Analytical Application](design-an-analytical-application-8819cb7.md "")
+
+[Design an Integration Service](design-an-integration-service-ec2ac31.md "")
+

docs/design-6bb7339.md

@@ -0,0 +1,25 @@
+<!-- loio6bb733981248482e86559bc52a87aaff -->
+
+# Design
+
+Good user experience \(UX\) goes beyond aesthetics and can have substantial business benefits, both financially and in overall efficiency. A great UX can improve productivity, enhance data quality, reduce training costs, and decrease the number of change requests.
+
+A positive UX boosts user satisfaction, customer loyalty, and overall application adoption. Users are more likely to embrace an application that is intuitive and easy to use.
+
+However, achieving a good UX involves overcoming several common challenges. Users often struggle with finding information, dealing with scattered data, excessive clicks, poor data entry interfaces, and unhelpful error messages. Beyond design, bad performance and unhelpful data visualization can also frustrate users.
+
+The essential approach to designing a good application is design thinking, which emphasizes understanding users' needs through observation and feedback. Iteration is key: quickly sketch prototypes, gather user feedback, and refine your designs before moving to development. This ensures that the final product truly meets users' needs and optimizes resources effectively.
+
+For organizations working with multiple applications, consistency is crucial. Users expect uniform visual design and interactions, easy access and navigation between applications, and common functions readily available. To achieve this, a design system is necessary. It ensures consistent user experience across various channels such as desktop, mobile, and so on.
+
+In large-scale development, you also need robust frameworks, libraries, and user experience integration runtimes to manage hundreds of applications efficiently. Proper authorization tools are essential to control access for an extensive user base.
+
+The SAP Fiori design system along with its enabling UI tools and technologies gives you the above: a comprehensive design system for web and mobile, along with a suite of development tools and UI frameworks, enabling SAP to provide a consistent UX with good usability across all SAP products, and enabling you to do the same for your applications. Using SAP's design system enables you to bring together business value, modern technology and excellent UX, thus benefitting business and users alike.
+
+Find out more about user experience design and technology design in the next sections:
+
+-   [User Experience Design](user-experience-design-323bd93.md)
+
+-   [Technology Design](technology-design-a5b8129.md)
+
+

docs/design-a-multitenant-application-1ac614d.md

@@ -0,0 +1,50 @@
+<!-- loio1ac614dd9c2a4f05957096e86de4931c -->
+
+# Design a Multitenant Application
+
+You can use the multiclient architecture of the ABAP system for multitenancy enablement and list the design principles to reach multitenancy.
+
+-   Store tenant-related data in client-dependent tables of type A, C, or L.
+
+-   Store system-related data in client-independent tables of type S.
+
+-   Always add the selection of the client to ABAP database procedures \(AMDPs\).
+
+
+Make sure consumers cannot modify the client parameter or any other part of the AMDP using the application or by tampering requests.
+
+-   Don't generate development objects or other client-independent data system-locally in the provider system.
+
+-   Don't evaluate the actual value of the 3-digit client field \(IF sy-mandt = ‘nnn’. ... ENDIF\).
+
+
+You have to classify database tables according to their content. There are the two different types of content:
+
+-   Tenant Content \(client-dependent\)
+
+    -   Tenant configuration data – tables with delivery class “C”
+
+    -   Tenant application data – tables with delivery class “A”
+
+    -   Tenant temporary data – tables with delivery class “L”
+
+
+    Database tables for tenant content must be client-dependent. This means that the first field of the table must be of datatype “CLNT”. We recommend using the inline declaration „abap.clnt“.
+
+    Only the content of client-dependent “C” and “A” tables is considered during tenant copy and tenant move. Content of client-independent tables that are not delivered from the development system and “L” tables are lost during tenant lifecycle processes such as tenant move.
+
+    During tenant deletion, the content of all client-dependent tables is removed.
+
+    The delivery class must be “C”, “A”, or “L”.
+
+    The delivery classes “E”, “G” and “W” are not supported in the ABAP environment at all.
+
+-   System Content \(client-independent\): System configuration data – tables with delivery class “S”
+
+    Store data that is defined by the service provider and not specific for any tenant in a client-independent “S” table. Define the content in the respective development system and export it as TABU entries via a development transport request. The content is considered as code and imported like other development artifacts into subsequent systems such as the provider system.
+
+    Access to tables and all further ABAP Cloud Syntax is by default tenant aware.
+
+
+See [Multitenancy Development Guideline](https://help.sap.com/docs/sap-btp-abap-environment/abap-environment/multitenancy-development-guideline).
+