formatting fixes

Author: JoeStech

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

@@ -25,9 +25,9 @@ sudo apt-get install -y dotnet-sdk-8.0
 
 3. **Verify installations**:
 
-   ```bash
-   dotnet --version
-   ```
+```bash
+dotnet --version
+```
 
 ## Step 2: Install the OrchardCore Templates
 
@@ -43,31 +43,31 @@ This command installs the OrchardCore project templates, which you will use to c
 
 1. **Create a new project**: Use the `dotnet` CLI to create a new OrchardCore application.
 
-   ```bash
-   dotnet new occms -n MyOrchardCoreApp
-   ```
+```bash
+dotnet new occms -n MyOrchardCoreApp
+```
 
    This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`.
 
 2. **Navigate to the project directory**:
 
-   ```bash
-   cd MyOrchardCoreApp
-   ```
+```bash
+cd MyOrchardCoreApp
+```
 
 ## Step 4: Run the OrchardCore application
 
 1. **Build the application**: Compile the application using the following command:
 
-   ```bash
-   dotnet build
-   ```
+```bash
+dotnet build
+```
 
 2. **Run the application**: Start the application with:
 
-   ```bash
-   dotnet run --urls http://0.0.0.0:8080
-   ```
+```bash
+dotnet run --urls http://0.0.0.0:8080
+```
 
 3. **Access the application**: Open a web browser and navigate to `http://[instance IP]:8080` to see your OrchardCore application in action, where `[instance IP]` is the public IP of your Azure Cobalt instance.
 

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

@@ -17,19 +17,19 @@ First, you need to create a simple C shared library. This library will contain a
 
 1. Create a new file named `mylib.c` with the following content:
 
-    ```c
-    #include <stdio.h>
+```c
+#include <stdio.h>
 
-    void greet() {
-        printf("Hello from the C library!\n");
-    }
-    ```
+void greet() {
+    printf("Hello from the C library!\n");
+}
+```
 
 2. Compile the C file into a shared library:
 
-    ```bash
-    gcc -shared -o libmylib.so -fPIC mylib.c
-    ```
+```bash
+gcc -shared -o libmylib.so -fPIC mylib.c
+```
 
    This will generate a shared library file (`libmylib.so`).
 
@@ -39,54 +39,54 @@ Now that you have a shared library, you can use it in your .NET application.
 
 1. In your OrchardCore application, create a new class file named `NativeMethods.cs`:
 
-    ```csharp
-    using System;
-    using System.Runtime.InteropServices;
+```csharp
+using System;
+using System.Runtime.InteropServices;
 
-    public static class NativeMethods
-    {
-        [DllImport("mylib", EntryPoint = "greet")]
-        public static extern void Greet();
-    }
-    ```
+public static class NativeMethods
+{
+    [DllImport("mylib", EntryPoint = "greet")]
+    public static extern void Greet();
+}
+```
 
 2. Call the `Greet` method from your application. For example, you can add the following code to your main program or a controller:
 
-    ```csharp
-    using OrchardCore.Logging;
+```csharp
+using OrchardCore.Logging;
 
-    var builder = WebApplication.CreateBuilder(args);
+var builder = WebApplication.CreateBuilder(args);
 
-    builder.Host.UseNLogHost();
+builder.Host.UseNLogHost();
 
-    builder.Services
-        .AddOrchardCms()
-        // // Orchard Specific Pipeline
-        // .ConfigureServices( services => {
-        // })
-        // .Configure( (app, routes, services) => {
-        // })
-    ;
+builder.Services
+    .AddOrchardCms()
+    // // Orchard Specific Pipeline
+    // .ConfigureServices( services => {
+    // })
+    // .Configure( (app, routes, services) => {
+    // })
+;
 
-    var app = builder.Build();
+var app = builder.Build();
 
-    Console.WriteLine("Calling native greet..."); // NEW INTEROP LINE
-    NativeMethods.Greet();                        // NEW INTEROP LINE
+Console.WriteLine("Calling native greet..."); // NEW INTEROP LINE
+NativeMethods.Greet();                        // NEW INTEROP LINE
 
-    if (!app.Environment.IsDevelopment())
-    {
-        app.UseExceptionHandler("/Error");
-        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
-        app.UseHsts();
-    }
+if (!app.Environment.IsDevelopment())
+{
+    app.UseExceptionHandler("/Error");
+    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+    app.UseHsts();
+}
 
-    app.UseHttpsRedirection();
-    app.UseStaticFiles();
+app.UseHttpsRedirection();
+app.UseStaticFiles();
 
-    app.UseOrchardCore();
+app.UseOrchardCore();
 
-    app.Run();
-    ```
+app.Run();
+```
 
 3. Ensure that dotnet can find your shared library:
 
@@ -115,4 +115,4 @@ aarch64-linux-gnu-gcc -mcpu=neoverse-n2 -O3 -shared -o libmylib.so -fPIC mylib.c
 
 The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD opimizations).
 
-In the next section, you will explore the tradeoffs of building native AOT arm64 binaries.
+In the next section, you will explore how to make your build architecture agnostic with the anyCPU feature.

content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md

@@ -20,25 +20,25 @@ To make your OrchardCore application architecture agnostic, you need to configur
 2. Locate the `.csproj` file for your project.
 3. Modify the `<PlatformTarget>` element to `AnyCPU`:
 
-   ```xml
-   <PropertyGroup>
-     <PlatformTarget>AnyCPU</PlatformTarget>
-   </PropertyGroup>
-   ```
+```xml
+<PropertyGroup>
+  <PlatformTarget>AnyCPU</PlatformTarget>
+</PropertyGroup>
+```
 
 4. Save the changes to the `.csproj` file.
 
 ## Build once, run anywhere
 
-   ```bash
-   dotnet build -c Release
-   ```
+```bash
+dotnet build -c Release
+```
 
 4. Run the application:
 
-   ```bash
-   dotnet run --urls http://0.0.0.0:8080
-   ```
+```bash
+dotnet run --urls http://0.0.0.0:8080
+```
 
 Your application should now be runnable on any architecture. All you have to do is copy the `MyOrchardCoreApp` directory to any computer with the .NET 8 Framework installed and run
 

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

@@ -8,14 +8,12 @@ who_is_this_for: .NET developers who want to take advantage of the cost and perf
 learning_objectives: 
     - Create and compile a basic OrchardCore CMS application
     - Add a simple C shared library to your .NET application
-    - Understand the tradeoffs of building native AOT (ahead-of-time) arm64 binaries
-    - Learn about TieredPGO (Profile Guided Optimization) for .NET
+    - Learn about anyCPU hardware agnostic builds
     - Gain intuition about performance of different .NET versions
-    - .NET optimizations for huge core counts
 
 prerequisites:
     - An Azure account
-    - Installation of .NET 10
+    - Installation of .NET 8
     - gcc installed
 
 author: Joe Stech