Refine titles and descriptions in resource usage documentation for clarity and consistency

Author: madeline-underwood

content/learning-paths/laptops-and-desktops/win-resource-ps1/_index.md

@@ -31,7 +31,7 @@ operatingsystems:
 
 further_reading:
     - resource:
-        title: Recording for Resource-based Analysis
+        title: Recording for resource-based analysis
         link: https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-8.1-and-8/hh448202(v=win.10)
         type: documentation
     - resource:

content/learning-paths/laptops-and-desktops/win-resource-ps1/how-to-1.md

@@ -7,13 +7,12 @@ layout: learningpathall
 ---
 
 ## Overview
-System resource usage provides an approach to understand the performance of an application as a black box. This Learning Path demonstrates how to sample system resource usage using a script.
+To understand how well your application performs, you can measure its system resource usage (such as CPU time and memory) without needing to look inside the code. In this Learning Path, you'll learn how to collect resource usage data using a simple script. This helps you compare performance between different builds and see how efficiently your system runs each version.
 
 The example application you will use is FFmpeg, a tool set that performs video encode and decode tasks. You will run the same tests with both the x86_64 binary (using Windows instruction emulation) and the Arm64 native binary on a Windows on Arm computer.
 
 ## Download the packages
-
-You don't need to build FFmpeg from scratch—just grab the ready-made binaries and get started.
+You don't need to compile FFmpeg from source. You can download the pre-built binaries to begin your testing:
 
 - First, download the [FFmpeg x86_64 package](https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-07-31-14-15/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip).
 - Next, download the [FFmpeg Arm64 native package](https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-07-31-14-15/ffmpeg-n7.1.1-56-gc2184b65d2-winarm64-gpl-7.1.zip).
@@ -23,20 +22,19 @@ You don't need to build FFmpeg from scratch—just grab the ready-made binaries
 Once you've downloaded both packages, unzip them. You'll find the binaries in the `bin` folder inside each package. The x86_64 version is for emulation, while the Arm64 version runs natively on your Windows on Arm device. Double-check the folder names so you don't mix them up.
 
 {{% notice Note %}}
-It's a good idea to create a separate folder for each version. Make a note of where you put both `ffmpeg.exe` and `ffplay.exe` for each version—you'll need these paths soon to run your tests and compare results.
+It's a good idea to create a separate folder for each version. Make a note of where you put both `ffmpeg.exe` and `ffplay.exe` for each version as you'll need these paths soon to run your tests and compare results.
 {{% /notice %}}
 
 Now you're set up with both versions of FFmpeg. Next, you'll use these binaries to encode a video and see how each one performs.
 
 ## Download the video source
 
-For this test, you'll use a sample video called RaceNight. Download it from [this public dataset](https://ultravideo.fi/video/RaceNight_3840x2160_50fps_420_8bit_YUV_RAW.7z).
+For this test, you'll use a sample video called RaceNight. Download it from this [RaceNight public dataset](https://ultravideo.fi/video/RaceNight_3840x2160_50fps_420_8bit_YUV_RAW.7z).
 
 Unzip the package and make a note of the path to the `.yuv` file inside.
 
 ## Encode the video
-
-The video you just downloaded is in YUV raw format, which means it's uncompressed and doesn't need decoding to play. To really test your system, you'll use FFmpeg to compress the video with the x265 encoder and convert it to an `.mp4` file.
+The video you downloaded is in `.yuv` raw format. This means it's uncompressed and ready for processing, so no decoding step is needed. To test your system's performance, you'll use FFmpeg to compress the video with the x265 encoder and convert it to an `.mp4` file. This workflow lets you measure how efficiently each FFmpeg binary handles video encoding on your Windows on Arm device.
 
 Assuming everything is in your current directory, open a terminal and run this command:
 
@@ -45,10 +43,10 @@ ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1\ffmpeg-n7.1.1-56-gc2184b65d2-win64-gp
 ```
 
 {{% notice Note %}}
-Make sure to update the paths to `ffmpeg.exe` and the YUV video file to match where you saved them.
+Make sure to update the paths to `ffmpeg.exe` and the `yuv.` video file to match where you saved them.
 {{% /notice %}}
 
-This command resizes the video and compresses it into an MP4 file using H.265 encoding (via the x265 encoder). The `-benchmark` option shows performance stats while the encoding runs. When it's done, you'll have a new file called `RaceNight_1080p.mp4`.
+This command resizes the video and compresses it into an MP4 file using H.265 encoding (using the x265 encoder). The `-benchmark` option shows performance stats while the encoding runs. When it's done, you'll have a new file called `RaceNight_1080p.mp4`.
 
 Try running the command with both the x86_64 and Arm64 versions of FFmpeg. Then, compare the results to see which one is faster.
 
@@ -104,7 +102,7 @@ x265 [info]: Weighted P-Frames: Y:0.0% UV:0.0%
 encoded 600 frames in 26.20s (22.90 fps), 9110.78 kb/s, Avg QP:27.23
 ```
 
