Update intro.md

Author: pareenaverma

content/learning-paths/mobile-graphics-and-gaming/android_halide/intro.md

@@ -10,19 +10,19 @@ layout: "learningpathall"
 ## Introduction
 Halide is a powerful, open-source programming language specifically designed to simplify and optimize high-performance image and signal processing pipelines. Initially developed by researchers at MIT and Adobe in 2012, Halide addresses a critical challenge in computational imaging: efficiently mapping image-processing algorithms onto diverse hardware architectures without extensive manual tuning. It accomplishes this by clearly separating the description of an algorithm (specifying the mathematical or logical transformations applied to images or signals) from its schedule (detailing how and where those computations execute). This design enables rapid experimentation and effective optimization for various processing platforms, including CPUs, GPUs, and mobile hardware.
 
-A key advantage of Halide lies in its innovative programming model. By clearly distinguishing between algorithmic logic and scheduling decisions—such as parallelism, vectorization, memory management, and hardware-specific optimizations—developers can first focus on ensuring the correctness of their algorithms. Performance tuning can then be handled independently, significantly accelerating development cycles. This approach often yields performance that matches or even surpasses manually optimized code. As a result, Halide has seen widespread adoption across industry and academia, powering image processing systems at technology giants such as Google, Adobe, and Facebook, and enabling advanced computational photography features used by millions daily.
+A key advantage of Halide lies in its innovative programming model. By clearly distinguishing between algorithmic logic and scheduling decisions—such as parallelism, vectorization, memory management, and hardware-specific optimizations, developers can first focus on ensuring the correctness of their algorithms. Performance tuning can then be handled independently, significantly accelerating development cycles. This approach often yields performance that matches or even surpasses manually optimized code. As a result, Halide has seen widespread adoption across industry and academia, powering image processing systems at organizations such as Google, Adobe, and Facebook, and enabling advanced computational photography features used by millions daily.
 
 In this learning path, you will explore Halide’s foundational concepts, set up your development environment, and create your first functional Halide application. By the end, you will understand what makes Halide uniquely suited to efficient image processing, particularly on mobile and Arm-based hardware, and be ready to build your own optimized pipelines.
 
