Merge pull request #2118 from jasonrandrews/review

spelling and link fixes

Author: jasonrandrews

.wordlist.txt

@@ -4323,4 +4323,129 @@ taskset
 unicast
 wrk's
 yy
-zenoh
+zenoh
+AFM
+AOR
+AWSEC
+Agrawal
+Arcee
+Atheros
+ChenYing
+Colima
+Corellium
+Corestone
+Croci
+DBAREMETAL
+Denormal
+Docker's
+Dpls
+ETHOSU
+FVP's
+Gopalakrishnan
+Gorman
+HVM
+Higham
+Huai
+ICML
+IIR
+IIoT
+ImageStreams
+Joana
+Kuo
+LANs
+Liang
+Libmath
+MACC
+MACCs
+MachineSets
+MobileNet
+OpenShift's
+PMLR
+PipelineRun
+PreserveOriginal
+Queryable
+Reimport
+SPRA
+STRINGIFY
+Sram
+TMS
+Tekton
+VPs
+VSCode
+WANs
+WR
+Waheed
+Weidmann
+Wikitest
+XQuartz
+Xiu
+ZGVnN
+Zenon
+afm
+aot
+arXiv
+arcee
+armpl
+ath
+bitbake
+bootloaders
+cntr
+cosf
+cpp's
+datadir
+dddd
+denormal
+denormalized
+edgeimpulse
+ethosu
+expf
+geo
+gupta
+iMac
+instrinsics
+ish
+keypair
+learnable
+libcurl
+lldb
+mL
+mM
+mR
+mlr
+nbc
+nbr
+nodeAffinity
+nordic
+oc
+oe
+openshift
+pcs
+podTemplate
+podTemplate's
+postinstallation
+prepending
+prog
+queryable
+redhat
+reimport
+shadergraph
+sheel
+spra
+stefanalfbo
+subnormals
+taskrun
+tg
+thisunrolling
+tokio
+topologies
+umax
+varg
+vexp
+vgetq
+vres
+wifi
+wlan
+wlp
+wlx
+xquartz
+zenohd

content/learning-paths/automotive/_index.md

@@ -12,15 +12,17 @@ title: Automotive
 weight: 4
 subjects_filter:
 - Containers and Virtualization: 3
-- Performance and Architecture: 1
+- Performance and Architecture: 2
 operatingsystems_filter:
 - Baremetal: 1
-- Linux: 3
+- Linux: 4
 - RTOS: 1
 tools_software_languages_filter:
 - Automotive: 1
+- C: 1
 - Docker: 2
 - Python: 2
+- Raspberry Pi: 1
 - ROS 2: 1
-- ROS2: 1
+- ROS2: 2
 ---

content/learning-paths/cross-platform/multiplying-matrices-with-sme2/1-get-started.md