-Check out the last line in each output—the run time and frames per second show how each build performed. The Arm64 version is much faster, thanks to running natively on your hardware.
+Check out the last line in each output. The run time and frames per second show how each build performed. The Arm64 version is much faster, thanks to running natively on your hardware.
 
 ## Review your progress and compare performance
 

content/learning-paths/laptops-and-desktops/win-resource-ps1/how-to-2.md

@@ -6,11 +6,12 @@ weight: 3
 layout: learningpathall
 ---
 
-## Sample video decoding resource usage
+## Analyze resource usage during sample video decoding
 
-To monitor resource usage during video decoding, use the following PowerShell script. This script starts the decoding process, periodically records CPU and memory statistics, and saves the results to a CSV file for analysis.
 
-Open your code editor, copy the content below, and save it as `sample_decoding.ps1`.
+To monitor resource usage during video decoding, use the following PowerShell script. This script starts the decoding process, periodically records CPU and memory statistics, and then saves the results to a CSV file for analysis.
+
+Open your code editor, copy the content below, and save it as `sample_decoding.ps1`:
 
 ```PowerShell { line_numbers = true }
 param (
@@ -114,24 +115,23 @@ Run the script:
 Set-ExecutionPolicy -Scope Process RemoteSigned
 .\sample_decoding.ps1
 ```
-
-A video starts playing and completes in 3 minutes. When finished, you can find the results file `usage_log.csv` in the current directory.
+When you run the script, the video plays for about three minutes. After playback finishes, you'll find the results file named `usage_log.csv` in your current directory. Open this file with a spreadsheet application to review and analyze the recorded resource usage data.
 
 {{% notice Note %}}
-Script execution may be blocked due to security policy configuration. The `Set-ExecutionPolicy` command allows local scripts to run during this session.
+Script execution might be blocked due to security policy configuration. The `Set-ExecutionPolicy` command allows local scripts to run during this session.
 {{% /notice %}}
 
-### Script explanation
+## Understand what the script does
 
 The `param` section defines variables including the binary path, video playback arguments, sampling interval, and result file path. You can modify these values as needed.
 
-Lines 15-26 check and modify the binary file attributes. The binaries in use are downloaded from the web and may be blocked from running due to lack of digital signature. These lines unlock the binaries.
+Lines 15–26 check whether the binary file is blocked by Windows security settings. When you download executables from the web, Windows may prevent them from running if they lack a digital signature. This section attempts to unlock the binary using the `Unblock-File` command, allowing the script to run the application without security restrictions.
 
 Line 41 retrieves all child processes of the main process. The statistical data includes resources used by all processes spawned by the main process.
 
 The `while` section collects CPU and memory usage periodically until the application exits. The CPU usage represents accumulated time that the process runs on the CPU. The memory usage shows the size of memory occupation with or without shared spaces accounted for.
 
-### View results
+### View the results
 
 The output below shows the results from running the x86_64 version of `ffplay.exe`:
 
@@ -150,5 +150,4 @@ Timestamp,CPU Sum (s),Memory Sum (MB),Memory Private Sum (MB),CPU0 (s),Memory0 (
 ......
 2025-08-18T10:39:01.7856168+08:00,329.109375,352.53,339.96,329.09375,340.23046875,338.20703125,0.015625,12.30078125,1.75390625
 ```
-
-The sample result file uses CSV (comma-separated values) format. You can open it with spreadsheet applications like Microsoft Excel for better visualization and create charts for data analysis.
+The sample result file is in CSV (comma-separated values) format. Open it with a spreadsheet application such as Microsoft Excel to view the data in a table. You can use built-in chart tools to visualize CPU and memory usage over time, making it easier to spot trends and compare performance between Arm64 and x86_64 versions.

content/learning-paths/laptops-and-desktops/win-resource-ps1/how-to-3.md

@@ -1,12 +1,12 @@
 ---
-title: Measure power usage
+title: Measure power usage on Windows on Arm with PowerShell
 weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Sampling battery status
+## Sample the battery status
 
 Querying battery status provides a way to measure power usage without an external power meter. Battery monitoring is also convenient because data collection and logging can be automated.
 
@@ -77,7 +77,7 @@ A video starts playing and completes in 30 minutes. When finished, you can find
 
 The script collects remaining battery capacity and discharge rate periodically. You can track the battery remaining capacity to understand the power consumption patterns.
 
-### View results
+### View the results
 
 The output below shows the results from running the x86_64 version of `ffplay.exe`:
 
@@ -100,3 +100,7 @@ Timestamp,RemainingCapacity(mWh),DischargeRate(mW)
 The sample results file is in CSV format. You can open it with spreadsheet applications like Microsoft Excel for better visualization and to plot data analysis charts.
 
 Battery monitoring provides an effective way to measure power consumption differences between x86_64 and native Arm64 applications. By comparing discharge rates, you can quantify the power efficiency advantages that Arm processors typically demonstrate for video decoding workloads.
+
+## Wrapping up and next steps
+ 
+You’ve measured power usage on your Windows on Arm device and can now compare results across builds to see how native Arm64 performance affects battery life. Sharing your findings with the Arm developer community helps others optimize applications for Windows on Arm.