-For broader or more general use cases, please refer to the official Halide documentation and tutorials available at halide-lang.org.
+For broader or more general use cases, please refer to the official Halide documentation and tutorials available at [halide-lang.org](https://halide-lang.org).
 
-The example code for this Learning Path is available in the following repositories: [here](https://github.com/dawidborycki/Arm.Halide.Hello-World.git) and [here](https://github.com/dawidborycki/Arm.Halide.AndroidDemo.git)
+The example code for this Learning Path is available in two repositories [here](https://github.com/dawidborycki/Arm.Halide.Hello-World.git) and [here](https://github.com/dawidborycki/Arm.Halide.AndroidDemo.git)
 
 ## Key concepts in Halide
 ### Separation of algorithm and schedule
 At the core of Halide’s design philosophy is the principle of clearly separating algorithms from schedules. Traditional image-processing programming tightly couples algorithmic logic with execution strategy, complicating optimization and portability. In contrast, Halide explicitly distinguishes these two components:
-* Algorithm. Defines what computations are performed—for example, image filters, pixel transformations, or other mathematical operations on image data.
-* Schedule. Specifies how and where these computations are executed, addressing critical details such as parallel execution, memory usage, caching strategies, and hardware-specific optimizations.
+  * Algorithm: Defines what computations are performed—for example, image filters, pixel transformations, or other mathematical operations on image data.
+  * Schedule: Specifies how and where these computations are executed, addressing critical details such as parallel execution, memory usage, caching strategies, and hardware-specific optimizations.
 
 This separation allows developers to rapidly experiment and optimize their code for different hardware architectures or performance requirements without altering the core algorithmic logic.
 
@@ -42,9 +42,9 @@ Halide is a domain-specific language (DSL) tailored explicitly for image and sig
 
 ### Scheduling strategies (parallelism, vectorization, tiling)
 Halide offers several powerful scheduling strategies designed for maximum performance:
-* Parallelism. Executes computations concurrently across multiple CPU cores, significantly reducing execution time for large datasets.
-* Vectorization. Enables simultaneous processing of multiple data elements using SIMD (Single Instruction, Multiple Data) instructions available on CPUs and GPUs, greatly enhancing performance.
-* Tiling. Divides computations into smaller blocks (tiles) optimized for cache efficiency, thus improving memory locality and reducing overhead due to memory transfers.
+  * Parallelism: Executes computations concurrently across multiple CPU cores, significantly reducing execution time for large datasets.
+  * Vectorization: Enables simultaneous processing of multiple data elements using SIMD (Single Instruction, Multiple Data) instructions available on CPUs and GPUs, greatly enhancing performance.
+  * Tiling: Divides computations into smaller blocks (tiles) optimized for cache efficiency, thus improving memory locality and reducing overhead due to memory transfers.
 
 By combining these scheduling techniques, developers can achieve optimal performance tailored specifically to their target hardware architecture.
 
@@ -58,16 +58,16 @@ Halide can be set up using one of two main approaches:
 * Installing pre-built binaries - pre-built binaries are convenient, quick to install, and suitable for most beginners or standard platforms (Windows, Linux, macOS). This approach is recommended for typical use cases.
 * Building Halide from source is required when pre-built binaries are unavailable for your specific environment, or if you wish to experiment with the latest Halide features or LLVM versions still under active development. This method typically requires greater familiarity with build systems and may be more suitable for advanced users.
 
-Here, we’ll use pre-built binaries:
-1. Visit the official Halide releases [page](https://github.com/halide/Halide/releases). As of this writing, the latest Halide version is v19.0.0.
-2. Download and unzip the binaries to a convenient location (e.g., /usr/local/halide on Linux/macOS or C:\halide on Windows).
-3. Optionally set environment variables to simplify further usage:
+Here, you will use pre-built binaries:
+  1. Visit the official Halide releases [page](https://github.com/halide/Halide/releases). As of this writing, the latest Halide version is v19.0.0.
+  2. Download and unzip the binaries to a convenient location (e.g., /usr/local/halide on Linux/macOS or C:\halide on Windows).
+  3. 3. Optionally set environment variables to simplify further usage:
 ```console
 export HALIDE_DIR=/path/to/halide
 export PATH=$HALIDE_DIR/bin:$PATH
 ```
 
-To proceed futher, let's make sure to install the following components:
+To proceed futher, make sure to install the following components:
 1. LLVM (Halide requires LLVM to compile and execute pipelines): 
 * Linux (Ubuntu):
 ```console
@@ -90,7 +90,7 @@ brew install opencv pkg-config
 Halide examples were tested with OpenCV 4.11.0
 
 ## Your first Halide program
-Now you’re ready to build your first Halide-based application. Save the following as hello-world.cpp:
+Now you’re ready to build your first Halide-based application. Save the following code in a file named `hello-world.cpp`:
 ```cpp
 #include "Halide.h"
 #include <opencv2/opencv.hpp>
@@ -154,7 +154,7 @@ int main() {
 }
 ```
 
-This program demonstrates how to combine Halide’s image processing capabilities with OpenCV’s image I/O and display functionality. It begins by loading an image from disk using OpenCV, specifically reading from a static file named img.png (here we use a Cameraman image). Since OpenCV loads images in BGR format by default, the code immediately converts the image to RGB format so that it is compatible with Halide’s expectations.
+This program demonstrates how to combine Halide’s image processing capabilities with OpenCV’s image I/O and display functionality. It begins by loading an image from disk using OpenCV, specifically reading from a static file named `img.png` (here you use a Cameraman image). Since OpenCV loads images in BGR format by default, the code immediately converts the image to RGB format so that it is compatible with Halide’s expectations.
 
 Once the image is loaded and converted, the program wraps the raw image data into a Halide buffer, capturing the image’s dimensions (width, height, and color channels). Next, the Halide pipeline is defined through a function named invert, which specifies the computations to perform on each pixel—in this case, subtracting the original pixel value from 255 to invert the colors. The pipeline definition alone does not perform any actual computation; it only describes what computations should occur and how to schedule them.
 
@@ -169,12 +169,11 @@ However, the optimal loop order depends on your intended memory layout and compa
 * Commonly used by libraries such as OpenCV.
 * To achieve this, the color channel (c) should be the innermost loop, followed by horizontal (x) and then vertical (y) loops
 
-Specifically, calling:
+Specifically, call:
 ```cpp
 invert.reorder(c, x, y);
 ```
-
-changes the loop nesting to process each pixel’s channels together (R, G, B for the first pixel, then R, G, B for the second pixel, and so on), resulting in:
+This changes the loop nesting to process each pixel’s channels together (R, G, B for the first pixel, then R, G, B for the second pixel, and so on), resulting in:
 * Better memory locality and cache performance when interfacing with interleaved libraries like OpenCV.
 * Reduced overhead for subsequent image-handling operations (display, saving, or further processing).
 
@@ -191,7 +190,7 @@ Buffer<uint8_t> inputBuffer = Buffer<uint8_t>::make_interleaved(
 * Preferred by certain image-processing routines or hardware accelerators (e.g., some GPU kernels or certain ML frameworks).
 * Achieved naturally by Halide’s default loop ordering (x, y, c).
 
-Thus, it is essential to select loop ordering based on your specific data format requirements and integration scenario. Halide provides full flexibility, allowing you to explicitly reorder loops to match the desired memory layout efficiently.
+It is essential to select loop ordering based on your specific data format requirements and integration scenario. Halide provides full flexibility, allowing you to explicitly reorder loops to match the desired memory layout efficiently.
 
 In Halide, two distinct concepts must be distinguished clearly:
 1. Loop execution order (controlled by reorder). Defines the nesting order of loops during computation. For example, to make the channel dimension (c) innermost during computation:
@@ -232,9 +231,9 @@ You will see two windows displaying the original and inverted images:
 ![img2](Figures/02.png)
 
 ## Summary
-In this lesson, you’ve learned Halide’s foundational concepts, explored the benefits of separating algorithms and schedules, set up your development environment, and created your first functional Halide application integrated with OpenCV. 
+In this section, you have learned Halide’s foundational concepts, explored the benefits of separating algorithms and schedules, set up your development environment, and created your first functional Halide application integrated with OpenCV. 
 
 While the example introduces the core concepts of Halide pipelines (such as defining computations symbolically and realizing them), it does not yet showcase the substantial benefits of explicitly separating algorithm definition from scheduling strategies.
 
-In subsequent lessons, you’ll explore advanced Halide scheduling techniques, including parallelism, vectorization, tiling, and loop fusion, which will clearly demonstrate the practical advantages of separating algorithm logic from scheduling. These techniques enable fine-grained performance optimization tailored to specific hardware without modifying algorithmic correctness.
+In subsequent sections, you will explore advanced Halide scheduling techniques, including parallelism, vectorization, tiling, and loop fusion, which will clearly demonstrate the practical advantages of separating algorithm logic from scheduling. These techniques enable fine-grained performance optimization tailored to specific hardware without modifying algorithmic correctness.