Final tweaks

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md

@@ -6,11 +6,11 @@ weight: 2
 layout: learningpathall
 ---
 
-# Getting started with the OrchardCore app 
+## Getting started with the OrchardCore app 
 
 In this section, you'll build and run a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, which is a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, that's commonly used to create content-driven websites.
 
-## Set up your development environment
+### Set up your development environment
 
 First, launch an Azure Cobalt 100 instance (Arm-based VM) running Ubuntu 24.04, and open port 8080 to the internet. 
 
@@ -43,7 +43,7 @@ Install gcc for compiling your application:
 sudo apt install gcc g++ build-essential -y
 ```
 
-## Install the OrchardCore templates
+### Install the OrchardCore templates
 
 Install the OrchardCore templates:
 
@@ -66,7 +66,7 @@ Orchard Core Mvc Web App  ocmvc        [C#]      Web/Orchard Core/Mvc
 Orchard Core Theme        octheme      [C#]      Web/Orchard Core/CMS
 ```
 
-## Create a new OrchardCore application
+### Create a new OrchardCore application
 
 First, create a new project using the `dotnet` CLI to create a new OrchardCore application:
 
@@ -82,7 +82,7 @@ Now navigate to the project directory:
 cd MyOrchardCoreApp
 ```
 
-## Run the OrchardCore application
+### Run the OrchardCore application
 
 Build the application: 
 
@@ -115,12 +115,12 @@ Access the application:
 
 * In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action. 
 
-* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the Networking tab of your virtual machine.
+* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the **Networking** tab of your virtual machine.
 
 Configure the application: 
 
-On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
+* On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
 
-## Summary and next steps
+### Summary and next steps
 
 You have successfully created and run a basic OrchardCore CMS application. In the next sections, you will learn how to integrate a C shared library into your .NET application and explore performance optimizations for Arm architecture.

content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md

@@ -7,11 +7,15 @@ layout: learningpathall
 ---
 ## Create a C shared library
 
-In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application. You’ll create the library, compile it, and call it from your .NET code. This allows you to reuse existing C code and improve performance by accessing native functionality.
+In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application, by doing the following:
 
-First, create a simple C shared library that defines a function you’ll call from your .NET application.
+- Write a C function
+- Compile it into a shared object (`.so`)
+- Call it from C# using `DllImport`
 
-Create a new file named `mylib.c` with the following content:
+This allows you to reuse existing C code and improve performance by accessing native functionality.
+
+Create a file named `mylib.c` with the following:
 
 ```c
 #include <stdio.h>

content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md

@@ -6,15 +6,26 @@ weight: 5
 layout: learningpathall
 ---
 
-## Evaluate .NET versions for performance on Arm
+## Version-by-version feature and throughput improvements
 
 Understanding which versions perform best and the features they offer can help you make informed decisions when developing applications for Arm-based systems.
 
 .NET has evolved significantly over the years, with each version introducing new features and performance improvements. Here, you will learn about key versions that have notable performance implications for Arm architecture.
 
+{{% notice Support status summary %}}
+
+- .NET 8 – Current LTS (support until Nov 2026)
+- .NET 9 – STS (preview; GA Q4 2025)
+- .NET 10 – Next LTS (preview; expected 2025 Q4–Q1 2026)
+- .NET 3.1, 5, 6, 7 – End of life
+{{% /notice %}}
+
+
 ## .NET Core 3.1 (end-of-life 2022)
 
-.NET Core 3.1 was the first LTS with meaningful Arm64 support. Highlights were:
+.NET Core 3.1 was the first LTS with meaningful Arm64 support. 
+
+Highlights were:
 
 - Initial JIT (Just-In-Time) optimizations for Arm64 (but the bulk of Arm throughput work arrived in .NET 5).
 - Faster garbage collection thanks to refinements to the background GC mode.
@@ -39,18 +50,22 @@ With .NET 5 Microsoft started the “one .NET” unification. Even though it had
 
 ## .NET 7 (end-of-life 2024)
 
-.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. Key highlights were:
+.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. 
+
+Key highlights were:
 
 - General-availability of Native AOT publishing for console applications, producing self-contained, very small binaries with fast start-up on Arm64.
 - Dynamic PGO (Profile-Guided Optimisation) and On-Stack Replacement became the default, letting the JIT optimise the hottest code paths based on real run-time data.
 - New Arm64 hardware intrinsics (e.g. SHA-1/SHA-256, AES, CRC-32) exposed through System.Runtime.Intrinsics, enabling high-performance crypto workloads.
 
 ## .NET 8 (current LTS – support until November 2026)
 
-.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. Important Arm-related improvements include:
+.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. 
+
+Important Arm-related improvements include:
 
 - Native AOT support for ASP.NET Core, trimming enhancements and even smaller self-contained binaries, translating into faster cold-start for containerised Arm services.
-- Further JIT tuning for Arm64 delivering single- to low-double-digit percentage throughput wins in real-world benchmarks.
+- Further JIT tuning for Arm64 delivering single-digit to low double-digit throughput gains in real-world benchmarks.
 - Smaller base container images (`mcr.microsoft.com/dotnet/aspnet:8.0` and `…/runtime:8.0`) thanks to a redesigned layering strategy, particularly beneficial on Arm where network bandwidth is often at a premium.
 - Garbage-collector refinements that reduce pause times on highly-threaded, many-core servers.
 
@@ -66,10 +81,10 @@ Although .NET 9 will receive only 18 months of support, it is an excellent choic
 
 ## .NET 10 (preview – next LTS)
 
-.NET 10 is still in preview and will likely change prior to it's GA release, but it will be the next LTS version of .NET.
+.NET 10 is still in preview and will likely evolve prior to its GA release, but it will be the next LTS version of .NET, with the following benefits:
 
 - [Extended SVE2 intrinsics](https://github.com/dotnet/runtime/issues/109652) to unlock efficient implementation of large-scale numerical algorithms and on-device AI inference on Arm v9.
 - C# 14 is expected to ship alongside .NET 10, bringing additional compile-time metaprogramming features that can reduce boilerplate on resource-constrained Arm edge devices.
 
-Because .NET 10 is still in preview, you should validate any assumptions about feature availability against the latest preview builds and roadmap updates.
+Developers targeting Arm-based systems should track preview builds and roadmap updates closely to validate feature availability and compatibility with their target platforms.
 

content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md

@@ -4,7 +4,7 @@ title: Migrate a .NET application to Azure Cobalt 100
 
 minutes_to_complete: 25
 
-who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.
+who_is_this_for: This is an advanced topic path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.
 
 learning_objectives: 
     - Build and run a basic OrchardCore CMS application