@@ -58,7 +58,7 @@ code-examples/learning-paths/cross-platform/multiplying-matrices-with-sme2/
 └── sme2_check.c
 ```
 
-Amongst other files, it includes:
+Among other files, it includes:
 - Code examples.
 - A `Makefile` to build the code.
 - `run-fvp.sh` to run the FVP model.

content/learning-paths/cross-platform/multiplying-matrices-with-sme2/7-sme2-matmul-intr.md

@@ -248,8 +248,8 @@ The core of the multiplication is done in 2 parts:
 
 Once again, intrinsics makes it easy to fully leverage SME2, provided you have a
 solid understanding of its available instructions. The compiler is automatically
-handling many low-level aspects (saving / restoring of the difeerent contexts),
-as well as not using registers that are reserved on specific plaforms (like
+handling many low-level aspects (saving / restoring of the diferent contexts),
+as well as not using registers that are reserved on specific platforms (like
 `x18`). Predicates handle corner cases elegantly, ensuring robust execution.
 Most importantly, the code adapts to different SVL values across various
 hardware implementations without requiring recompilation. This follows the key

content/learning-paths/cross-platform/multiplying-matrices-with-sme2/_index.md

@@ -18,7 +18,7 @@ prerequisites:
     - Intermediate proficiency with the C programming language and the Armv9-A assembly language
     - A computer running Linux, macOS, or Windows
     - Installations of Git and Docker for project setup and emulation
-    - A platform that supports SME2 (see the list of [devices with SME2 support](/learning-paths/cross-platform/multiplying-matrices-with-sme2/1-get-started/#devices-with-sme2-support)) or an emulator to run code with SME2 instructions
+    - A platform that supports SME2 (see the list of [devices with SME2 support](/learning-paths/cross-platform/multiplying-matrices-with-sme2/1-get-started/#devices) or an emulator to run code with SME2 instructions
     - Compiler support for SME2 instructions (for example, LLVM 17+ with SME2 backend support)
 
 author: Arnaud de Grandmaison

content/learning-paths/cross-platform/zenoh-multinode-ros2/3_zenoh-multinode.md

@@ -14,7 +14,7 @@ In this session, you’ll use Raspberry Pi boards to simulate a scalable, distri
 
 You’ll learn how to use Docker to deploy the environment on physical devices, and how to duplicate virtual instances using snapshot cloning on Arm Virtual Hardware.
 
-This setup lets you simulate `real-world`, `cross-node communication`, making it ideal for validating Zenoh’s performance in robotics and industrial IoT use cases.
+This setup lets you simulate `real-world`, `cross-node communication`, making it ideal for validating Zenoh's performance in robotics and industrial IoT use cases.
 
 ### Install Docker on Raspberry Pi
 

content/learning-paths/cross-platform/zenoh-multinode-ros2/4_zenoh-ex1-pubsub.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Example 1: Simple Pub/Sub
 
-This first test demonstrates Zenoh’s real-time publish/subscribe model using two Raspberry Pi devices.
+This first test demonstrates  real-time publish/subscribe model using two Raspberry Pi devices.
 
 The following command is to initiate a subscriber for a key expression `demo/example/**`, i.e. a set of topics starting with the path `demo/example`.
 
@@ -36,4 +36,4 @@ The result will look like:
 In the left-side window, I have logged into the device Pi4 and run the z_sub program. 
 It receives values with the key `demo/example/zenoh-rs-pub` continuously published by z_pub running on Pi in the right-side window.
 
-This basic example shows Zenoh’s zero-config discovery and low-latency pub/sub across physical nodes.
+This basic example shows Zenoh's zero-config discovery and low-latency pub/sub across physical nodes.

content/learning-paths/cross-platform/zenoh-multinode-ros2/5_zenoh-ex2-storagequery.md

@@ -8,13 +8,13 @@ layout: learningpathall
 
 ## Example 2: Storage and Query
 
-The second example adds Zenoh’s data storage and querying capabilities—enabling nodes to retrieve historical values on demand.
+The second example adds Zenoh's data storage and querying capabilities—enabling nodes to retrieve historical values on demand.
 
 Building on the previous Pub/Sub example, you’ll now explore how Zenoh supports `persistent data storage` and `on-demand querying` -- a powerful feature for robotics and IIoT applications.
 
 In a typical warehouse or factory scenario, autonomous robots may periodically publish sensor data (e.g., position, temperature, battery level), and a central system—or another robot—may later need to query the latest state of each unit. 
 
-Unlike Pub/Sub, which requires live, real-time message exchange, Zenoh’s storage and query model enables asynchronous access to data that was published earlier, even if the original publisher is no longer online.
+Unlike Pub/Sub, which requires live, real-time message exchange, Zenoh's storage and query model enables asynchronous access to data that was published earlier, even if the original publisher is no longer online.
 
 In this example, you’ll run the zenohd daemon with in-memory storage and use z_put to publish data and z_get to retrieve it.
 
@@ -70,5 +70,5 @@ The result will look like:
 If you have more than two Raspberry Pi devices, you can run the z_get command on a third RPi to validate that storage queries work seamlessly across a multi-node setup.
 {{% /notice %}}
 
-This example shows how Zenoh’s Storage + Query model supports asynchronous data access and resilient state-sharing—critical capabilities in robotics and industrial IoT systems where network connectivity may be intermittent or system components loosely coupled.
+This example shows how Zenoh's Storage + Query model supports asynchronous data access and resilient state-sharing—critical capabilities in robotics and industrial IoT systems where network connectivity may be intermittent or system components loosely coupled.
 

content/learning-paths/cross-platform/zenoh-multinode-ros2/6_zenoh-ex3-queryable.md

@@ -8,15 +8,15 @@ layout: learningpathall
 
 ## Example 3: Computation on Query using Queryable
 
-Next, you’ll explore Zenoh’s queryable capability, which lets a node dynamically respond to data queries by executing a custom computation or data generation function in this example.
+Next, you’ll explore Zenoh's queryable capability, which lets a node dynamically respond to data queries by executing a custom computation or data generation function in this example.
 
 Unlike zenohd which simply returns stored data, a queryable node can register to handle a specific key expression and generate responses at runtime. This is ideal for distributed computing at the edge, where lightweight devices—such as Raspberry Pi nodes—can respond to requests with calculated values (e.g., sensor fusion, AI inference results, or diagnostics).
 
 ### Use Case: On-Demand Battery Health Estimation
 
 Imagine a robot fleet management system where the central planner queries each robot for its latest battery health score, which is not published continuously but calculated only when queried.
 
-This saves bandwidth and enables edge compute optimization using Zenoh’s Queryable.
+This saves bandwidth and enables edge compute optimization using Zenoh's Queryable.
 
 ### Step 1: Launch a Queryable Node
 

content/learning-paths/cross-platform/zenoh-multinode-ros2/7_zenoh-querycomp.md

@@ -10,7 +10,7 @@ layout: learningpathall
 
 Finally, you’ll combine pub/sub, storage, and queryable components to simulate a distributed computation flow—demonstrating how Zenoh enables intelligent, coordinated edge systems.
 
-You’ll learn how to use Zenoh’s Queryable API in Rust to build a parameterized query system for estimating battery health at the edge. 
+You’ll learn how to use Zenoh's Queryable API in Rust to build a parameterized query system for estimating battery health at the edge. 
 
 This extends a previous example by supporting runtime query parameters like battery level and temperature.
 
@@ -93,7 +93,7 @@ async fn main() -> zenoh::Result<()> {
 }
 ```
 
-This edge node responds to real-time queries using Zenoh’s Queryable API. It listens for requests on the robot/battery/estimate key and returns a calculated battery health score based on provided input parameters.
+This edge node responds to real-time queries using Zenoh's Queryable API. It listens for requests on the robot/battery/estimate key and returns a calculated battery health score based on provided input parameters.
 
 The program starts by establishing a Zenoh session using open(Config::default()). It then registers a queryable resource on the robot/battery/estimate key. Whenever this key is queried, a callback function is invoked asynchronously using tokio::spawn.
 
@@ -160,7 +160,7 @@ The excepted output will be
 >> Received ('robot/battery/estimate': 'Estimated battery health: 85%')
 ```
 
-You’ve just built a responsive, parameterized edge compute service using Zenoh’s Queryable API in Rust — a lightweight but powerful pattern for real-time intelligence at the edge.
+You’ve just built a responsive, parameterized edge compute service using Zenoh's Queryable API in Rust — a lightweight but powerful pattern for real-time intelligence at the edge.
 
 This approach not only minimizes network overhead but also enables each device to process and respond to context-aware queries on demand. 
 It’s a strong foundation for building scalable, event-driven IoT systems that can adapt dynamically to operational needs.