Merge pull request #2686 from jasonrandrews/review3

Eliminate links that explain to click here or review this Learning Path

Author: jasonrandrews

content/install-guides/stm32_vs.md

@@ -69,7 +69,7 @@ Run the installer(s) and follow on-screen instructions.
 
 ### How do I install Git for version control functionality?
 
-You can download the latest version from [here](https://git-scm.com/).
+You can download the latest version from [git-scm.com](https://git-scm.com/).
 
 ### What about Keil Studio for VS Code?
 

content/learning-paths/cross-platform/kleidiai-explainer/page1.md

@@ -40,13 +40,13 @@ KleidiAI uses modern Arm CPU instructions to accelerate matrix multiplication an
 ## What Arm features does KleidiAI leverage?
 Each KleidiAI matrix multiplication micro-kernel uses a specific Arm architecture feature to enhance AI inference. In this section you can read a description of each architecture feature that KleidiAI uses to accelerate matrix multiplication.
 
-* **Dot Product**: KleidiAI uses the `vdotq_s32` intrinsic, which is a vector dot product, introduced as part of SIMD. It computes the dot product of two vector 8-bit integers, and accumulates the result into a 32-bit integer. View the `vdot` documentation [here](https://developer.arm.com/documentation/ddi0597/2024-03/SIMD-FP-Instructions/VDOT--by-element---BFloat16-floating-point-indexed-dot-product--vector--by-element--).
+* **Dot Product**: KleidiAI uses the `vdotq_s32` intrinsic, which is a vector dot product, introduced as part of SIMD. It computes the dot product of two vector 8-bit integers, and accumulates the result into a 32-bit integer. View the [`vdot` documentation](https://developer.arm.com/documentation/ddi0597/2024-03/SIMD-FP-Instructions/VDOT--by-element---BFloat16-floating-point-indexed-dot-product--vector--by-element--).
 
-* **SMMLA**: KleidiAI also makes use of the Int8 Matrix Multiplication (i8mm) feature including the `SMMLA` instruction (*Signed 8-bit integer matrix multiply-accumulate*). It multiplies a 2x8 matrix of 8-bit integers by a 8x2 matrix of 8-bit integers, which is accumulated into a 2x2 matrix of 32-bit integers. For more information, view the *SMMLA* and *i8mm* documentation [here](https://developer.arm.com/documentation/ddi0602/latest/SIMD-FP-Instructions/SMMLA--vector---Signed-8-bit-integer-matrix-multiply-accumulate--vector--).
+* **SMMLA**: KleidiAI also makes use of the Int8 Matrix Multiplication (i8mm) feature including the `SMMLA` instruction (*Signed 8-bit integer matrix multiply-accumulate*). It multiplies a 2x8 matrix of 8-bit integers by a 8x2 matrix of 8-bit integers, which is accumulated into a 2x2 matrix of 32-bit integers. For more information, view the [*SMMLA* and *i8mm* documentation](https://developer.arm.com/documentation/ddi0602/latest/SIMD-FP-Instructions/SMMLA--vector---Signed-8-bit-integer-matrix-multiply-accumulate--vector--).
 
-* **FMLA**: This instruction, *Floating-point Multiply Accumulate*, is for 16-bit operations. It is included as part of the Advanced SIMD extension, multiplying and accumulating two vectors together, each containing eight 16-bit numbers. View the `FMLA` documentation [here](https://developer.arm.com/documentation/ddi0602/2024-03/SIMD-FP-Instructions/FMLA--vector---Floating-point-fused-Multiply-Add-to-accumulator--vector--).
+* **FMLA**: This instruction, *Floating-point Multiply Accumulate*, is for 16-bit operations. It is included as part of the Advanced SIMD extension, multiplying and accumulating two vectors together, each containing eight 16-bit numbers. View the [`FMLA` documentation](https://developer.arm.com/documentation/ddi0602/2024-03/SIMD-FP-Instructions/FMLA--vector---Floating-point-fused-Multiply-Add-to-accumulator--vector--).
 
-* **FMOPA**: This instruction stands for *Floating-point outer product and accumulate*. It is included in the Arm Scalable Matrix Extension (SME). The single precision `FMOPA` variant enables optimized matrix multiplication on 32-bit numbers. View the `FMOPA` documentation [here](https://developer.arm.com/documentation/ddi0602/2023-12/SME-Instructions/FMOPA--non-widening---Floating-point-outer-product-and-accumulate-?lang=en).
+* **FMOPA**: This instruction stands for *Floating-point outer product and accumulate*. It is included in the Arm Scalable Matrix Extension (SME). The single precision `FMOPA` variant enables optimized matrix multiplication on 32-bit numbers. View the [`FMOPA` documentation](https://developer.arm.com/documentation/ddi0602/2023-12/SME-Instructions/FMOPA--non-widening---Floating-point-outer-product-and-accumulate-?lang=en).
 
 Today, Arm-powered hardware containing these instructions exist in cloud servers and smartphones. Here are some examples of the first products from popular vendors that support KleidiAI:
 

content/learning-paths/cross-platform/psa-tfm/run.md

@@ -8,7 +8,7 @@ weight: 4 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 {{% notice  MPS3%}}
-MPS3 users can jump to [here](#mps3).
+MPS3 users can jump to the [MPS3 section](#mps3).
 {{% /notice %}}
 
 

content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part1.md

@@ -282,7 +282,7 @@ Feature detection in particular refers to minor extensions in the ISA that are n
 #endif
 ```
 
-A full list of current extensions for Arm can be found [here](https://doc.rust-lang.org/std/arch/macro.is_aarch64_feature_detected.html) while the full list of supported intrinsics is [here](https://doc.rust-lang.org/core/arch/aarch64/index.html).
+A [full list of current extensions for Arm](https://doc.rust-lang.org/std/arch/macro.is_aarch64_feature_detected.html) is available, and the [full list of supported intrinsics](https://doc.rust-lang.org/core/arch/aarch64/index.html) is also documented.
 
 ## An alternative way with Rust using std::simd
 

content/learning-paths/cross-platform/simd-on-rust/simd-on-rust-part4.md

@@ -225,7 +225,7 @@ fff6 0000 0000 0000
 
 A 4x4 matrix `a` is initialized and a `fDCT` function is called on it. The function carries out 2 passes of the same algorithm on the elements of the array, calls the 2 butterfly functions (for one and two coefficients respectively) and transposes the results in between the calculations. The result is rounded and stored in the output buffer `dct`.
 
-The assembly output is linked [here](/learning-paths/cross-platform/simd-on-rust/butterfly1.asm) instead of being displayed due to its size.
+The [assembly output](/learning-paths/cross-platform/simd-on-rust/butterfly1.asm) is available separately due to its size.
 
 Now create a Rust version of this algorithm and save the contents below in a file called `butterfly2.rs`:
 
@@ -393,7 +393,7 @@ ff71 0000 0000 0000
 fff6 0000 0000 0000
 ```
 
-The disassembly output is linked [here](/learning-paths/cross-platform/simd-on-rust/butterfly2.asm) for size reasons. You will see that it is very similar to the C version, apart from the cpu feature check at the start.
+The [disassembly output](/learning-paths/cross-platform/simd-on-rust/butterfly2.asm) is available separately for size reasons. You will see that it is very similar to the C version, apart from the cpu feature check at the start.
 
 ### Comments
 

content/learning-paths/embedded-and-microcontrollers/edge_impulse_greengrass/edgeimpulseprojectbuild.md

@@ -74,7 +74,7 @@ Clicking on "Object Detection" on the left, you will see some detail on the mode
 
 ![Edge Impulse](./images/EI_Project_3.png)
 
-In our project, the "Impulse" is fully created, trained, and optimized so we won't have to walk through those steps.  Edge Impulse has a ton of examples and docs available [here](https:://docs.edgeimpulse.com) to walk you through your first "Impulse" creation:
+In our project, the "Impulse" is fully created, trained, and optimized so we won't have to walk through those steps.  Edge Impulse has a ton of [examples and documentation](https:://docs.edgeimpulse.com) to walk you through your first "Impulse" creation:
 
 ![Edge Impulse](./images/EI_Project_4.png)
 

content/learning-paths/embedded-and-microcontrollers/edge_impulse_greengrass/overview.md

@@ -23,9 +23,9 @@ The Edge Impulse integration with AWS IoT Core and AWS IoT Greengrass is structu
 * The Edge Impulse "Runner" service can relay inference results into IoT Core for further processing in the cloud
 * The Edge Impulse "Runner" service relays model performance metrics, at configurable intervals, into IoTCore for further processing.
 * The Edge Impulse "Runner" service has accessible commands that can be used to configure the service real-time as well as retrieve information about the model/service/configuration.
-* More information regarding the Edge Impulse "Runner" service itself can be found [here](https://docs.edgeimpulse.com/docs/tools/edge-impulse-for-linux/linux-node-js-sdk).
+* More information regarding the Edge Impulse "Runner" service itself can be found in the [Edge Impulse for Linux Node.js SDK documentation](https://docs.edgeimpulse.com/docs/tools/edge-impulse-for-linux/linux-node-js-sdk).
 
-Edge Impulse has several custom Greengrass components that can be deployed and run on the Greengrass-enabled edge device to enable this integration. The component recipes and artifacts can be found [here](https://github.com/edgeimpulse/aws-greengrass-components). Lets examine one of those components that we'll used for this workshop!
+Edge Impulse has several custom Greengrass components that can be deployed and run on the Greengrass-enabled edge device to enable this integration. The component recipes and artifacts can be found in the [AWS Greengrass components repository](https://github.com/edgeimpulse/aws-greengrass-components). Lets examine one of those components that we'll used for this workshop!
 
 ### The "EdgeImpulseLinuxRunnerServiceComponent" Greengrass Component
 
@@ -45,7 +45,7 @@ Command results are published to the following topic:
 
 		/edgeimpulse/device/<EdgeImpulseDeviceName>/command/output
 
-The command reference, including JSON structure details, can be found [here](https://docs.edgeimpulse.com/docs/integrations/aws-greengrass#commands-january-2025-integration-enhancements).
+The command reference, including JSON structure details, can be found in the [Edge Impulse AWS Greengrass integration documentation](https://docs.edgeimpulse.com/docs/integrations/aws-greengrass#commands-january-2025-integration-enhancements).
 
 Lets dive deeper into this integration starting with setting up our own edge device!  
 

content/learning-paths/laptops-and-desktops/electron/_index.md

@@ -11,7 +11,7 @@ learning_objectives:
 
 prerequisites:
     - A Windows on Arm computer such as the Lenovo Thinkpad X13s running Windows 11 or a Windows on Arm [virtual machine](/learning-paths/cross-platform/woa_azure/).
-    - Node.js for Arm64. You can find the installer [here](https://nodejs.org/dist/v20.10.0/node-v20.10.0-arm64.msi)
+    - Node.js for Arm64. You can find the [Node.js installer](https://nodejs.org/dist/v20.10.0/node-v20.10.0-arm64.msi).
     - Any code editor; we recommend using [Visual Studio Code for Arm64](https://code.visualstudio.com/docs/?dv=win32arm64user).
 
 author: Dawid Borycki

content/learning-paths/laptops-and-desktops/electron/how-to-1.md

@@ -15,10 +15,10 @@ In this learning path you will learn how to create a Desktop application for Win
 
 Here, you will use the posts endpoint of the `JSONPlaceholder`. This endpoint enables you to retrieve the list of hypothetical posts.
 
-You can find the the complete code used in the learning path [here](https://github.com/dawidborycki/electron-sample-app.git)
+You can find the [complete code on GitHub](https://github.com/dawidborycki/electron-sample-app.git).
 
 ## Before you begin
-Before you begin, install Node.JS for Arm64. You can find the installer [here](https://nodejs.org/en/download). In this learning path, you will use version 20.10.0. The installation process is automatic. However, make sure to check the "Automatically install the necessary tools" checkbox so that it automatically installs the build tools for the NPM packages:
+Before you begin, install Node.JS for Arm64. You can find the [Node.js installer](https://nodejs.org/en/download). In this learning path, you will use version 20.10.0. The installation process is automatic. However, make sure to check the "Automatically install the necessary tools" checkbox so that it automatically installs the build tools for the NPM packages:
 
 ![fig1](figures/01.png)
 

content/learning-paths/laptops-and-desktops/self_hosted_cicd_github/_index.md

@@ -12,8 +12,8 @@ learning_objectives:
 
 prerequisites:
     - An Arm64-powered machine, either virtual or physical. This Learning Path demonstration uses an Arm64-powered VM with Ubuntu 22.04.
-    - A DockerHub account. You can set up a free account [here](https://hub.docker.com/signup).
-    - A GitHub account. You can sign up [here](https://github.com/signup).
+    - A DockerHub account. You can [set up a free DockerHub account](https://hub.docker.com/signup).
+    - A GitHub account. You can [sign up for GitHub](https://github.com/signup).
 
 author: Dawid Borycki