More updates, including Figure titles.

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/net-aspire/_index.md

@@ -11,9 +11,9 @@ learning_objectives:
     - Modify code on a Windows on Arm development machine.
     - Deploy a .NET Aspire application to Arm-powered virtual machines in the Cloud.
 prerequisites:
-    - A Windows on Arm machine, for example [Windows Dev Kit 2023](https://learn.microsoft.com/en-us/windows/arm/dev-kit), or a Lenovo Thinkpad X13s running Windows 11 to build the .NET Aspire project.    
+    - A Windows on Arm machine, for example the [Windows Dev Kit 2023](https://learn.microsoft.com/en-us/windows/arm/dev-kit), or a Lenovo Thinkpad X13s running Windows 11 to build the .NET Aspire project.    
     - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) from AWS or GCP.
-    - Any code editor. [Visual Studio Code for Arm64](https://code.visualstudio.com/docs/?dv=win32arm64user) is suitable.    
+    - Any code editor. [Visual Studio Code for Arm64](https://code.visualstudio.com/docs/?dv=win32arm64user) is an example of a suitable editor.    
 
 author_primary: Dawid Borycki
 

content/learning-paths/servers-and-cloud-computing/net-aspire/project.md

@@ -1,13 +1,13 @@
 ---
-title: Create an application
+title: Create a project and then an application
 weight: 3
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 
-## Create a Project
+## Create a project
 
 In this section, you will set up the project, which involves installing the Aspire workload.
 
@@ -34,29 +34,55 @@ Installing Aspire.ProjectTemplates.Msi.arm64 ..... Done
 
 Successfully installed workload(s) aspire.
 ```
+## Create an application
+
 Once the Aspire workload is installed, you can create a new application by executing:
 
 ```console
 dotnet new aspire-starter -o NetAspire.Arm
 ```
 This command generates a solution with the following structure:
-* **NetAspire.Arm.AppHost** - the orchestrator, or coordinator, project serves as the backbone of your distributed application. Its primary responsibilities include defining how services connect to one another, configuring ports and endpoints to ensure seamless communication, managing service discovery to enable efficient interactions between components, and handling container orchestration to streamline the deployment and operation of services within your application.
+* **NetAspire.Arm.AppHost** - the orchestrator, or coordinator, project serves as the backbone of your distributed application. Its primary responsibilities include:
+
+    - Defining how services connect to one another.
+    - Configuring ports and endpoints to ensure seamless communication.
+    - Managing service discovery to enable efficient interactions between components.
+    - Handling container orchestration to streamline the deployment and operation of services within your application.
+
+* **NetAspire.Arm.ApiService** - the sample REST API service, built with ASP.NET Core, acts as a core component of your application by implementing business logic and managing data access. The default implementation comes preconfigured with essential features, that include:
 
-* **NetAspire.Arm.ApiService** - the sample REST API service, built with ASP.NET Core, acts as a core component of your application by implementing business logic and managing data access. The default implementation comes preconfigured with essential features, including a WeatherForecast endpoint for demonstration purposes, built-in health checks to monitor the service’s status, and telemetry setup to track performance and usage metrics.
+    * A weatherForecast endpoint for demonstration purposes.
+    * Built-in health checks to monitor the service’s status
+    * Telemetry setup to track performance and usage metrics.
 
-* **NetAspire.Arm.Web** - the web frontend application, implemented with Blazor, serves as the user-facing layer of your application. It communicates with the API service to provide an interactive experience. This application includes a user interface for presenting data, client-side logic for handling interactions, and preconfigured patterns for consuming services.
+* **NetAspire.Arm.Web** - the web frontend application, implemented with Blazor, serves as the user-facing layer of your application. It communicates with the API service to provide an interactive experience. This application includes:
 
-* **NetAspire.Arm.ServiceDefaults** - the shared library provides a centralized foundation for common service configurations across your application. It includes a default middleware setup, preconfigured telemetry settings for tracking performance, standard health check implementations, and logging configurations to ensure consistent and efficient monitoring and debugging.
+    * A user interface for presenting data.
+    * Client-side logic for handling interactions.
+    * Preconfigured patterns for consuming services.
 
-The structure of this project is designed to enhance efficiency and simplify the development of cloud-native applications. At its core, it incorporates features to ensure seamless service interactions, robust monitoring, and an exceptional development experience.
+* **NetAspire.Arm.ServiceDefaults** - the shared library provides a centralized foundation for common service configurations across your application. It includes:
+
+    * A default middleware setup.
+    * Preconfigured telemetry settings for tracking performance.
+    * Standard health check implementations.
+    * Logging configurations to ensure consistent and efficient monitoring and debugging.
+
+The structure of this project is designed to enhance efficiency, and simplify the development of cloud-native applications. At its core, it incorporates features to ensure seamless service interactions, robust monitoring, and an exceptional development experience.
 
 One of the foundational elements is service discovery, which enables automatic service registration, dynamic endpoint resolution, and load balancing. These features ensure that services communicate effectively and handle traffic efficiently, even in complex, distributed environments.
 
 For monitoring and telemetry, the architecture integrates tools like built-in health checks, OpenTelemetry for monitoring, and metrics collection with distributed tracing. These features provide developers with deep insights into application performance, helping to maintain reliability and optimize system operations.
 
 Configuration management offers environment-based settings that make deploying applications across different stages straightforward. Secure secrets management safeguards sensitive information, while standardized service-to-service communication simplifies interactions between microservices.
 
-The architecture is also tailored to improve the development experience. Developers can benefit from local debugging support and a powerful monitoring dashboard. This dashboard provides a detailed view of service health, logs, metrics, trace information, resource usage, and service dependencies. Additionally, hot reload capability allows real-time updates during development, and container support ensures consistency across local and production environments.
+The architecture is also tailored to improve the development experience. Developers can benefit from local debugging support and a powerful monitoring dashboard. This dashboard provides a detailed view of the following:
+
+* Service health.
+* Logs. 
+* Metrics.
+* Trace information.
+* Resource usage.
 
-This thoughtfully-crafted architecture embodies microservices best practices, promoting scalability, maintainability, and service isolation. It not only simplifies deployment and monitoring, but also fosters developer productivity by streamlining workflows and providing intuitive tools for building modern, distributed applications.
+This thoughtfully-crafted architecture embodies best practices for microservices, and promotes scalability, maintainability, and service isolation. It not only simplifies deployment and monitoring, but also fosters developer productivity by streamlining workflows and providing intuitive tools for building modern, distributed applications.
 

content/learning-paths/servers-and-cloud-computing/net-aspire/run_app.md

@@ -18,7 +18,7 @@ cd .\NetAspire.Arm\
 dotnet run --project NetAspire.Arm.AppHost 
 ```
 
-The output will look like below:
+The output should look like the text below:
 ```output
 Building...
 info: Aspire.Hosting.DistributedApplication[0]
@@ -33,15 +33,15 @@ info: Aspire.Hosting.DistributedApplication[0]
       Login to the dashboard at https://localhost:17222/login?t=81f99566c9ec462e66f5eab5aa9307b0
 ```
 
-Click on the link generated for the dashboard. In this case it is: https://localhost:17222/login?t=81f99566c9ec462e66f5eab5aa9307b0. This will direct you to the application dashboard, as shown below:
+Click on the link generated for the dashboard. In this case it is: [https://localhost:17222/login?t=81f99566c9ec462e66f5eab5aa9307b0](https://localhost:17222/login?t=81f99566c9ec462e66f5eab5aa9307b0). This directs you to the application dashboard, as shown in Figure 1:
 
-![fig1](figures/01.png)
+![fig1 alt-text#center](figures/01.png "Figure 1: Application Dashboard.")
 
-On the dashboard, locate and click the endpoint link for `NetAspire.Arm.Web`. This will take you to the Blazor based web application. In the Blazor app, navigate to the Weather section to access and display data retrieved from the WeatherForecast API:
+On the dashboard, locate and click the endpoint link for `NetAspire.Arm.Web`. This takes you to the Blazor-based web application. In the Blazor app, navigate to the Weather section to access and display data retrieved from the WeatherForecast API:
 
-![fig2](figures/02.png)
+![fig2 alt-text#center](figures/02.png "Figure 2: Data Displayed from WeatherForecast API.")
 
-Return to the dashboard and select the Traces option. This section provides detailed telemetry tracing, allowing you to view the flow of requests, track service dependencies, and analyze performance metrics for your application:
+Now return to the dashboard, and select the **Traces** option. This section provides detailed telemetry tracing, allowing you to view the flow of requests, track service dependencies, and analyze performance metrics for your application:
 
 ![fig3](figures/03.png)