DEV Community: Pavan Kumar Sadashiv

Prompting on a MacBook Air, Executing on Windows: Building a Remote MCP Infrastructure for Cadence Allegro X

Pavan Kumar Sadashiv — Sun, 01 Nov 2026 05:34:01 +0000

Prompting on a MacBook Air, Executing on Windows: Building a Remote MCP Infrastructure for Cadence Allegro X

When building complex multi-layer PCBs, heavy hardware design suites like Cadence Allegro X present a massive resource hurdle. The official platform guidelines call for a minimum of 50 GB of free disk space and up to 64 GB of RAM for intense routing jobs.

If your daily driver is a compact setup—like a MacBook Air M2 with a tight 256 GB drive—local virtualization (e.g., via Parallels Desktop) isn't practical. Splitting your 16 GB of RAM causes both macOS and the guest Windows instance to choke, and the 120+ GB virtual storage allocation leaves your local SSD running near maximum capacity.

To solve this, you can decouple your orchestration layer from your execution layer. By running a remote AI agent setup using the Model Context Protocol (MCP) and Google Antigravity, you can use a MacBook Air for context prompting while running the physical workloads on an external high-spec Windows machine (like an Infinix GT Book with a Core i9, 32 GB RAM, and a discrete RTX GPU).

Here is how to set up a cross-platform, network-isolated engineering pipeline that moves desktop automation across operating systems.

The Architecture Topology

Instead of launching local child processes over standard input/output (stdio), this distributed pattern relies on a Remote HTTP server configuration using Server-Sent Events (SSE). The MacBook Air serves as the human-in-the-loop validation client, and the Windows machine operates as the dedicated execution worker node.

+───────────────────────────────+               +───────────────────────────────────+
│   MacBook Air M2 (Client)     │               │    Windows Workstation (Node)     │
├───────────────────────────────┤               ├───────────────────────────────────┤
│  [Google Antigravity CLI]     │  Remote HTTP  │   [winremote-mcp Server]          │
│              │                │  (SSE/JSON)   │                 │                 │
│              ▼                ├──────────────►│                 ▼                 │
│  Sends Natural Language Prompts│               │   Executes Shell Commands         │
│  "Route this PCB layout..."   │               │   Controls Cadence Allegro X CLI  │
+───────────────────────────────+               +───────────────────────────────────+

Step-by-Step Implementation Guide

1. Prepare the Windows Worker Node

First, configure the automation target environment to receive structured JSON-RPC calls from the orchestration layer.

Open a PowerShell terminal on the Windows machine and install the remote coordination bridge:

pip install winremote-mcp

Next, boot the server and bind it to your local network interface. Make sure to note your local IPv4 address (e.g., 192.168.1.50):

winremote-mcp --host 0.0.0.0 --port 8090

2. Bind the Client Layer on macOS

With the worker node listening, link the Google Antigravity runtime or active IDE context to the remote endpoint.

Locate your agent ecosystem definition layout (typically mcp-config.json or agent.json) on your MacBook Air and register the external server block:

{
  "mcpServers": {
    "infinix-windows-worker": {
      "url": "http://192.168.1.50:8090/sse",
      "type": "remote"
    }
  }
}

Prompt Execution Mechanics

Once connected, your hardware workflow transitions into automated prompt loops:

Context Submission: Submit a structural design prompt (e.g., "Import the footprints from library X and run the automated placement script on layer 3") directly into the Antigravity prompt interface on the Mac.
Step Calculation: The reasoning engine parses the design request and translates it into a deterministic order of operations.
Network Delegation: Antigravity routes these instructions as standardized tool-call payloads across the local network via HTTP SSE.
Native Execution: The Windows handler receives the JSON payloads, maps them to local shell tools or Cadence CLI executables, and utilizes the system's Core i9 and RTX GPU pipelines to run the tasks.

Critical Production Realities

Directory Mapping: When writing prompt paths, ensure you reference files using Windows directory layouts (e.g., C:\Cadence\Projects\...) rather than standard macOS POSIX routes.
Network Isolation: Basic remote MCP utilities typically lack robust built-in authentication out of the box. Keep this entire setup isolated behind a trusted local router or encrypted VPN link to eliminate Remote Code Execution risks.

Kali Linux on Apple Silicon

Pavan Kumar Sadashiv — Sat, 31 Oct 2026 21:57:14 +0000

Kali Linux on Apple Silicon (M2 MacBook Air) — Complete VM Setup Guide

This guide provides a step-by-step walkthrough for configuring and running Kali Linux as an ARM64 virtual machine on an M2 MacBook Air (16 GB Unified Memory, 256 GB SSD).

1. Storage & Resource Sizing (256 GB SSD Strategy)

Because a 256 GB internal drive has limited headroom alongside macOS system data and caching, disk allocation must balance functionality with host drive health:

Resource	Recommended Value	Notes
Virtual Disk Size	30 GB to 40 GB	Set to Dynamic / Thin Provisioning (only consumes actual space used, initially ~10–12 GB).
Installer / Download	3 GB to 4 GB	Can be deleted immediately after installation is complete.
RAM Allocation	4 GB to 6 GB	Leaves 10–12 GB for macOS Sonoma/Sequoia; perfect for smooth multi-tasking.
CPU Cores	4 vCPUs	M2 has 4 performance + 4 efficiency cores; 4 vCPUs provides near-native responsiveness.

Storage Warning: Do not pre-allocate fixed disk space. Always ensure sparse / dynamic disk allocation is checked so your VM grows only as tools and packages are installed.

2. Choosing the Hypervisor: UTM vs. VMware Fusion

For Apple Silicon (ARM64), UTM is the recommended open-source hypervisor:

Uses Apple's native Hypervisor virtualization framework.
Officially supported with ready-to-run Kali ARM64 images.
Zero license fees, active community, and native SPICE tools for copy/paste and dynamic resolution.

Alternative: VMware Fusion Pro (now free for personal use) is also viable, but UTM provides the smoothest out-of-the-box experience with Kali's pre-packaged ARM64 builds.

3. Installation: Method A (Pre-Built UTM Image — Recommended)

Offensive Security provides officially tuned UTM images for Apple Silicon. This avoids manual installer partitioning and driver quirks.

Step 1: Download Prerequisites

Download and install UTM from mac.getutm.app (free download from the website).
Go to kali.org/get-kali/#kali-virtual-machines.
Select the Apple Silicon (ARM64) tab.
Download the UTM package (a .7z archive, ~2.5–3.5 GB).

Step 2: Extract and Import

Install an unarchiver that handles 7z (e.g., Keka or via terminal: brew install p7zip).
Extract the downloaded archive:

   7z x kali-linux-*-utm-arm64.7z

You will get a .utm package (e.g., kali-linux-202x.x-utm.utm).
Double-click the .utm file or open UTM, click Open VM, and select the extracted .utm package.

Step 3: Default Credentials & First Boot

In the UTM sidebar, select the Kali VM and click the Play button.
Default login credentials:
- Username: kali
- Password: kali

4. Installation: Method B (Fresh ISO Installer — Custom Control)

If you prefer full control over disk partitions and tool metapackages:

Step 1: Download Kali ARM64 Installer

Visit kali.org/get-kali/#kali-installer-images.
Select Apple Silicon (ARM64).
Download the Installer ISO image (kali-linux-*-installer-arm64.iso).

Step 2: Create VM in UTM

Open UTM and click + (Create a New Virtual Machine).
Select Virtualize (do not select Emulate; virtualization runs at native M2 speed).
Select Linux.
Check Use Apple Virtualization (or standard QEMU; standard QEMU provides better snapshot support).
Under Boot ISO Image, browse and choose the downloaded Kali ARM64 ISO.
Configure Hardware:
- Memory: 4096 MB (4 GB) or 6144 MB (6 GB).
- CPU Cores: 4.
Configure Storage:
- Size: 35 GB (leave dynamic allocation enabled).
Leave Shared Directory as default for now, review settings, and click Save.

Step 3: Run the Installation

Start the VM. Choose Graphical Install at the boot menu.
Set Language, Region, and Keymap.
Configure hostname (kali) and user account credentials.
Partitioning: Choose Guided - use entire disk -> All files in one partition.
Software Selection:
- Keep default desktop environment: Xfce (lightweight, minimal RAM).
- Select default top 10 tools. Avoid selecting everything or large on a 256 GB drive.
Complete the installation and reboot. Remove the ISO from the CD/DVD drive in UTM settings under Drives.

5. Post-Installation Configuration

1. Update Repositories & Packages

Open a terminal inside Kali:

sudo apt update && sudo apt upgrade -y

2. Enable Clipboard Sharing & Auto-Resolution (SPICE Agent)

If using QEMU backend in UTM, ensure the SPICE guest tools are active:

sudo apt install -y spice-vdagent spice-webdavd
sudo systemctl enable --now spice-vdagent

Verification: Resize the UTM window on your Mac. The Kali desktop should automatically adjust resolution to match.

3. Change Default Passwords

Protect your instance:

passwd

6. Keeping Disk Usage Lean on a 256 GB Mac

With a 256 GB SSD, saving storage is essential:

Clean Package Cache regularly:

   sudo apt clean
   sudo apt autoremove --purge -y

Install Only What You Need: Instead of installing the bloated kali-linux-everything (which takes >30 GB), install specific tool suites on demand:
- Web testing: sudo apt install -y kali-tools-web
- Wireless auditing: sudo apt install -y kali-tools-wireless
- Reverse engineering: sudo apt install -y kali-tools-reverse-engineering
Delete ISO / Archive Files from macOS: Delete the .iso or .7z file in ~/Downloads after installation to instantly reclaim ~3.5 GB.
UTM Disk Reclaim: When files are deleted inside Kali, run sudo fstrim -av to inform the hypervisor to trim unused blocks.

7. Troubleshooting Common Apple Silicon Issues

Problem	Root Cause	Solution
Black screen on boot	Display backend mismatch	In UTM settings -> Display -> Change Emulated Display Card to `virtio-gpu-pci` or `virtio-ramfb`.
No Internet in VM	Network adapter mode	In VM settings -> Network -> Ensure Mode is set to Shared (NAT).
Cursor stutter or desync	Missing tablet input	In VM settings -> Input -> Set mouse to USB Tablet or install `spice-vdagent`.
Shared Folder not mounting	WebDAV service inactive	Run `davfs2` or use UTM's built-in VirtFS mount: `sudo mount -t 9p -o trans=virtio share /mnt/shared`.

OpenGalvoCal

Pavan Kumar Sadashiv — Sat, 31 Oct 2026 04:20:16 +0000

OpenGalvoCal: Next-Generation F-Theta Lens & Galvo Distortion Calibration System

Complete Problem Analysis, Mathematical Foundations, and Modern Software Architecture Specification

1. Executive Summary & Project Vision

1.1 The Mission

Galvanometer-based ("galvo") laser systems (Fiber, CO2, UV, and MOPA) are the backbone of modern industrial marking, precision micro-machining, and artisan engraving. Despite rapid advancements in laser sources and controller hardware, the software ecosystem for optical calibration remains mired in decades-old legacy tools. The standard industry utility—EzCad's bundled CorFile / CorFile2 utility—is a fragile, closed-source, 32-bit Windows application plagued by driver conflicts, geometric bugs, proprietary binary formats, and primitive 9-point manual measurement workflows.

OpenGalvoCal is conceived as a modern, cross-platform, open-source calibration suite and software engine designed to eliminate F-theta lens distortion, galvo mirror non-linearities, and mechanical assembly misalignments. By pairing robust mathematical modeling (Thin-Plate Splines, 5th-order bivariate polynomials, and decoupled affine transforms) with automated computer vision (CV) capture via flatbed scanners or smartphone cameras, OpenGalvoCal democratizes sub-50-micron marking accuracy across any field size (from 70×70 mm up to 300×300 mm and beyond).

1.2 Core Objectives

Platform Independence: Native support for Windows, macOS, and Linux via a modern Rust/Tauri desktop interface and a headless CLI.
Driver Coexistence: Zero conflict with modern laser control suites (e.g., LightBurn, EzCad, LinuxCNC) by utilizing non-invasive capture methods and native LibUSB/WinUSB communication without driver replacement.
Automated Computer Vision (CV): Replace error-prone manual caliper measurements with high-precision optical scanning (sub-pixel corner detection of 81- to 225-point dot/checkerboard matrices).
Universal Interoperability: Direct export to JCZ binary .cor/.cor2 files, LightBurn .lbgalvo configurations, LinuxCNC kinematics tables, and an open JSON/YAML calibration schema.
Mathematical Correctness: True decoupling of galvo skew, mirror orthogonality, trapezoidal tilt, barrel/pincushion distortion, and galvo scale factor.

2. Root Cause Analysis: The Physics & Geometry of Galvo Distortion

To build software that corrects optical distortion, we must first model every physical mechanism contributing to beam positioning errors in a galvanometer optical scanner.

                  +-----------------------------------+
                  |         Laser Source              |
                  +-----------------+-----------------+
                                    | Beam
                                    v
                            +---------------+
                            | Galvo Mirror X| (Theta_X)
                            +-------+-------+
                                    |
                                    v
                            +---------------+
                            | Galvo Mirror Y| (Theta_Y)
                            +-------+-------+
                                    |
                                    v
                         +---------------------+
                         |   F-Theta Objective |
                         +----------+----------+
                                    |
            +-----------------------+-----------------------+
            |                       |                       |
      Flat Planar Field      Ideal Flat Beam       Distorted Field
     (Without Correction)  (True F-Theta Lens)    (Real-World Errors)
            |                       |                       |
   - Tangent Distortion    - Focal Length f       - Pincushion / Barrel
   - Spherical Defocus     - y = f * theta        - Trapezoid / Skew
   - Field Curvature       - Uniform Spot Size    - Non-linear Edge Bowing

2.1 Optical & Kinematic Error Sources

1. Tangent Distortion (Pre-Objective / Post-Objective Geometry)

In a simple scanning system without an F-theta lens, an angular deflection $ heta$ creates a linear displacement on a flat surface proportional to the tangent of the deflection angle:
$$y = f \cdot an( heta)$$
Because $ an( heta) > heta$ for $ heta > 0$, beam velocity accelerates away from the optical center, resulting in massive pincushion distortion and non-uniform laser fluence.

2. F-Theta Lens Deviations ($y = f \cdot heta$)

An F-theta objective is specifically engineered to introduce an optical barrel distortion that cancels out the natural tangent distortion:
$$y = f \cdot heta$$
However, real-world multi-element F-theta lenses (especially budget 1064 nm fiber or 355 nm UV lenses) deviate from the theoretical linear relationship. Residual aberrations include:

Higher-order spherical aberrations: Causing non-linear edge bowing (the characteristic "banana shape" reported by users on 200 mm and 300 mm lenses).
Field curvature (Petzval curvature): Spot focal plane curves away from the flat marking surface, causing focal waist expansion and line thickening at corners.
Chromatic & thermal drift: Laser power absorption in the optical elements induces thermal lensing, shifting effective focal length during long jobs.

3. Mirror Separation & Parallax (Off-Axis Mirror Geometry)

Galvo mirrors $X$ and $Y$ are physically separated along the optical axis by a distance $d_{sep}$ (typically 7 to 15 mm). Because Mirror $X$ is further from the lens entrance pupil than Mirror $Y$:

The effective focal distance and scan angles differ between the X and Y axes.
Deflection along the Y axis shifts the point of incidence on the X mirror, introducing coupled cross-axis distortion ($X$ position depends non-linearly on $Y$ position).

4. Mechanical & Galvanometer Assembly Errors

Orthogonality Skew: The rotation axes of mirrors X and Y may not be perfectly $90.00^\circ$ perpendicular. Even a $0.2^\circ$ mechanical misalignment produces a diamond-shaped parallelogram skew across a 200×200 mm field.
Planar Tilt / Non-perpendicular Focal Axis: If the galvo scanhead is tilted relative to the work bed, the field projects as a keystone / trapezoid (one side wider than the opposing side).
Galvo Motor Non-Linearity & DAC Quantization: Galvo rotary position sensors (capacitive or optical encoders) and their analog driver boards possess small non-linearities, temperature drift, and DAC quantization steps across the 16-bit range ($-32768$ to $+32767$).

3. Comprehensive Breakdown of Legacy EzCad `CorFile` Failures

A critical review of the real-world experiences from hundreds of active machine operators reveals catastrophic flaws in the existing CorFile architecture:

Problem Domain	Legacy EzCad / CorFile Failure Mode	User Impact & Community Complaints
Driver Lock-in & Conflicts	Requires exclusive proprietary JCZ LMC drivers. Incompatible with WinUSB / LibUSB used by modern platforms (LightBurn).	When users switch to LightBurn, running CorFile triggers `"Failed to open lmc driver"` or hangs silently. Restoring requires deep driver uninstalls/reinstalls.
Platform Inflexibility	32-bit legacy Windows binary compiled in the 2000s. Relies on deprecated MFC libraries.	Completely unusable on macOS or Linux without unstable virtual machines with pass-through USB latency.
Coordinate Flips & Mirroring	Inverting galvos or swapping Galvo 1 / Galvo 2 in Ezcad parameters conflicts with how `.cor` stores coordinate orientation.	Post-calibration marks are frequently inverted $180^\circ$, mirrored, or rotated $90^\circ$ (`@GuyMouton`, `@billsouth2660`, `@MakerPlates`). Parameter UI locks out manual changes.
Sparse Sampling (9-Point Grid)	Only marks a $3 imes 3$ grid (center point + 4 edges + 4 corners).	Completely insufficient for higher-order polynomial aberrations on lenses $\ge 150 ext{ mm}$. Concentric squares bow dramatically between calibration points (`@otis_d`, `@milandestroyer6471`).
Mathematical Blind Spots	Assumes edge points (Points 2, 4, 6, 8) lie strictly on Cartesian axes ($X=0$ or $Y=0$).	Cannot decouple or mathematically compute angular skew or parallelogram distortion from pure edge distance measurements (`@imajeenyus42`).
Human Measurement Error	Requires measuring 9 distances with handheld digital calipers to $0.01 ext{ mm}$ precision across black tape or scrap metal.	Zero-drift on calipers, parallax error, line thickness ambiguity, and manual data-entry typos ruin the calibration, requiring multi-hour retry loops.
Black-Box Proprietary Format	Saves an encrypted/opaque binary `.cor` or `.cor2` file with no human-readable inspection.	Users cannot manually tweak scale or inspect distortion metrics (`@Chanvgap`). Corrupts field size when switching between metric and imperial units.
Security & Packaging	Packed with outdated packers; flags false-positives in enterprise antivirus suites.	McAfee / Windows Defender regularly quarantines or deletes `CorFile.exe` directly from the install directory (`@MarshallCNC`).
Abandonment in EzCad 3	EzCad 3 removed `CorFile.exe` entirely in favor of an untranslated, undocumented internal wizard.	Operators upgrading to newer controllers are left stranded with no viable distortion calibration path.

4. Mathematical Architecture for Modern Calibration

OpenGalvoCal implements a dual-layer calibration model:

Parametric Global Affine Transform: Resolves coordinate system alignment, scaling, offset, and mechanical orthogonality skew.
Non-Parametric / High-Order Optical Transform: Models and eliminates non-linear lens aberrations across the full 2D field.

[Target Coordinate (x, y)] 
          |
          v
+-----------------------------+
| Layer 1: Affine Alignment   | --> Corrects Offset, Scale (X/Y),
| (Scale, Skew, Rotation)     |     Rotation, and Mirror Orthogonality
+--------------+--------------+
               |
               v
+-----------------------------+
| Layer 2: Optical Correction | --> Corrects Keystone/Trapezoid,
| (Polynomial / Thin-Plate)   |     Barrel/Pincushion, and Edge Bowing
+--------------+--------------+
               |
               v
[Galvo DAC Output (Vx, Vy)]

4.1 Layer 1: Decoupled Affine Normalization

Let $(u, v) \in [-1, 1]^2$ represent normalized commanded galvo coordinates, and $(x, y) \in \mathbb{R}^2$ represent measured physical coordinates in millimeters.

The linear transformation accounts for:

Offset: $(x_0, y_0)$
Linear scaling factors: $S_x, S_y$ (pulses/mm or DAC units/mm)
Grid rotation: $ heta$
Galvo axis orthogonality skew: $\psi$

$$egin{bmatrix} x_{aff} \ y_{aff} \end{bmatrix} =
egin{bmatrix} S_x & 0 \ 0 & S_y \end{bmatrix}
egin{bmatrix} \cos heta & -\sin( heta + \psi) \ \sin heta & \cos( heta + \psi) \end{bmatrix}
egin{bmatrix} u \ v \end{bmatrix} + egin{bmatrix} x_0 \ y_0 \end{bmatrix}$$

Decoupling orthogonality $\psi$ from rotation $ heta$ is essential: rotation is simply the orientation of the workpiece or head mount, whereas skew $\psi$ represents physical non-perpendicularity of the galvanometer mirror axes.

4.2 Layer 2: Non-Linear Distortion Modeling

Option A: Bivariate 5th-Order Polynomial Surface

For lenses with standard radial and tangential distortions, the residual displacement $(\Delta x, \Delta y)$ is modeled as a 5th-order complete polynomial:

$$\Delta x(u, v) = \sum_{i=0}^{5} \sum_{j=0}^{5-i} a_{i,j} \, u^i v^j$$
$$\Delta y(u, v) = \sum_{i=0}^{5} \sum_{j=0}^{5-i} b_{i,j} \, u^i v^j$$

$i+j = 1$: Linear scaling and skew terms (redundant with Layer 1, held orthogonal).
$i+j = 2$: Trapezoidal / keystone distortion ($u^2, uv, v^2$), caused by focal plane tilt.
$i+j = 3$: Primary barrel / pincushion distortion ($u(u^2+v^2), v(u^2+v^2)$).
$i+j = 4, 5$: Higher-order peripheral bowing (critical for large $200 ext{ mm}$ and $300 ext{ mm}$ field lenses).

Option B: Thin-Plate Spline (TPS) Interpolation

For irregular or complex lens aberrations where polynomial fitting suffers from Runge’s phenomenon at the field boundaries, OpenGalvoCal applies 2D Thin-Plate Splines (TPS). Given $N$ measured calibration control points $(u_k, v_k) o (x_k, y_k)$:

$$f(u, v) = \mathbf{a}0 + a_x u + a_y v + \sum{k=1}^N w_k \, U\left(\left| (u, v) - (u_k, v_k)
ight|
ight)$$

where the radial basis kernel is $U(r) = r^2 \ln(r)$, minimizing the physical bending energy:
$$E_{bend} = \iint_{\mathbb{R}^2} \left( \left(rac{\partial^2 f}{\partial u^2}
ight)^2 + 2\left(rac{\partial^2 f}{\partial u \partial v}
ight)^2 + \left(rac{\partial^2 f}{\partial v^2}
ight)^2
ight) du \, dv$$

TPS provides perfectly smooth, infinitely differentiable $C^1$ velocity profiles across the entire scanning field, preventing galvo mirror acceleration spikes and chatter.

5. Automated Computer Vision (CV) Pipeline

Manual caliper measurement is the single largest point of human failure in laser calibration. OpenGalvoCal introduces an automated optical calibration pipeline.

+--------------------------------------------------------------------------+
|                       Automated Vision Pipeline                          |
+--------------------------------------------------------------------------+
|                                                                          |
|  1. Generate Target Vector Grid                                          |
|     - Mark dense grid (81 points: 9x9, or 225 points: 15x15)             |
|     - High-contrast fiducial marks (ChArUco / Ring-Dot array)            |
|                                                                          |
|  2. Image Acquisition                                                    |
|     - Mode A: Flatbed Scanner (Zero perspective distortion, 1200+ DPI)   |
|     - Mode B: Smartphone / DSLR Camera (Corrected via ChArUco fiducials) |
|                                                                          |
|  3. Sub-Pixel Feature Detection                                          |
|     - OpenCV Hough circles / Saddle-point corner detection               |
|     - Centroid precision < 0.05 pixels (~5 to 10 microns)                |
|                                                                          |
|  4. Coordinate Registration & Homography                                 |
|     - Perspective de-warping via known planar fiducials                  |
|     - Global coordinate frame normalization                              |
|                                                                          |
|  5. Residual Error Vector Generation                                     |
|     - Map nominal (commanded) coordinates to observed coordinates        |
|     - Generate interactive error heatmap & vector displacement map       |
|                                                                          |
+--------------------------------------------------------------------------+

5.1 Flatbed Document Scanner Workflow (Gold Standard)

The operator marks a standardized grid on a flat sheet of black anodized aluminum, black cardstock, or thermally sensitive paper.
The card is placed on any standard commercial flatbed document scanner (e.g., Canon, Epson) at 600 or 1200 DPI.
Because flatbed scanners use a linear optical array moved by a precision lead screw, they possess zero perspective distortion and exceptional dimensional linearity.
The software automatically detects the target corners, calculates exact micron displacements for all grid points, and generates the correction matrix in under 5 seconds.

5.2 Smartphone / Camera Assisted Workflow (Zero Extra Hardware)

The marked calibration sheet incorporates four corner ArUco / AprilTag fiducial markers with known physical dimensions.
The user snaps a photo with any modern smartphone.
OpenGalvoCal applies perspective homography inversion to eliminate camera perspective tilt, rectifies camera radial lens distortion using tag geometry, and extracts the inner laser-marked dot array.

6. Software Architecture & Implementation Specification

6.1 Technology Stack Selection

Core Engine & Kinematics: Rust
- Ultra-high numerical performance, zero garbage collection pauses.
- Type-safe mathematical operations using nalgebra.
- Memory-safe binary serialization for legacy file formats.
Frontend / GUI Layer: Tauri + Svelte 5 + WebGL
- Lightweight (<15 MB binary footprint vs. >150 MB for Electron).
- Native OS rendering with zero web-engine bloat.
- Interactive 2D/3D WebGL distortion vector mesh visualization.
Computer Vision Module: C++ / Rust (via opencv bindings)
- Sub-pixel corner detection (cornerSubPix), ellipse fitting, and adaptive thresholding.
Direct Hardware Driver Interface: rusb (LibUSB)
- Direct communication with JCZ LMCV4 / DLC boards without altering system drivers or breaking LightBurn.

+--------------------------------------------------------------------------+
|                       OpenGalvoCal Architecture                          |
+--------------------------------------------------------------------------+
|                                                                          |
|   [ User Interface Layer: Tauri + Svelte + WebGL ]                       |
|   - Interactive Wizard   - 2D/3D Error Heatmap   - Caliper Fallback UI   |
|                                                                          |
+------------------------------------+-------------------------------------+
                                     | IPC / Bridge
                                     v
+--------------------------------------------------------------------------+
|   [ Rust Core Engine ]                                                   |
|   +-----------------------+ +-----------------------+ +----------------+ |
|   | Vision & Detection    | | Math & Solver Engine  | | File Exporters | |
|   | - ChArUco / Grid CV   | | - Affine Decomposition| | - .cor / .cor2 | |
|   | - Sub-pixel Centroids | | - 5th-Order Poly Fit  | | - .lbgalvo     | |
|   | - Scanner Rectifier   | | - Thin-Plate Spline   | | - JSON / YAML  | |
|   +-----------------------+ +-----------------------+ +----------------+ |
|                                                                          |
|   +------------------------------------------------------------------+   |
|   | Hardware Communication Layer (Optional Direct Connection)         |   |
|   | - LibUSB / WinUSB abstraction                                     |   |
|   | - JCZ LMC / DLC controller protocol parser                       |   |
|   +------------------------------------------------------------------+   |
+--------------------------------------------------------------------------+

6.2 Universal Open Calibration Schema (`galvocal.json`)

Unlike the closed binary .cor format, OpenGalvoCal establishes an open, human-readable JSON schema that fully documents the optical state:

{
  "$schema": "https://opengalvocal.org/schema/v1/calibration.json",
  "metadata": {
    "profileName": "Fiber_30W_175mm_Opex",
    "created": "2026-10-31T09:43:00Z",
    "softwareVersion": "1.0.0",
    "operatorNotes": "Calibrated via 1200 DPI flatbed scan on anodized aluminum"
  },
  "lensHardware": {
    "nominalFocalLengthMm": 254.0,
    "nominalFieldSizeMm": 175.0,
    "wavelengthNm": 1064,
    "mountThread": "M85x1"
  },
  "galvoConfig": {
    "axisOrientation": {
      "galvo1Axis": "X",
      "galvo2Axis": "Y",
      "invertGalvo1": false,
      "invertGalvo2": true,
      "swapXY": false
    },
    "dacResolutionBits": 16,
    "fieldLimitDac": 32767
  },
  "affineParameters": {
    "scaleFactorX": 1.00234,
    "scaleFactorY": 0.99812,
    "orthogonalitySkewDeg": 0.084,
    "rotationDeg": 0.12,
    "offsetMm": { "x": 0.15, "y": -0.08 }
  },
  "distortionModel": {
    "type": "ThinPlateSpline",
    "gridResolution": [9, 9],
    "measuredFieldSizeMm": 174.82,
    "maxResidualErrorMm": 0.018,
    "meanResidualErrorMm": 0.007,
    "controlPoints": [
      { "nominal": [-80.0, -80.0], "corrected": [-80.42, -80.38] },
      { "nominal": [0.0, -80.0], "corrected": [0.02, -80.12] },
      { "nominal": [80.0, -80.0], "corrected": [80.39, -80.41] }
    ]
  }
}

6.3 Reverse-Engineered JCZ `.cor` / `.cor2` Binary Compatibility

To guarantee backward compatibility with existing EzCad2, EzCad3, and LightBurn installations, OpenGalvoCal includes a complete binary packer/unpacker for JCZ correction files:

Format Anatomy:
- Header Magic: Specific byte markers identifying format revision (0x43 0x4F 0x52 / COR).
- Grid Specification: Sampling count (typically $33 imes 33$ or $65 imes 65$ interpolation matrix across full DAC range).
- Coordinate Interleaving: Paired IEEE-754 32-bit floats or signed 16-bit integers representing delta displacements: $$\Delta X(i, j) = X_{corrected}(i, j) - X_{ideal}(i, j)$$ $$\Delta Y(i, j) = Y_{corrected}(i, j) - Y_{ideal}(i, j)$$
- Galvo Flags: Inversion, swap, and orientation bits encoded into the header, preventing the famous "180° rotation / mirrored engraving" bug by synchronizing with user parameters.

7. Step-by-Step Modern User Workflow

[ Step 1: Laser Mark ] ---> [ Step 2: Optical Capture ] ---> [ Step 3: Solve & Review ] ---> [ Step 4: Export ]
  Generate & mark             Scan or photo of target         Automatic grid detection,       Direct export to
  high-contrast 9x9           using flatbed scanner or        residual error analysis,        .cor, .lbgalvo,
  fiducial test grid          smartphone camera               and 2D/3D distortion mesh       or open JSON

Step 1: Calibration Target Generation & Laser Marking

The user selects their nominal lens field size (e.g., 70, 110, 150, 175, 200, 300 mm) in OpenGalvoCal.
The software generates a test pattern:
- Dense Grid Mode (Vision): 81 fiducial dots with 4 unique ArUco alignment markers and a central reference crosshair.
- Assisted Caliper Mode (Manual Fallback): 9 numbered reference circles with crosshair centers, optimized for caliper jaws.
The pattern is marked using the user's current software (EzCad or LightBurn) as a 1:1 uncorrected job on scrap material (black cardstock, black masking tape, or anodized aluminum).

Step 2: High-Speed Automated Capture

Method A (Scanner): Place marked card on a flatbed scanner. Click "Scan & Detect".
Method B (Camera): Hold phone over target. The software automatically identifies corners, corrects perspective tilt, and extracts dot centers.
Method C (Guided Caliper Entry): If manual calipers are used, OpenGalvoCal guides the operator step-by-step with high-contrast diagrams, caliper zero-drift verification alerts, and real-time sanity checking (flagging typos and geometric contradictions).

Step 3: Analysis & Live Interactive Verification

OpenGalvoCal calculates the affine transformation and residual distortion field.
A Visual Distortion Heatmap displays:
- Total barrel/pincushion magnitude.
- Skew angle in degrees.
- Maximum dimensional deviation (e.g., +1.84 mm at corner (X: 87.5, Y: 87.5)).
The user can inspect the simulated before/after square and circle geometry in real time.

Step 4: One-Click Export

The user clicks "Apply Calibration":

For LightBurn: Saves an updated .lbgalvo profile or imports directly into LightBurn device settings.
For EzCad2 / EzCad3: Exports a clean, valid .cor / .cor2 file with correct axis inversions already configured.
For Custom / Industrial: Saves standard JSON/CSV lookup tables.

8. Specific Solutions to Community Failure Modes

Community Issue / Pain Point	Root Cause in Legacy Tools	OpenGalvoCal Modern Solution
Marked Image Upside-Down / 90° Rotated	EzCad applies `.cor` files using a fixed coordinate convention, ignoring user parameter invert flags (`@billsouth2660`, `@MakerPlates`).	The software includes an interactive Orientation Preview. Users confirm visual orientation (top-left marker alignment) before saving; Galvo 1/Galvo 2 and Invert bits are baked consistently into the file.
"Failed to open lmc driver"	EzCad `CorFile` cannot communicate over WinUSB drivers installed for LightBurn (`@rssacnavy`, `@JulietTangoCustoms`).	OpenGalvoCal decouples marking from calibration. Marking is done via standard export files (.dxf, .svg, .lbgalvo), requiring zero driver swaps. Optional direct control uses standard multi-OS LibUSB.
Distortion Persists on Large Lenses (200/300mm)	A 9-point grid is too sparse to capture 4th/5th order peripheral lens curve deviations (`@otis_d`, `@milandestroyer6471`).	Supports up to 225 calibration points (15×15 matrix) using automated vision, accurately capturing high-order non-linear edge bow.
Skew / Parallelogram Not Corrected	Legacy caliper method measures radial edge distances assuming points lie on axes, mathematically incapable of resolving shear angle (`@imajeenyus42`).	True 2D coordinate registration computes independent $X$ and $Y$ displacements for every point, allowing full decomposition of non-orthogonal shear ($\psi$).
Inches vs. Metric Scaling Bug	EzCad defaults to metric units internally; entering inches causes scaling to explode (`@kapple5290`, `@camiscioni08`).	Strict internal unit normalization to SI standard millimeters ($1 ext{ in} = 25.400 ext{ mm}$), regardless of user display preference.
Caliper Jaw Damage & Measurement Noise	Calipers slip on paper or metal; zero shifts during multi-point measurement (`@lithgowlights859`).	Automatic flatbed scanning removes manual measurement entirely. For manual mode, automatic software prompts require re-zeroing calipers after every 3 measurements.

9. Implementation Roadmap & Project Deliverables

Phase 1: Mathematical Engine & Spec (Weeks 1 - 4)
├── Complete Rust solver (nalgebra, Thin-Plate Splines, 5th-order polynomial)
├── JCZ .cor / .cor2 binary parser and serializer
└── LightBurn .lbgalvo format generator

Phase 2: Computer Vision Core (Weeks 5 - 8)
├── Scanner image ingestion & automated DPI calculation
├── Sub-pixel corner and centroid extraction pipeline
└── Homography de-warping for mobile camera captures

Phase 3: Cross-Platform GUI (Weeks 9 - 12)
├── Tauri + Svelte desktop application
├── Interactive WebGL distortion mesh visualizer
├── Step-by-step calibration wizard (Scanner, Camera, Caliper modes)
└── Automated test suite and cross-validation against physical galvo systems

Phase 4: Open Community Launch & Ecosystem (Weeks 13+)
├── Open-source repository release (MIT / Apache 2.0)
├── Pre-compiled binaries for Windows, macOS (Universal), and Linux (.AppImage, .deb)
└── Public online lens profile repository for community-shared base calibrations

10. Conclusion

The widespread frustration documented across the laser engraving community highlights an urgent need for modern engineering in the optical calibration space. By replacing fragile 32-bit binaries, proprietary driver dependencies, and imprecise manual calipers with rigorous mathematical transforms, cross-platform architecture, and automated computer vision, OpenGalvoCal transforms a multi-hour, error-prone ordeal into a 60-second, sub-50-micron precision workflow.

Machine Learning From Scratch in Pure C: Module I — Supervised Learning & Foundations

Pavan Kumar Sadashiv — Sat, 31 Oct 2026 02:26:51 +0000

Machine Learning From Scratch in Pure C

Module I: Supervised Learning & Model Validation

When studying machine learning, Python and libraries like Scikit-Learn or PyTorch often hide the low-level mechanics under high-level abstractions. Implementing these foundational algorithms in pure ANSI C exposes the core mathematics: mean deviations, 2x2 matrix determinants, Euclidean spatial metrics, Laplace conditional distributions, and gradient descent updates.

Every program in this lab guide is self-contained, written in standard C (<stdio.h> and <math.h>), and designed with clean, step-by-step logic suitable for lab exams, technical viva voce, and fast handwritten code reproduction.

Module I Syllabus & Lab Mapping

Lab #	Topic / Algorithm	Type	Core Mathematical Concept
Lab 01	Simple Linear Regression	Supervised (Regression)	Ordinary Least Squares (OLS) & Mean Deviations
Lab 02	Multiple Linear Regression	Supervised (Regression)	Deviation Product System & 2x2 Closed-Form Determinants
Lab 03	K-Nearest Neighbors (KNN)	Supervised (Classification)	Instance-based Euclidean Distance & Majority Voting
Lab 04	Naïve Bayes Classifier	Supervised (Classification)	Conditional Independence, Prior Probabilities & Laplace Smoothing
Lab 05	Logistic Regression	Supervised (Classification)	Sigmoid Hypothesis & Batch Gradient Descent Optimization
Lab 06	Leave-One-Out CV (LOOCV)	Model Evaluation	Exhaustive Resampling & Mean Squared Error (MSE)

Lab 01: Simple Linear Regression (Ordinary Least Squares)

1. Problem Statement

Implement Simple Linear Regression using Ordinary Least Squares (OLS). Given a training set of input features $x$ and continuous target outcomes $y$, compute:

Feature and target sample means ($\bar{x}, \bar{y}$)
Regression slope ($b_1$) and y-intercept ($b_0$)
The fitted linear model $\hat{y} = b_0 + b_1x$
Output predictions for unseen query values.

2. Core Mathematical Formulation

Sample Means:
$$\bar{x} = \frac{1}{n}\sum_{i=1}^{n} x_i, \quad \bar{y} = \frac{1}{n}\sum_{i=1}^{n} y_i$$
Slope Coefficient ($b_1$):
$$b_1 = \frac{\sum_{i=1}^{n} (x_i - \bar{x})(y_i - \bar{y})}{\sum_{i=1}^{n} (x_i - \bar{x})^2}$$
Y-Intercept ($b_0$):
$$b_0 = \bar{y} - b_1\bar{x}$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 4, i;
    // Training dataset: Study hours (x) vs Exam marks (y)
    float x[] = {1.0, 2.0, 3.0, 4.0};
    float y[] = {2.0, 3.0, 5.0, 6.0};

    float sum_x = 0.0, sum_y = 0.0;
    float mx, my;
    float num = 0.0, den = 0.0;
    float b0, b1;
    float test_x = 5.0, pred_y;

    // Step 1: Calculate arithmetic means
    for (i = 0; i < n; i++) {
        sum_x += x[i];
        sum_y += y[i];
    }
    mx = sum_x / n;
    my = sum_y / n;

    // Step 2: Compute deviation products (num) and squared deviations (den)
    for (i = 0; i < n; i++) {
        num += (x[i] - mx) * (y[i] - my);
        den += (x[i] - mx) * (x[i] - mx);
    }

    // Step 3: Compute slope (b1) and intercept (b0)
    b1 = num / den;
    b0 = my - (b1 * mx);

    // Step 4: Make prediction for new observation
    pred_y = b0 + (b1 * test_x);

    printf("=== Lab 01: Simple Linear Regression ===\n");
    printf("Mean X = %.2f, Mean Y = %.2f\n", mx, my);
    printf("Slope (b1) = %.2f\n", b1);
    printf("Intercept (b0) = %.2f\n", b0);
    printf("Fitted Equation: y = %.2f + %.2fx\n", b0, b1);
    printf("Prediction for x = %.1f -> y = %.2f\n", test_x, pred_y);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Two-Pass Loop Strategy: The first loop computes the means (mx and my). The second loop calculates the centered deviations (x[i] - mx) and accumulates the covariance numerator and variance denominator.
Calculation Sequence: Always resolve b1 = num / den before computing b0 = my - b1 * mx, since $b_0$ explicitly depends on $b_1$.
Time & Space Complexity: Time Complexity is $\mathcal{O}(n)$, Space Complexity is $\mathcal{O}(1)$ auxiliary space.

5. Sample Execution Output

=== Lab 01: Simple Linear Regression ===
Mean X = 2.50, Mean Y = 4.00
Slope (b1) = 1.40
Intercept (b0) = 0.50
Fitted Equation: y = 0.50 + 1.40x
Prediction for x = 5.0 -> y = 7.50

Lab 02: Multiple Linear Regression (Two Features)

1. Problem Statement

Implement Multiple Linear Regression with two independent continuous predictor variables ($X_1, X_2$) and one dependent target variable ($Y$). Solve the linear equation:
$$\hat{Y} = b_0 + b_1X_1 + b_2X_2$$
using closed-form deviation products and 2x2 determinants.

2. Core Mathematical Formulation

Centering Variables (Mean Deviations):
$$x_1 = X_1 - \bar{X}_1, \quad x_2 = X_2 - \bar{X}_2, \quad y = Y - \bar{Y}$$
Coefficient Solution via System Determinants:
$$b_1 = \frac{(\sum x_1 y)(\sum x_2^2) - (\sum x_2 y)(\sum x_1 x_2)}{(\sum x_1^2)(\sum x_2^2) - (\sum x_1 x_2)^2}$$
$$b_2 = \frac{(\sum x_2 y)(\sum x_1^2) - (\sum x_1 y)(\sum x_1 x_2)}{(\sum x_1^2)(\sum x_2^2) - (\sum x_1 x_2)^2}$$
Model Intercept ($b_0$):
$$b_0 = \bar{Y} - b_1\bar{X}_1 - b_2\bar{X}_2$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 3, i;
    // Input features X1, X2 and Target Y
    float X1[] = {1.0, 2.0, 3.0};
    float X2[] = {1.0, 2.1, 2.9};
    float Y[]  = {3.0, 5.8, 9.2};

    float m1 = 0.0, m2 = 0.0, my = 0.0;
    float s11 = 0.0, s22 = 0.0, s12 = 0.0, s1y = 0.0, s2y = 0.0;
    float den, b0, b1, b2;
    float test_x1 = 4.0, test_x2 = 3.8, pred_y;

    // Step 1: Calculate feature and target sample means
    for (i = 0; i < n; i++) {
        m1 += X1[i];
        m2 += X2[i];
        my += Y[i];
    }
    m1 /= n; m2 /= n; my /= n;

    // Step 2: Accumulate centered sum-of-squares and cross-products
    for (i = 0; i < n; i++) {
        float x1 = X1[i] - m1;
        float x2 = X2[i] - m2;
        float y  = Y[i] - my;
        s11 += x1 * x1;
        s22 += x2 * x2;
        s12 += x1 * x2;
        s1y += x1 * y;
        s2y += x2 * y;
    }

    // Step 3: Compute determinant denominator and weights
    den = (s11 * s22) - (s12 * s12);
    b1  = ((s1y * s22) - (s2y * s12)) / den;
    b2  = ((s2y * s11) - (s1y * s12)) / den;
    b0  = my - (b1 * m1) - (b2 * m2);

    // Step 4: Output model and evaluate new data point
    pred_y = b0 + (b1 * test_x1) + (b2 * test_x2);

    printf("=== Lab 02: Multiple Linear Regression ===\n");
    printf("b0 (Intercept) = %.2f\n", b0);
    printf("b1 (Weight X1) = %.2f\n", b1);
    printf("b2 (Weight X2) = %.2f\n", b2);
    printf("Model Equation: Y = %.2f + (%.2f * X1) + (%.2f * X2)\n", b0, b1, b2);
    printf("Prediction for (%.1f, %.1f) = %.2f\n", test_x1, test_x2, pred_y);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

5 Deviation Accumulators: Remember s11 ($\sum x_1^2$), s22 ($\sum x_2^2$), s12 ($\sum x_1 x_2$), s1y ($\sum x_1 y$), and s2y ($\sum x_2 y$).
Cross Matching Rule: b1 pairs s1y with s22 minus s2y * s12. Conversely, b2 pairs s2y with s11 minus s1y * s12. Both share the exact same denominator den = s11*s22 - s12*s12.

5. Sample Execution Output

=== Lab 02: Multiple Linear Regression ===
b0 (Intercept) = 0.00
b1 (Weight X1) = 5.00
b2 (Weight X2) = -2.00
Model Equation: Y = 0.00 + (5.00 * X1) + (-2.00 * X2)
Prediction for (4.0, 3.8) = 12.40

Lab 03: K-Nearest Neighbors (KNN Classification)

1. Problem Statement

Implement the K-Nearest Neighbors (KNN) algorithm from scratch for binary classification. Given a query point $Q(q_1, q_2)$:

Calculate the Euclidean distance between $Q$ and all training vectors.
Sort the training instances in ascending order of proximity while maintaining label synchronicity.
Apply majority voting over the top $K$ nearest neighbors to classify $Q$.

2. Core Mathematical Formulation

Euclidean Distance Metric:
$$d(p, q) = \sqrt{(p_1 - q_1)^2 + (p_2 - q_2)^2}$$
Majority Voting Function:
$$\hat{Y} = \begin{cases} 1 & \text{if } \sum_{i=1}^{K} y_{(i)} > \frac{K}{2} \ 0 & \text{otherwise} \end{cases}$$

3. Pure C Implementation

#include <stdio.h>
#include <math.h>

int main() {
    int n = 6, k = 3, i, j;
    // 2D training coordinates and binary classes (0 or 1)
    float x1[] = {1.0, 1.5, 2.0, 5.0, 5.5, 6.0};
    float x2[] = {1.0, 2.0, 1.5, 5.0, 6.0, 5.5};
    int label[] = {0, 0, 0, 1, 1, 1};

    float d[6];
    float q1 = 2.0, q2 = 2.5; // Test query point
    int votes = 0;

    // Step 1: Compute Euclidean distance to all training instances
    for (i = 0; i < n; i++) {
        d[i] = sqrt(((x1[i] - q1) * (x1[i] - q1)) + ((x2[i] - q2) * (x2[i] - q2)));
    }

    // Step 2: Sort distances in ascending order while keeping labels synchronized
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (d[j] > d[j + 1]) {
                float temp_d = d[j];
                d[j] = d[j + 1];
                d[j + 1] = temp_d;

                int temp_l = label[j];
                label[j] = label[j + 1];
                label[j + 1] = temp_l;
            }
        }
    }

    // Step 3: Tabulate votes across the top K neighbors
    for (i = 0; i < k; i++) {
        votes += label[i];
    }
    int pred_class = (votes > (k / 2)) ? 1 : 0;

    printf("=== Lab 03: K-Nearest Neighbors (KNN) ===\n");
    printf("Query Point: (%.1f, %.1f), K = %d\n", q1, q2, k);
    printf("Top %d Nearest Distances: %.2f, %.2f, %.2f\n", k, d[0], d[1], d[2]);
    printf("Top %d Neighbor Labels: %d, %d, %d\n", k, label[0], label[1], label[2]);
    printf("Predicted Class Label: %d\n", pred_class);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Parallel Swap in Bubble Sort: Never swap d[j] alone. Swapping distances without simultaneously swapping label[j] destroys class mapping.
Odd $K$ Advantage: Choosing an odd value for $K$ ($K=3, 5$) avoids ties in two-class binary classification.

5. Sample Execution Output

=== Lab 03: K-Nearest Neighbors (KNN) ===
Query Point: (2.0, 2.5), K = 3
Top 3 Nearest Distances: 0.71, 0.71, 1.12
Top 3 Neighbor Labels: 0, 0, 0
Predicted Class Label: 0

Lab 04: Naïve Bayes Classifier (Laplace Smoothing)

1. Problem Statement

Implement a Naïve Bayes classifier with additive Laplace smoothing for discrete binary text features (e.g., spam email detection). Evaluate prior and likelihood probabilities to calculate class posterior scores for an incoming message.

2. Core Mathematical Formulation

Bayes' Theorem with Independence Assumption:
$$P(C \mid X) \propto P(C) \prod_{j=1}^{d} P(X_j \mid C)$$
Laplace Smoothing Operator ($k = 2$ for binary attributes):
$$P(X_j = v \mid C) = \frac{\text{count}(X_j = v \text{ and } C) + 1}{N_C + 2}$$
where $N_C$ is total occurrences of class $C$.

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 10, i;
    // Feature 1: Keyword "Free" present (1) or absent (0)
    int feat_free[]  = {0, 1, 1, 1, 1, 0, 0, 0, 0, 0};
    // Feature 2: Keyword "Offer" present (1) or absent (0)
    int feat_offer[] = {1, 1, 1, 1, 0, 0, 0, 0, 0, 0};
    // Ground Truth Target: Spam = 1, Ham/Not-Spam = 0
    int target[]     = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0};

    // Test sample: Contains "Offer" (1), but no "Free" (0)
    int test_free = 0, test_offer = 1;

    int n_spam = 0, n_ham = 0;
    int c_free_spam = 0, c_offer_spam = 0;
    int c_free_ham = 0, c_offer_ham = 0;

    // Step 1: Accumulate class totals and matching feature frequencies
    for (i = 0; i < n; i++) {
        if (target[i] == 1) {
            n_spam++;
            if (feat_free[i] == test_free)   c_free_spam++;
            if (feat_offer[i] == test_offer) c_offer_spam++;
        } else {
            n_ham++;
            if (feat_free[i] == test_free)   c_free_ham++;
            if (feat_offer[i] == test_offer) c_offer_ham++;
        }
    }

    // Step 2: Calculate Class Prior Probabilities
    float p_spam = (float)n_spam / n;
    float p_ham  = (float)n_ham / n;

    // Step 3: Compute Laplace-smoothed conditional likelihoods: (count + 1) / (N + 2)
    float l_free_spam  = (float)(c_free_spam + 1) / (n_spam + 2);
    float l_offer_spam = (float)(c_offer_spam + 1) / (n_spam + 2);
    float l_free_ham   = (float)(c_free_ham + 1) / (n_ham + 2);
    float l_offer_ham  = (float)(c_offer_ham + 1) / (n_ham + 2);

    // Step 4: Multiply Prior * Likelihoods to obtain posterior scores
    float post_spam = p_spam * l_free_spam * l_offer_spam;
    float post_ham  = p_ham  * l_free_ham  * l_offer_ham;

    printf("=== Lab 04: Naive Bayes with Laplace Smoothing ===\n");
    printf("Priors: P(Spam) = %.2f, P(Ham) = %.2f\n", p_spam, p_ham);
    printf("Unnormalized Posterior Spam = %.4f\n", post_spam);
    printf("Unnormalized Posterior Ham  = %.4f\n", post_ham);
    printf("Classification Result       = %s\n", (post_spam > post_ham) ? "SPAM" : "HAM");

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

The Zero-Probability Solution: In standard probability, if $P(\text{Offer}=\text{Yes} \mid \text{Ham}) = 0$, the entire posterior collapses to zero. Laplace smoothing fixes this by adding $1$ to numerator and $k=2$ to denominator ((count + 1.0) / (N + 2)).
Float Casting: Always write (float)(count + 1) / (N + 2) to avoid integer division returning zero.

5. Sample Execution Output

=== Lab 04: Naive Bayes with Laplace Smoothing ===
Priors: P(Spam) = 0.50, P(Ham) = 0.50
Unnormalized Posterior Spam = 0.1020
Unnormalized Posterior Ham  = 0.0612
Classification Result       = SPAM

Lab 05: Logistic Regression (Sigmoid & Gradient Descent)

1. Problem Statement

Implement binary Logistic Regression using gradient descent. Train a linear combination model $z = b_0 + b_1x$ passed through a continuous Sigmoid activation function $P = \frac{1}{1 + e^{-z}}$ to predict classification probabilities.

2. Core Mathematical Formulation

Sigmoid Hypothesis:
$$P(Y = 1 \mid x) = \sigma(z) = \frac{1}{1 + e^{-(b_0 + b_1x)}}$$
Batch Gradient Descent Weight Update:
$$b_0 \leftarrow b_0 - \alpha \frac{1}{m}\sum_{i=1}^{m}(P^{(i)} - y^{(i)})$$
$$b_1 \leftarrow b_1 - \alpha \frac{1}{m}\sum_{i=1}^{m}(P^{(i)} - y^{(i)})x^{(i)}$$
where $\alpha$ is the learning rate and $m$ is the sample count.

3. Pure C Implementation

#include <stdio.h>
#include <math.h>

int main() {
    int m = 6, epoch, i;
    // Data: Study Hours (x) vs Exam Result Pass=1 / Fail=0 (y)
    float x[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
    float y[] = {0.0, 0.0, 0.0, 1.0, 1.0, 1.0};

    float b0 = 0.0, b1 = 0.0;
    float alpha = 0.1; // Learning rate
    int epochs = 500;
    float test_x = 5.0, z_test, p_test;

    // Step 1: Batch Gradient Descent Optimization Loop
    for (epoch = 0; epoch < epochs; epoch++) {
        float grad_b0 = 0.0;
        float grad_b1 = 0.0;

        for (i = 0; i < m; i++) {
            float z = b0 + (b1 * x[i]);
            float p = 1.0 / (1.0 + exp(-z)); // Sigmoid activation
            float err = p - y[i];

            grad_b0 += err;
            grad_b1 += err * x[i];
        }

        // Apply parameter updates
        b0 -= alpha * (grad_b0 / m);
        b1 -= alpha * (grad_b1 / m);
    }

    // Step 2: Make prediction for new observation
    z_test = b0 + (b1 * test_x);
    p_test = 1.0 / (1.0 + exp(-z_test));
    int pred_class = (p_test >= 0.5) ? 1 : 0;

    printf("=== Lab 05: Logistic Regression ===\n");
    printf("Trained Weights: b0 = %.3f, b1 = %.3f\n", b0, b1);
    printf("Test Input x = %.1f -> Logit z = %.2f\n", test_x, z_test);
    printf("Predicted Probability P(Y=1) = %.4f\n", p_test);
    printf("Predicted Decision Class      = %d (%s)\n", pred_class, pred_class ? "PASS" : "FAIL");

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Gradient Symmetry: Notice the gradient formula matches linear regression MSE gradient, but the prediction $P$ is squashed through 1.0 / (1.0 + exp(-z)).
Standard Threshold: Probabilities $\ge 0.5$ map to Class 1, while $< 0.5$ map to Class 0.

5. Sample Execution Output

=== Lab 05: Logistic Regression ===
Trained Weights: b0 = -3.894, b1 = 1.113
Test Input x = 5.0 -> Logit z = 1.67
Predicted Probability P(Y=1) = 0.8416
Predicted Decision Class      = 1 (PASS)

Lab 06: Model Validation via Leave-One-Out Cross-Validation (LOOCV)

1. Problem Statement

Implement Leave-One-Out Cross-Validation (LOOCV) for a regression model in C. Partition a dataset of $n$ instances into $n$ separate folds. In each iteration, train on $n - 1$ samples, evaluate on the single held-out instance, and compute the final generalization Mean Squared Error ($\text{MSE}_{\text{LOO}}$).

2. Core Mathematical Formulation

Exhaustive Partitioning:
$$\text{Fold } k: \quad \mathcal{D}{\text{train}} = { (x_i, y_i) \mid i \neq k }, \quad \mathcal{D}{\text{test}} = { (x_k, y_k) }$$
Cross-Validation Mean Squared Error:
$$\text{MSE}{\text{LOO}} = \frac{1}{n} \sum{k=1}^{n} (y_k - \hat{y}_{(k)})^2$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 4, test_idx, i;
    float x[] = {1.0, 2.0, 3.0, 4.0};
    float y[] = {2.0, 3.0, 5.0, 6.0};
    float total_sq_err = 0.0;

    printf("=== Lab 06: Leave-One-Out Cross-Validation (LOOCV) ===\n");

    // Outer Loop: Hold out each sample once
    for (test_idx = 0; test_idx < n; test_idx++) {
        float sum_x = 0.0, sum_y = 0.0;
        float mx, my, num = 0.0, den = 0.0;
        float b0, b1, pred_y, err;
        int train_size = n - 1;

        // Step 1: Compute means over the (n - 1) training instances
        for (i = 0; i < n; i++) {
            if (i == test_idx) continue; // Skip held-out test instance
            sum_x += x[i];
            sum_y += y[i];
        }
        mx = sum_x / train_size;
        my = sum_y / train_size;

        // Step 2: Fit model on the training fold
        for (i = 0; i < n; i++) {
            if (i == test_idx) continue;
            num += (x[i] - mx) * (y[i] - my);
            den += (x[i] - mx) * (x[i] - mx);
        }
        b1 = num / den;
        b0 = my - (b1 * mx);

        // Step 3: Evaluate on held-out sample
        pred_y = b0 + (b1 * x[test_idx]);
        err = y[test_idx] - pred_y;
        total_sq_err += err * err;

        printf("Fold %d: Left out (%.1f, %.1f) -> Pred: %.2f, Sq Error: %.4f\n", 
               test_idx + 1, x[test_idx], y[test_idx], pred_y, err * err);
    }

    // Step 4: Average squared loss across all folds
    float loo_mse = total_sq_err / n;
    printf("Final LOOCV Mean Squared Error (MSE) = %.4f\n", loo_mse);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

The continue Statement: Using if (i == test_idx) continue; eliminates the need to allocate separate temporary arrays for every cross-validation fold.
Division Factors: Train means divide by train_size = n - 1. The final overall cross-validation error divides by the total sample size n.

5. Sample Execution Output

=== Lab 06: Leave-One-Out Cross-Validation (LOOCV) ===
Fold 1: Left out (1.0, 2.0) -> Pred: 1.83, Sq Error: 0.0278
Fold 2: Left out (2.0, 3.0) -> Pred: 3.50, Sq Error: 0.2500
Fold 3: Left out (3.0, 5.0) -> Pred: 4.50, Sq Error: 0.2500
Fold 4: Left out (4.0, 6.0) -> Pred: 6.67, Sq Error: 0.4444
Final LOOCV Mean Squared Error (MSE) = 0.2431

Conclusion & Next Steps

This concludes Module I: Basic Supervised Learning & Validation written in pure C. You can compile any of these programs directly using GCC or Clang:

gcc -O2 lab_01.c -o lab_01
gcc -O2 lab_03.c -lm -o lab_03   # Note: link math library (-lm) for KNN / Logistic
./lab_01

The AI Infrastructure Playbook: Building a Generational Deep-Tech Company

Pavan Kumar Sadashiv — Thu, 29 Oct 2026 11:17:02 +0000

Core Philosophy: Picks & Shovels Over Wrapper Apps

When Alexandr Wang built Scale AI at 19span_0 span_0, he ignored flashy consumer apps and targeted the unsexy bottleneck choking every autonomous vehicle company: high-volume sensor and LiDAR data pipelines. When the industry shifted to LLMs, he pivoted that exact infrastructure into RLHF and frontier model evaluation for giants like OpenAI and Microsoftspan_1 span_1.

The Rule: Stop building fragile UI wrappers. Build the low-level plumbing (C++20, CUDA, deterministic agent sandboxes, and physical edge data pipelines) that every funded AI company is forced to buy.

Phase 1: Lock In the "Narrow Wedge" (Weeks 1–2)

Do not build a general platform on Day 1. Pick one excruciatingly painful bottleneck where engineering teams are bleeding cash or compute.

Wedge Track	The Enterprise Pain Point	The "Pick & Shovel" Deliverable
Track A: GPU & Inference Plumbing	AI companies burn 60%+ of funding on inefficient GPU compute, memory fragmentation, and slow agent tool-calling.	Custom C++20/CUDA runtime optimization layer, paged KV-cache manager, or ultra-fast MCP execution sandbox that cuts latency/cost by 30–50%.
Track B: Physical & Edge AI Data	Robotics, marine, and industrial IoT companies lack clean real-world training data and low-power edge inference in harsh environments.	Standardized edge-sensor hardware + automated telemetry/vision labeling pipeline (scaling the MATSYA architecture into a global B2B marine/edge data engine).

Week 1–2 Action Checklist

[ ] Select one primary track for the next 90 days.
[ ] Write a 1-page technical specification defining exact input, the processing bottleneck eliminated, and the target metric (e.g., Latency drops from 400ms to 90ms or Underwater vision labeling accuracy hits 99% in low-visibility conditions).

Phase 2: Build the "Hardcore Proof" Prototype (Weeks 3–6)

In deep-tech and infrastructure, CTOs do not care about slide decks. They care about reproducible benchmarks.

Build the bare-bones core engine: Strip out all UI and dashboards. Write the raw C++/CUDA kernel, the Python/Go SDK wrapper, or the edge-sensor ingestion pipeline.
Run a head-to-head benchmark: Test your solution against the current industry standard (e.g., vanilla vLLM, standard PyTorch, or baseline OpenCV pipelines).
Publish the receipts: Push a clean benchmark repository to GitLab/GitHub with reproducible test scripts, profiling flamegraphs, and a technical breakdown showing why your architecture wins on throughput, memory, or accuracy.

Phase 3: Land the First 3 "Design Partners" (Weeks 7–10)

You do not need 1,000 random users. You need 3 funded companies whose engineering teams are struggling with your exact bottleneck.

1. Build a Hit-List of 50 Targets

Filter for recent Y Combinator, Peak XV Surge, or a16z speedrun startups building in autonomous agents, robotics, or heavy inference. Identify their CTOs or Principal Systems Engineers.

2. The "Engineer-to-Engineer" Cold Outreach Template

"Hey [Name], saw your team is scaling [specific repo/product]. Noticed [specific bottleneck in inference / edge telemetry]. I built a custom [C++/CUDA runtime / edge pipeline] that cuts [metric] by 40%—here is the benchmark repo with the profiling numbers: [Link]. Happy to wire it into your staging environment this week for free to see if it beats your current setup."

3. Do Things That Don't Scale

Write the integration code for your first 3 design partners manually.
Debug their edge cases overnight.
Get your runtime or pipeline running inside their production environment.

Phase 4: Build an "AI-Native" Software Factory (Months 3–4)

Once 3 companies rely on your code in production, transition from custom engineering to a scalable platform.

Productize Manual Fixes into an SDK/API: Every bug or custom optimization written for Client #1 gets abstracted into the core codebase so Client #4 deploys it via a single pip install, binary, or Docker container.
Token-Max Internal Operations: Run engineering under HRL as an automated software factory. Write strict test harnesses and formal specs, using autonomous coding agents and CLI automation (glab, custom MCP workflows) to handle boilerplate and CI/CD while you focus on core architecture.
Value-Based Enterprise Pricing: Charge based on compute saved, data volume processed, or an annual enterprise license:
- Early Indian Startup Tier: ₹40,000 – ₹1,50,000 / month
- Global / US Startup Tier: $2,000 – $5,000 / month

Phase 5: The Venture & Accelerator Leap (Months 5–6)

With verified 3x benchmarks and 3 active design partners, you are in the top 1% of technical applicants globally.

Keep IP Clean: House all core IP cleanly under HRL International Pvt. Ltd. (ready for a standard Delaware C-Corp structure if raising US institutional capital).
Target Tier-1 Accelerators: Apply to Y Combinator, Peak XV Surge, and Accel Atoms.
The 60-Second Pitch Formula:
1. Who I am: Systems architect & founder.
2. The Bottleneck: Why current AI infrastructure breaks at scale.
3. The Proof: Our engine beats the industry standard by $X\times$ in production benchmarks.
4. Traction: 3 companies are already running it in their live pipelines.

Immediate 7-Day Sprint Log

Selected Track: [Fill in: GPU/Agent Runtime OR Physical Edge-AI Pipeline]
Target Benchmark Metric: [Fill in exact metric to beat within 7 days]
Baseline to Beat: [Fill in competitor/standard tool]
Repo Link: [Insert private/public GitLab repo URL]

Contributing to GitLab & MCP: Lessons from a Week of Upstream Open-Source Engineering

Pavan Kumar Sadashiv — Thu, 29 Oct 2026 11:09:19 +0000

Over the past sprint, I contributed a series of upstream enhancements and bug fixes to GitLab (gitlab-org/gitlab) and the GitLab Language Server (gitlab-org/editor-extensions/gitlab-lsp).

Most of these changes focus on GitLab’s implementation of the Model Context Protocol (MCP)—the protocol connecting AI agents and IDE assistants (like GitLab Duo) to GitLab's API—as well as race-condition resilience in Language Server protocols.

Here is a comprehensive retrospective on what was built, the architectural decisions behind them, and lessons learned getting complex merge requests to 100% green pipelines under GitLab's rigorous review standards.

1. Enabling Note Editing in the MCP `save_note` Tool (!264854)

The Challenge

The MCP save_note tool allowed AI agents to post comments, reply to discussion threads, and resolve discussions on merge requests and work items. However, agents could not edit their existing comments or refine feedback in-place, leading to comment sprawl.

The Solution

We introduced the update_note method to save_note:

GraphQL Mutation Integration: Leveraged Mutations::Notes::Update::Base (updateNote) with proper authorization checks and quick-action guards.
Flexible Note ID Normalization: Agents might supply a bare integer ID (from review tools) or a full Global ID (gid://gitlab/Note/123). We updated the tool schema to accept oneOf: [{ type: 'string' }, { type: 'integer' }] and automatically coerce them.
Container Governance for Group-Level Items: Group-level work items and epics don't have a project, so we ensured the governance container resolver properly fell back to note.namespace to enforce project/group tool policies.
Ruby false.blank? Trap: In Ruby/Rails, false.blank? evaluates to true. When validating method arguments for boolean fields like resolved: false, a naive .blank? check erroneously flagged the parameter as missing. We implemented strict string-blankness checking (val.nil? || (val.is_a?(String) && val.blank?)) to guarantee boolean stability.

2. Exposing User Contribution Events to MCP with JSON Schema Compatibility (!264864)

The Challenge

Agents needed visibility into recent user activity to assist with sprint summaries and standups. While /users/:id/events existed as a REST endpoint, it was not exposed as an MCP tool.

The Solution

API Tool Exposure: Bound the endpoint as list_user_events in the :core toolset with pagination, action, and target-type filters.
Date Type Schema Fix (ApiTool::TYPE_CONVERSIONS): Grape defines parameters like before and after with type: Date. Grape's MCP tool mapper previously lacked a mapping for Date, emitting "type": "date" in the generated JSON Schema—which is invalid according to the JSON Schema meta-schema and caused strict MCP clients to reject the tool catalog. We added 'Date' => 'string' to map dates cleanly to ISO 8601 strings.
Handbook Documentation: Documented the tool, parameters, and history blocks in mcp_server_tools.md.

3. Consolidating Pipeline Creation into `save_pipeline` (!264858)

The Challenge

An earlier draft introduced a separate tool to create merge request pipelines. Reviewers pointed out that having both save_pipeline and a dedicated merge request pipeline tool introduced fragmentation and API redundancy.

The Solution

Single Responsibility Principle: Consolidated the merge request trigger directly into SavePipelineService using an optional merge_request_iid parameter.
Zero-Route Redundancy: Reverted unnecessary Grape route settings and handled project/pipeline discovery within the core service.
RuboCop Layout Compliance: Aligned multiline exception rescue blocks to satisfy GitLab's strict rubocop layout rules.

4. Work Item Parent Filtering & MCP Validation Ergonomics (!264859 & !264853)

Work Item Parent Filtering (!264859)

Added parent_iid support to the list_work_items MCP tool, enabling agents to query tasks and child items belonging to a specific parent issue or epic.
Added comprehensive unit specs and documentation updates.

Informative MCP Validation Errors (!264853)

When LLMs make tool calls with misspelled or extraneous arguments, generic error messages force them into trial-and-error loops.
Refactored argument validation to explicitly return both the unknown parameters and the list of accepted parameters, allowing AI models to self-correct in a single turn.
Verified across all 3,000+ MCP tool specs with zero regressions.

5. Eliminating Cross-Session Message Leaks in `gitlab-lsp` (!4539)

The Challenge

In the GitLab Language Server (gitlab-lsp), when a user ran /new to initiate a clean session while pending wake messages were queued, old microtasks could resolve and dispatch messages to the newly instantiated session, causing stale state corruption.

The Solution

Wrapped pending wake operations with session IDs and implemented await flushMicrotasks() during session teardown.
Added automated mid-stream cancellation tests to ensure pending events from defunct sessions are deterministically discarded.
Achieved a 100% green CI pipeline across all 82 jobs.

Key Takeaways for Contributing to Large-Scale Projects

Beware of Truthiness Edge-Cases: In Rails, remember that false.blank? == true. Always check .nil? or type-check when accepting booleans.
Adhere to the Rule of Minimum Code: If a capability can be cleanly folded into an existing tool or service (like adding merge_request_iid to save_pipeline), do that instead of spawning new classes.
Strict JSON Schema Compliance Matters: LLM tool runners and protocol clients parse schemas strictly. Non-standard types like "date" will break tool discovery across ecosystems.
Resilient CI Habits: Multi-stage CI pipelines test everything from Danger rules to Pajamas component adoption. Running linters locally and writing isolated unit specs keeps reviews moving fast.

All Merge Requests linked above are open or merged in GitLab's official repositories. Happy hacking!

Official Corporate Standard & Future Role Ingestion Specification

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 19:18:28 +0000

HRL International Private Limited™ — Leadership Architecture & Role Onboarding Protocol

Document Status: Official Corporate Standard & Future Role Ingestion Specification

Authority: HRL International Private Limited™

Founder & Managing Director: Pavan Kumar Sadashiv (hrlpavan)

Standard Identifier: HRL-SPEC-LEADERSHIP-ONBOARDING-2026-V1

Effective Date: October 2026

Target Repositories: hrl-international-website- & HRL-Company-Page-Announcement-Design

1. Overview & Purpose of This Architecture Update

This update establishes a standalone, dedicated Corporate Leadership Directory (/leadership) for HRL International Private Limited to showcase our executive council, founders, and division managers, loading all profile pictures dynamically from the HRL CORE COMPANY ROLE directory.

Core Architecture Objectives

Dedicated Executive Showcase: Independent route (/leadership and /leadership.html) decoupling executive governance from the landing page.
Tactile Identity Card Design Language: Direct inheritance of the Universal Rate Card & Studio VFX standard (baby pink accent stripe, subtle rose gradient, tactile drop shadows, and typographic watermarks).
High-Fidelity Specular Glass Avatar Lenses: Optical mirror glare, diagonal lens horizon reflections, and continuous $360^\circ$ specular conic chrome rims.
Symmetrical Placing Principle: Balanced responsive grid (3 columns on desktop, 2 on tablet, 1 on mobile) with zero lone dangling cards.
Zero Main Page Regression: The main page (index.html) remains clean and regression-free, with surgical navigation links inserted into the navbar and footer.

2. Design Tokens & Visual Architecture

A. Color Palette & Card Shell Tokens

Token	Value	Visual Function
Surface Background	`linear-gradient(165deg, #ffffff 0%, #fff7f9 100%)`	Subtle tactile rose-white executive gradient.
Accent Stripe (`@hrl`)	`#e05375` (`border-left: 5px solid #e05375`)	Primary tactile boundary stripe on left edge.
Accent Stripe (`@hrlcrimsonRED`)	`#D1002D` (`border-left: 5px solid #D1002D`)	High-salience Crimson Red division boundary stripe.
Card Border	`1px solid rgba(255, 182, 193, 0.45)`	Subtle translucent rose containment boundary.
Border Radius	`20px` (`var(--radius-card)`)	Apple-caliber rounded geometry.
Box Shadow	`0 16px 36px rgba(255, 182, 193, 0.14), 0 2px 8px rgba(0, 0, 0, 0.02)`	Tactile soft elevation.
Hover State	`transform: translateY(-4px); border-left-color: #D1002D;`	Tactile elevation with enriched drop shadow.

B. High-Quality Specular Glass Avatar Lens & Mirror Reflection

Every leader profile avatar features a multi-layer specular glass lens:

Specular Conic Rim (::before):

Continuous $360^\circ$ metallic silver/chrome transition with zero blank spots:

 background: conic-gradient(
   from 225deg,
   #ffffff 0deg, #cbd5e1 35deg, #64748b 70deg, #334155 120deg,
   #0f172a 160deg, #1e293b 200deg, #475569 230deg, #94a3b8 270deg,
   #e2e8f0 310deg, #ffffff 340deg, #ffffff 360deg
 );
 filter: drop-shadow(0 3px 8px rgba(0, 0, 0, 0.35));

Crimson variant for @hrlcrimsonRED transitioning from white to scarlet (#D1002D), deep garnet (#881337), and ruby highlights.
1. Specular Glass Mirror Reflection (::after):
Dual-layered optical glare:
- Upper $45^\circ$ Diagonal Lens Horizon Mirror Sheen: linear-gradient(135deg, rgba(255,255,255,0.42) 0%, rgba(255,255,255,0.18) 28%, rgba(255,255,255,0.03) 48%, transparent 52%, rgba(255,255,255,0.04) 75%, rgba(255,255,255,0.16) 100%)
- Top Radial Keylight Flare: radial-gradient(ellipse at 50% 0%, rgba(255,255,255,0.50) 0%, rgba(255,255,255,0.15) 32%, transparent 65%)

Double-Lipped Beveled Glass Edge:

 box-shadow: 
   inset 0 2px 2.5px rgba(255, 255, 255, 0.95),
   inset 0 -2px 3px rgba(0, 0, 0, 0.55),
   inset 0 0 0 1px rgba(255, 255, 255, 0.25);

C. Background Watermark Monogram

Large translucent typography anchored at right: -15px; bottom: -15px; with: font-size: 88px; font-weight: 900; color: rgba(224, 83, 117, 0.05); line-height: 1; pointer-events: none; user-select: none;

3. Protocol for Adding a New Role in the Future

Whenever a new executive, founder, director, or operational manager joins HRL, follow this 5-Phase Onboarding Protocol:

Phase 1: Asset Intake

Obtain an executive headshot or professional portrait.
Crop/format the image to a 1:1 square ratio (minimum 800 × 800 px, ideal 1080 × 1080 px).
Save the image into the HRL CORE COMPANY ROLE folder:
- Filename convention: firstname-lastname.jpg (or .png / .jpeg)
- Lowercase, hyphen-separated, zero spaces.
- Example: HRL CORE COMPANY ROLE/alex-rivera.jpg

Phase 2: Role Metadata Specification

Prepare the following metadata attributes:

Full Legal / Corporate Name: e.g., Alex Rivera
Corporate Designation / Title: e.g., Chief Technology Officer (CTO)
Division Tag:
- @hrl: Core sovereign software, AI research, cloud infrastructure, enterprise engineering.
- @hrlcrimsonRED: Digital media broadcasting, Hollywood film promotions, creator acceleration, VFX.
Category Pill Tag: e.g., HRL Technology Directorate or HRL Creative Directorate
Strategic Role Scope (2–3 lines): Executive summary of domain ownership and operational mandate.
Watermark Monogram (2–3 characters): e.g., CTO, COO, DIR, VP, LEAD.

Phase 3: Symmetrical Grid Verification

Before publishing, ensure the total number of leaders maintains the Symmetrical Placing Principle:

Multiples of 2 or 3 items are required.
6 cards = 2 rows of 3 (desktop) | 3 rows of 2 (tablet).
If adding 1 new role (making 7), pair it with a second role (making 8: 2×4 or 4×2) or reorganize into 2 balanced sections (e.g. Executive Board: 3 members; Operational Directorate: 4 members in 2×2).

Phase 4: Code Insertion (HTML Template)

Copy and paste the production template below into both leadership.html and leadership/index.html.

4. Production Card Code Template for New Roles

Standard Role Card (`@hrl` Division)

<article class="tactile-identity-card">
  <!-- 1. Background Watermark Monogram -->
  <div class="card-watermark">[MONOGRAM]</div>

  <div>
    <!-- 2. Eyebrow Category Pill -->
    <div class="card-eyebrow-pill">
      <span class="pill-dot"></span>
      <span class="pill-text">[CATEGORY BADGE, e.g. HRL Technology Directorate]</span>
    </div>

    <!-- 3. Specular Glass Avatar Lens with Mirror Glare -->
    <div class="avatar-hero-container">
      <div class="avatar-wrapper">
        <img 
          src="HRL%20CORE%20COMPANY%20ROLE/[filename.jpg]" 
          alt="[Full Name] — [Title]" 
          class="avatar-img"
          loading="lazy"
          onerror="this.onerror=null; this.src='assets/hrl-company-avatar.png';"
        />
      </div>
    </div>

    <!-- 4. Identity & Scope Block -->
    <div class="card-title-group">
      <h2 class="card-main-title">[Full Name]</h2>
      <div class="card-accent-subhead">[Official Title, e.g. Chief Technology Officer (CTO)]</div>
      <p class="card-body-desc">
        [Concise 2-line strategic scope describing operational mandate and enterprise domain].
      </p>
      <div class="division-tag-row">
        <span class="division-pill division-pill-hrl">
          <span class="pill-dot"></span>
          @hrl
        </span>
      </div>
    </div>
  </div>

  <!-- 5. Signature Tactile Metadata Footer -->
  <div class="card-tactile-footer">
    <div class="card-footer-name">[FULL NAME IN UPPERCASE] (HRL)</div>
    <div class="card-footer-meta">[Official Corporate Title] · HRL International Private Limited</div>
  </div>
</article>

Crimson Red Media Role Card (`@hrlcrimsonRED` Division)

<article class="tactile-identity-card card-crimson">
  <!-- 1. Background Watermark Monogram -->
  <div class="card-watermark">[MONOGRAM]</div>

  <div>
    <!-- 2. Eyebrow Category Pill -->
    <div class="card-eyebrow-pill">
      <span class="pill-dot"></span>
      <span class="pill-text">[CATEGORY BADGE, e.g. HRL Crimson Red Media]</span>
    </div>

    <!-- 3. Specular Glass Avatar Lens (Crimson Conic Rim) -->
    <div class="avatar-hero-container">
      <div class="avatar-wrapper crimson-rim">
        <img 
          src="HRL%20CORE%20COMPANY%20ROLE/[filename.jpg]" 
          alt="[Full Name] — [Title]" 
          class="avatar-img"
          loading="lazy"
          onerror="this.onerror=null; this.src='assets/hrl-company-avatar.png';"
        />
      </div>
    </div>

    <!-- 4. Identity & Scope Block -->
    <div class="card-title-group">
      <h2 class="card-main-title">[Full Name]</h2>
      <div class="card-accent-subhead">[Official Title]</div>
      <p class="card-body-desc">
        [Concise 2-line strategic scope describing media engineering and broadcast production mandate].
      </p>
      <div class="division-tag-row">
        <span class="division-pill division-pill-crimson">
          <span class="pill-dot"></span>
          @hrlcrimsonRED
        </span>
      </div>
    </div>
  </div>

  <!-- 5. Signature Tactile Metadata Footer -->
  <div class="card-tactile-footer">
    <div class="card-footer-name">[FULL NAME IN UPPERCASE] (HRL)</div>
    <div class="card-footer-meta">[Official Corporate Title] · HRL Crimson Red Media</div>
  </div>
</article>

Note for leadership/index.html: Always prepend ../ to relative asset and page links (e.g. ../HRL%20CORE%20COMPANY%20ROLE/[filename.jpg], ../assets/..., ../index.html).

5. Automated Verification Checklist

After editing the files, run the automated test suite:

python3 test_leadership_page.py

The test runner will deterministically verify:

All referenced avatar images exist on disk and are non-empty.
Zero decorative emojis in HTML/CSS/JS (100% compliance).
Company motto presence and exact phrasing.
Correct division tags (@hrl or @hrlcrimsonRED).
Zero main page regressions (git diff index.html limited strictly to clean nav/footer links).

6. Current Verified Roster (Reference Baseline)

Member	Title	Division	Image File	Watermark
Sheikh Mohammed Raees	Chief Executive Officer (CEO)	`@hrl`	`sheikh-mohammed-raees.jpg`	`CEO`
Sanjana	Co-Founder	`@hrl`	`sanjana.png`	`CO`
Apoorvi Vijay	Chief Executive Officer (CEO)	`@hrlcrimsonRED`	`apoorvi-vijay.jpg`	`CRM`
Nishwin	REA	`@hrl`	`nishwin.jpeg`	`REA`
Shubhada Naik	Business Consultant	`@hrl`	`shubhada-naik.jpg`	`BIZ`
Jia Shetty	Core Community Manager	`@hrl`	`jia-shetty.jpeg`	`CM`

Maintained by: HRL International Private Limited Corporate Systems Directorate

Author & Inventor: Pavan Kumar Sadashiv (hrlpavan)

GitLab Notification

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 08:12:37 +0000

GitLab Notification Brief & Next Actions (`@hrlpavan`)

Generated at: Tuesday, October 27, 2026 (1:38 PM IST)

Current Contributor Score: 4,892 pts (Level 3 — Official live score, +110 pts queued from !264865 merge)

Target Milestone: 7,500 pts (Level 4 — 2,608 pts remaining)

Sprint Momentum: +1,024 pts gained! 24 merged MRs (7 merged this sprint!), 100% green pipelines across all active MRs.

⚡ 1. Critical Recent Events & Completed Actions (< 15 min Turnaround SLA)

1. `ai-assist!7641` — APPROVED & MERGED by Maintainer λ Tan Le (`@tle_gitlab`)! 🎉

Status: MERGED to main at 12:25 PM IST!
Impact: Closed issue #3394. Included in official AI Gateway release v1.876.0. Contributed +110 points directly to live score!
Action: Resolved all @gitlab-bot ready discussions on sibling MR ai-assist!7642.

2. `gitlab-lsp!4536` — APPROVED & MERGED by Maintainer Alejandro Metke Jimenez (`@ametke-jimenez`)! 🎉

Status: MERGED to main at 11:56 AM IST!
Impact: Closed issue #2381. All 187 tests passing. Contributed +110 points directly to live score!
Action: Resolved discussions on sibling MR gitlab-lsp!4539.

3. `gitlab!264862` — Pushed Interaction Spec & Resolved All Discussions

Commit: 7dbe45e1cfda added test in spec/services/mcp/tools/work_items/update_work_item_tool_spec.rb combining description_edits with expected_updated_at stale guard per Duo Developer's review.
Discussions: 100% resolved (replied to thread 0451946d, resolved 8c7e545e, 501ab77d, dfa94da2).
Status: blocking_discussions_resolved: true, approved by Miranda Fluharty (@mfluharty).

4. Zero Unresolved Discussions Across the Entire Fleet

Cleaned up all legacy bot-ready / discussion threads across:
- gitlab!264864, gitlab!264863, gitlab!264859, gitlab!264858, gitlab!264856, gitlab!264854, gitlab!264853, gitlab!264852
- gitlab!261178, gitlab!261174
- gitlab-lsp!4539, ai-assist!7642
Result: Every active MR is completely clean with 0 blocking discussions.

⚡ 2. Current Open MR Status Board (18 Active MRs)

Project	MR	Component	Reviewer	Approvals	Pipeline	Discussions
`gitlab`	!264862	MCP `save_work_item` edits & guard	`@mfluharty`, `@jessieay`	1/4 (Approved)	Running	0 Unresolved
`gitlab`	!261025	Route mount precondition assertions	`@jannik_lehmann`	1/1 (Approved)	Success	0 Unresolved
`gitlab`	!261030	Organization#empty? attached resources	`@ngala`, `@mbenayoun`	2/2 (Approved)	Success	0 Unresolved
`gitlab`	!264858	MCP `create_merge_request_pipeline`	`@jessieay`	0/4	Success	Awaiting Jessie
`gitlab`	!264864	MCP `list_user_events`	`@sandrato`	0/4	Success	0 Unresolved
`gitlab`	!264863	MCP `get_pipeline` poll hint	`@hbakergitlab`	0/4	Success	0 Unresolved
`gitlab`	!264859	MCP `list_work_items` parent filter	`@sandrato`	0/4	Success	0 Unresolved
`gitlab`	!264856	MCP `list_pipeline_schedules`	`@narendran-kannan`	0/4	Success	0 Unresolved
`gitlab`	!264854	MCP `save_note` update support	`@shameed3`	0/4	Success	0 Unresolved
`gitlab`	!264853	MCP param error validation formatting	`@tgao3701908`	0/4	Success	0 Unresolved
`gitlab`	!264852	MCP search query aliases	`@obaiye`	0/4	Success	0 Unresolved
`gitlab`	!262103	Non-ASCII branch workspace cloning	`@erran`	0/1	Success	1 appsec ping
`gitlab`	!261178	Secret detection variable cleanup	`@ashvins`	0/1	Success	0 Unresolved
`gitlab`	!261174	SourceEditor dynamic height directive	`@clavimoniere`	0/1	Success	0 Unresolved
`gitlab`	!262558	RubyGems spec files cleanup	`@jnutt`, `@shameed3`	0/2	Success	Under DB review
`gitlab-lsp`	!4539	Hold pending wakes during slash command	`@john-slaughter`	0/1	Success	0 Unresolved
`gitlab-lsp`	!4407	Welcome card after /new	`@elwyn-gitlab`	0/1	Success	0 Unresolved
`ai-assist`	!7642	Read status_code from APIStatusError	`@tle_gitlab`	0/1	Success	0 Unresolved
gitlab!264865	Zoekt storage index	`@rkumar555`	MERGED	`success`	0
gitlab!264862	MCP `save_work_item`	`@mfluharty`, `@jessieay`	Approved (1/4)	`success`	0
gitlab!261025	CI graph view	`@jannik_lehmann`	Approved	`success`	0
gitlab!261030	Pipeline mini graph	`@mbenayoun`, `@ngala`	Approved	`success`	0
gitlab!262103	Workspace non-ASCII	`@erran`	Approved	`success`	0
gitlab!264858	MCP `create_mr_pipeline`	`@jessieay`	Ready	`success`	0
gitlab!264853	MCP param validation	`@tgao3701908`	Ready	`success`	0
gitlab!264854	MCP `save_note`	`@shameed3`	Ready	`success`	0
gitlab!264856	MCP `pipeline_schedules`	`@narendran-kannan`	Ready	`success`	0
gitlab!264859	MCP `parent_id` filter	`@sandrato`	Ready	`success`	0
gitlab!264863	MCP `get_pipeline` hint	`@hbakergitlab`	Ready	`success`	0
gitlab!264864	MCP `list_user_events`	`@sandrato`	Ready	`success`	0
gitlab!264852	MCP search aliases	`@obaiye`	Ready	`success`	0
gitlab-lsp!4536	Workflow file state key	`@ametke-jimenez`	Ready to merge	`running`	0
gitlab-lsp!4539	Slash command queue	`@john-slaughter`	Ready	`success`	0
ai-assist!7641	Tool call guard	`@tle_gitlab`	Ready	`success`	0
ai-assist!7642	DWS status code	`@tle_gitlab`	Ready	`success`	0

🎯 3. What To Do Next

Self-Assign Available Issue Slots on contributors.gitlab.com:
- Claim gitlab-lsp#2381 (MR !4536 all feedback resolved, ready to merge)
- Claim gitlab-lsp#3355 (MR !4539 under review & green)
- Claim ai-assist#3394 (MR !7641 under review & green)
- Claim ai-assist#3345 (MR !7642 under review & green)
Current Review Posture:
- 0 blocker threads remain on you across all 15 open MRs.
- Awaiting maintainer merge on:
  - gitlab-lsp!4536 (@ametke-jimenez confirmed: "Should be good to merge once that's fixed.")
  - !264862 (Approved by @mfluharty)
  - !261025 (@jannik_lehmann — re-add to merge train)
  - !261030 (@mbenayoun — approved by @ngala)

Machine Learning From Scratch in Pure C: Module I — Supervised Learning & Foundations

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 06:14:01 +0000

Machine Learning From Scratch in Pure C

Module I: Supervised Learning & Model Validation

Module I Syllabus & Lab Mapping

Lab #	Topic / Algorithm	Type	Core Mathematical Concept
Lab 01	Simple Linear Regression	Supervised (Regression)	Ordinary Least Squares (OLS) & Mean Deviations
Lab 02	Multiple Linear Regression	Supervised (Regression)	Deviation Product System & 2x2 Closed-Form Determinants
Lab 03	K-Nearest Neighbors (KNN)	Supervised (Classification)	Instance-based Euclidean Distance & Majority Voting
Lab 04	Naïve Bayes Classifier	Supervised (Classification)	Conditional Independence, Prior Probabilities & Laplace Smoothing
Lab 05	Logistic Regression	Supervised (Classification)	Sigmoid Hypothesis & Batch Gradient Descent Optimization
Lab 06	Leave-One-Out CV (LOOCV)	Model Evaluation	Exhaustive Resampling & Mean Squared Error (MSE)

Lab 01: Simple Linear Regression (Ordinary Least Squares)

1. Problem Statement

Implement Simple Linear Regression using Ordinary Least Squares (OLS). Given a training set of input features $x$ and continuous target outcomes $y$, compute:

Feature and target sample means ($ar{x}, ar{y}$)
Regression slope ($b_1$) and y-intercept ($b_0$)
The fitted linear model $\hat{y} = b_0 + b_1x$
Output predictions for unseen query values.

2. Core Mathematical Formulation

Sample Means:
$$ar{x} = rac{1}{n}\sum_{i=1}^{n} x_i, \quad ar{y} = rac{1}{n}\sum_{i=1}^{n} y_i$$
Slope Coefficient ($b_1$):
$$b_1 = rac{\sum_{i=1}^{n} (x_i - ar{x})(y_i - ar{y})}{\sum_{i=1}^{n} (x_i - ar{x})^2}$$
Y-Intercept ($b_0$):
$$b_0 = ar{y} - b_1ar{x}$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 4, i;
    // Training dataset: Study hours (x) vs Exam marks (y)
    float x[] = {1.0, 2.0, 3.0, 4.0};
    float y[] = {2.0, 3.0, 5.0, 6.0};

    float sum_x = 0.0, sum_y = 0.0;
    float mx, my;
    float num = 0.0, den = 0.0;
    float b0, b1;
    float test_x = 5.0, pred_y;

    // Step 1: Calculate arithmetic means
    for (i = 0; i < n; i++) {
        sum_x += x[i];
        sum_y += y[i];
    }
    mx = sum_x / n;
    my = sum_y / n;

    // Step 2: Compute deviation products (num) and squared deviations (den)
    for (i = 0; i < n; i++) {
        num += (x[i] - mx) * (y[i] - my);
        den += (x[i] - mx) * (x[i] - mx);
    }

    // Step 3: Compute slope (b1) and intercept (b0)
    b1 = num / den;
    b0 = my - (b1 * mx);

    // Step 4: Make prediction for new observation
    pred_y = b0 + (b1 * test_x);

    printf("=== Lab 01: Simple Linear Regression ===\n");
    printf("Mean X = %.2f, Mean Y = %.2f\n", mx, my);
    printf("Slope (b1) = %.2f\n", b1);
    printf("Intercept (b0) = %.2f\n", b0);
    printf("Fitted Equation: y = %.2f + %.2fx\n", b0, b1);
    printf("Prediction for x = %.1f -> y = %.2f\n", test_x, pred_y);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Two-Pass Loop Strategy: The first loop computes the means (mx and my). The second loop calculates the centered deviations (x[i] - mx) and accumulates the covariance numerator and variance denominator.
Calculation Sequence: Always resolve b1 = num / den before computing b0 = my - b1 * mx, since $b_0$ explicitly depends on $b_1$.
Time & Space Complexity: Time Complexity is $\mathcal{O}(n)$, Space Complexity is $\mathcal{O}(1)$ auxiliary space.

5. Sample Execution Output

=== Lab 01: Simple Linear Regression ===
Mean X = 2.50, Mean Y = 4.00
Slope (b1) = 1.40
Intercept (b0) = 0.50
Fitted Equation: y = 0.50 + 1.40x
Prediction for x = 5.0 -> y = 7.50

Lab 02: Multiple Linear Regression (Two Features)

1. Problem Statement

2. Core Mathematical Formulation

Centering Variables (Mean Deviations):
$$x_1 = X_1 - ar{X}_1, \quad x_2 = X_2 - ar{X}_2, \quad y = Y - ar{Y}$$
Coefficient Solution via System Determinants:
$$b_1 = rac{(\sum x_1 y)(\sum x_2^2) - (\sum x_2 y)(\sum x_1 x_2)}{(\sum x_1^2)(\sum x_2^2) - (\sum x_1 x_2)^2}$$
$$b_2 = rac{(\sum x_2 y)(\sum x_1^2) - (\sum x_1 y)(\sum x_1 x_2)}{(\sum x_1^2)(\sum x_2^2) - (\sum x_1 x_2)^2}$$
Model Intercept ($b_0$):
$$b_0 = ar{Y} - b_1ar{X}_1 - b_2ar{X}_2$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 3, i;
    // Input features X1, X2 and Target Y
    float X1[] = {1.0, 2.0, 3.0};
    float X2[] = {1.0, 2.1, 2.9};
    float Y[]  = {3.0, 5.8, 9.2};

    float m1 = 0.0, m2 = 0.0, my = 0.0;
    float s11 = 0.0, s22 = 0.0, s12 = 0.0, s1y = 0.0, s2y = 0.0;
    float den, b0, b1, b2;
    float test_x1 = 4.0, test_x2 = 3.8, pred_y;

    // Step 1: Calculate feature and target sample means
    for (i = 0; i < n; i++) {
        m1 += X1[i];
        m2 += X2[i];
        my += Y[i];
    }
    m1 /= n; m2 /= n; my /= n;

    // Step 2: Accumulate centered sum-of-squares and cross-products
    for (i = 0; i < n; i++) {
        float x1 = X1[i] - m1;
        float x2 = X2[i] - m2;
        float y  = Y[i] - my;
        s11 += x1 * x1;
        s22 += x2 * x2;
        s12 += x1 * x2;
        s1y += x1 * y;
        s2y += x2 * y;
    }

    // Step 3: Compute determinant denominator and weights
    den = (s11 * s22) - (s12 * s12);
    b1  = ((s1y * s22) - (s2y * s12)) / den;
    b2  = ((s2y * s11) - (s1y * s12)) / den;
    b0  = my - (b1 * m1) - (b2 * m2);

    // Step 4: Output model and evaluate new data point
    pred_y = b0 + (b1 * test_x1) + (b2 * test_x2);

    printf("=== Lab 02: Multiple Linear Regression ===\n");
    printf("b0 (Intercept) = %.2f\n", b0);
    printf("b1 (Weight X1) = %.2f\n", b1);
    printf("b2 (Weight X2) = %.2f\n", b2);
    printf("Model Equation: Y = %.2f + (%.2f * X1) + (%.2f * X2)\n", b0, b1, b2);
    printf("Prediction for (%.1f, %.1f) = %.2f\n", test_x1, test_x2, pred_y);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

5 Deviation Accumulators: Remember s11 ($\sum x_1^2$), s22 ($\sum x_2^2$), s12 ($\sum x_1 x_2$), s1y ($\sum x_1 y$), and s2y ($\sum x_2 y$).
Cross Matching Rule: b1 pairs s1y with s22 minus s2y * s12. Conversely, b2 pairs s2y with s11 minus s1y * s12. Both share the exact same denominator den = s11*s22 - s12*s12.

5. Sample Execution Output

=== Lab 02: Multiple Linear Regression ===
b0 (Intercept) = 0.00
b1 (Weight X1) = 5.00
b2 (Weight X2) = -2.00
Model Equation: Y = 0.00 + (5.00 * X1) + (-2.00 * X2)
Prediction for (4.0, 3.8) = 12.40

Lab 03: K-Nearest Neighbors (KNN Classification)

1. Problem Statement

Implement the K-Nearest Neighbors (KNN) algorithm from scratch for binary classification. Given a query point $Q(q_1, q_2)$:

Calculate the Euclidean distance between $Q$ and all training vectors.
Sort the training instances in ascending order of proximity while maintaining label synchronicity.
Apply majority voting over the top $K$ nearest neighbors to classify $Q$.

2. Core Mathematical Formulation

Euclidean Distance Metric:
$$d(p, q) = \sqrt{(p_1 - q_1)^2 + (p_2 - q_2)^2}$$
Majority Voting Function:
$$\hat{Y} = egin{cases} 1 & ext{if } \sum_{i=1}^{K} y_{(i)} > rac{K}{2} \ 0 & ext{otherwise} \end{cases}$$

3. Pure C Implementation

#include <stdio.h>
#include <math.h>

int main() {
    int n = 6, k = 3, i, j;
    // 2D training coordinates and binary classes (0 or 1)
    float x1[] = {1.0, 1.5, 2.0, 5.0, 5.5, 6.0};
    float x2[] = {1.0, 2.0, 1.5, 5.0, 6.0, 5.5};
    int label[] = {0, 0, 0, 1, 1, 1};

    float d[6];
    float q1 = 2.0, q2 = 2.5; // Test query point
    int votes = 0;

    // Step 1: Compute Euclidean distance to all training instances
    for (i = 0; i < n; i++) {
        d[i] = sqrt(((x1[i] - q1) * (x1[i] - q1)) + ((x2[i] - q2) * (x2[i] - q2)));
    }

    // Step 2: Sort distances in ascending order while keeping labels synchronized
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (d[j] > d[j + 1]) {
                float temp_d = d[j];
                d[j] = d[j + 1];
                d[j + 1] = temp_d;

                int temp_l = label[j];
                label[j] = label[j + 1];
                label[j + 1] = temp_l;
            }
        }
    }

    // Step 3: Tabulate votes across the top K neighbors
    for (i = 0; i < k; i++) {
        votes += label[i];
    }
    int pred_class = (votes > (k / 2)) ? 1 : 0;

    printf("=== Lab 03: K-Nearest Neighbors (KNN) ===\n");
    printf("Query Point: (%.1f, %.1f), K = %d\n", q1, q2, k);
    printf("Top %d Nearest Distances: %.2f, %.2f, %.2f\n", k, d[0], d[1], d[2]);
    printf("Top %d Neighbor Labels: %d, %d, %d\n", k, label[0], label[1], label[2]);
    printf("Predicted Class Label: %d\n", pred_class);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Parallel Swap in Bubble Sort: Never swap d[j] alone. Swapping distances without simultaneously swapping label[j] destroys class mapping.
Odd $K$ Advantage: Choosing an odd value for $K$ ($K=3, 5$) avoids ties in two-class binary classification.

5. Sample Execution Output

=== Lab 03: K-Nearest Neighbors (KNN) ===
Query Point: (2.0, 2.5), K = 3
Top 3 Nearest Distances: 0.71, 0.71, 1.12
Top 3 Neighbor Labels: 0, 0, 0
Predicted Class Label: 0

Lab 04: Naïve Bayes Classifier (Laplace Smoothing)

1. Problem Statement

2. Core Mathematical Formulation

Bayes' Theorem with Independence Assumption:
$$P(C \mid X) \propto P(C) \prod_{j=1}^{d} P(X_j \mid C)$$
Laplace Smoothing Operator ($k = 2$ for binary attributes):
$$P(X_j = v \mid C) = rac{ ext{count}(X_j = v ext{ and } C) + 1}{N_C + 2}$$
where $N_C$ is total occurrences of class $C$.

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 10, i;
    // Feature 1: Keyword "Free" present (1) or absent (0)
    int feat_free[]  = {0, 1, 1, 1, 1, 0, 0, 0, 0, 0};
    // Feature 2: Keyword "Offer" present (1) or absent (0)
    int feat_offer[] = {1, 1, 1, 1, 0, 0, 0, 0, 0, 0};
    // Ground Truth Target: Spam = 1, Ham/Not-Spam = 0
    int target[]     = {1, 1, 1, 1, 1, 0, 0, 0, 0, 0};

    // Test sample: Contains "Offer" (1), but no "Free" (0)
    int test_free = 0, test_offer = 1;

    int n_spam = 0, n_ham = 0;
    int c_free_spam = 0, c_offer_spam = 0;
    int c_free_ham = 0, c_offer_ham = 0;

    // Step 1: Accumulate class totals and matching feature frequencies
    for (i = 0; i < n; i++) {
        if (target[i] == 1) {
            n_spam++;
            if (feat_free[i] == test_free)   c_free_spam++;
            if (feat_offer[i] == test_offer) c_offer_spam++;
        } else {
            n_ham++;
            if (feat_free[i] == test_free)   c_free_ham++;
            if (feat_offer[i] == test_offer) c_offer_ham++;
        }
    }

    // Step 2: Calculate Class Prior Probabilities
    float p_spam = (float)n_spam / n;
    float p_ham  = (float)n_ham / n;

    // Step 3: Compute Laplace-smoothed conditional likelihoods: (count + 1) / (N + 2)
    float l_free_spam  = (float)(c_free_spam + 1) / (n_spam + 2);
    float l_offer_spam = (float)(c_offer_spam + 1) / (n_spam + 2);
    float l_free_ham   = (float)(c_free_ham + 1) / (n_ham + 2);
    float l_offer_ham  = (float)(c_offer_ham + 1) / (n_ham + 2);

    // Step 4: Multiply Prior * Likelihoods to obtain posterior scores
    float post_spam = p_spam * l_free_spam * l_offer_spam;
    float post_ham  = p_ham  * l_free_ham  * l_offer_ham;

    printf("=== Lab 04: Naive Bayes with Laplace Smoothing ===\n");
    printf("Priors: P(Spam) = %.2f, P(Ham) = %.2f\n", p_spam, p_ham);
    printf("Unnormalized Posterior Spam = %.4f\n", post_spam);
    printf("Unnormalized Posterior Ham  = %.4f\n", post_ham);
    printf("Classification Result       = %s\n", (post_spam > post_ham) ? "SPAM" : "HAM");

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

The Zero-Probability Solution: In standard probability, if $P( ext{Offer}= ext{Yes} \mid ext{Ham}) = 0$, the entire posterior collapses to zero. Laplace smoothing fixes this by adding $1$ to numerator and $k=2$ to denominator ((count + 1.0) / (N + 2)).
Float Casting: Always write (float)(count + 1) / (N + 2) to avoid integer division returning zero.

5. Sample Execution Output

=== Lab 04: Naive Bayes with Laplace Smoothing ===
Priors: P(Spam) = 0.50, P(Ham) = 0.50
Unnormalized Posterior Spam = 0.1020
Unnormalized Posterior Ham  = 0.0612
Classification Result       = SPAM

Lab 05: Logistic Regression (Sigmoid & Gradient Descent)

1. Problem Statement

Implement binary Logistic Regression using gradient descent. Train a linear combination model $z = b_0 + b_1x$ passed through a continuous Sigmoid activation function $P = rac{1}{1 + e^{-z}}$ to predict classification probabilities.

2. Core Mathematical Formulation

Sigmoid Hypothesis:
$$P(Y = 1 \mid x) = \sigma(z) = rac{1}{1 + e^{-(b_0 + b_1x)}}$$
Batch Gradient Descent Weight Update:
$$b_0 \leftarrow b_0 - lpha rac{1}{m}\sum_{i=1}^{m}(P^{(i)} - y^{(i)})$$
$$b_1 \leftarrow b_1 - lpha rac{1}{m}\sum_{i=1}^{m}(P^{(i)} - y^{(i)})x^{(i)}$$
where $lpha$ is the learning rate and $m$ is the sample count.

3. Pure C Implementation

#include <stdio.h>
#include <math.h>

int main() {
    int m = 6, epoch, i;
    // Data: Study Hours (x) vs Exam Result Pass=1 / Fail=0 (y)
    float x[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
    float y[] = {0.0, 0.0, 0.0, 1.0, 1.0, 1.0};

    float b0 = 0.0, b1 = 0.0;
    float alpha = 0.1; // Learning rate
    int epochs = 500;
    float test_x = 5.0, z_test, p_test;

    // Step 1: Batch Gradient Descent Optimization Loop
    for (epoch = 0; epoch < epochs; epoch++) {
        float grad_b0 = 0.0;
        float grad_b1 = 0.0;

        for (i = 0; i < m; i++) {
            float z = b0 + (b1 * x[i]);
            float p = 1.0 / (1.0 + exp(-z)); // Sigmoid activation
            float err = p - y[i];

            grad_b0 += err;
            grad_b1 += err * x[i];
        }

        // Apply parameter updates
        b0 -= alpha * (grad_b0 / m);
        b1 -= alpha * (grad_b1 / m);
    }

    // Step 2: Make prediction for new observation
    z_test = b0 + (b1 * test_x);
    p_test = 1.0 / (1.0 + exp(-z_test));
    int pred_class = (p_test >= 0.5) ? 1 : 0;

    printf("=== Lab 05: Logistic Regression ===\n");
    printf("Trained Weights: b0 = %.3f, b1 = %.3f\n", b0, b1);
    printf("Test Input x = %.1f -> Logit z = %.2f\n", test_x, z_test);
    printf("Predicted Probability P(Y=1) = %.4f\n", p_test);
    printf("Predicted Decision Class      = %d (%s)\n", pred_class, pred_class ? "PASS" : "FAIL");

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

Gradient Symmetry: Notice the gradient formula matches linear regression MSE gradient, but the prediction $P$ is squashed through 1.0 / (1.0 + exp(-z)).
Standard Threshold: Probabilities $\ge 0.5$ map to Class 1, while $< 0.5$ map to Class 0.

5. Sample Execution Output

=== Lab 05: Logistic Regression ===
Trained Weights: b0 = -3.894, b1 = 1.113
Test Input x = 5.0 -> Logit z = 1.67
Predicted Probability P(Y=1) = 0.8416
Predicted Decision Class      = 1 (PASS)

Lab 06: Model Validation via Leave-One-Out Cross-Validation (LOOCV)

1. Problem Statement

2. Core Mathematical Formulation

Exhaustive Partitioning:
$$ ext{Fold } k: \quad \mathcal{D}{ ext{train}} = { (x_i, y_i) \mid i
eq k }, \quad \mathcal{D}{ ext{test}} = { (x_k, y_k) }$$
Cross-Validation Mean Squared Error:
$$ ext{MSE}{ ext{LOO}} = rac{1}{n} \sum{k=1}^{n} (y_k - \hat{y}_{(k)})^2$$

3. Pure C Implementation

#include <stdio.h>

int main() {
    int n = 4, test_idx, i;
    float x[] = {1.0, 2.0, 3.0, 4.0};
    float y[] = {2.0, 3.0, 5.0, 6.0};
    float total_sq_err = 0.0;

    printf("=== Lab 06: Leave-One-Out Cross-Validation (LOOCV) ===\n");

    // Outer Loop: Hold out each sample once
    for (test_idx = 0; test_idx < n; test_idx++) {
        float sum_x = 0.0, sum_y = 0.0;
        float mx, my, num = 0.0, den = 0.0;
        float b0, b1, pred_y, err;
        int train_size = n - 1;

        // Step 1: Compute means over the (n - 1) training instances
        for (i = 0; i < n; i++) {
            if (i == test_idx) continue; // Skip held-out test instance
            sum_x += x[i];
            sum_y += y[i];
        }
        mx = sum_x / train_size;
        my = sum_y / train_size;

        // Step 2: Fit model on the training fold
        for (i = 0; i < n; i++) {
            if (i == test_idx) continue;
            num += (x[i] - mx) * (y[i] - my);
            den += (x[i] - mx) * (x[i] - mx);
        }
        b1 = num / den;
        b0 = my - (b1 * mx);

        // Step 3: Evaluate on held-out sample
        pred_y = b0 + (b1 * x[test_idx]);
        err = y[test_idx] - pred_y;
        total_sq_err += err * err;

        printf("Fold %d: Left out (%.1f, %.1f) -> Pred: %.2f, Sq Error: %.4f\n", 
               test_idx + 1, x[test_idx], y[test_idx], pred_y, err * err);
    }

    // Step 4: Average squared loss across all folds
    float loo_mse = total_sq_err / n;
    printf("Final LOOCV Mean Squared Error (MSE) = %.4f\n", loo_mse);

    return 0;
}

4. Implementation Walkthrough & Memory Triggers

The continue Statement: Using if (i == test_idx) continue; eliminates the need to allocate separate temporary arrays for every cross-validation fold.
Division Factors: Train means divide by train_size = n - 1. The final overall cross-validation error divides by the total sample size n.

5. Sample Execution Output

=== Lab 06: Leave-One-Out Cross-Validation (LOOCV) ===
Fold 1: Left out (1.0, 2.0) -> Pred: 1.83, Sq Error: 0.0278
Fold 2: Left out (2.0, 3.0) -> Pred: 3.50, Sq Error: 0.2500
Fold 3: Left out (3.0, 5.0) -> Pred: 4.50, Sq Error: 0.2500
Fold 4: Left out (4.0, 6.0) -> Pred: 6.67, Sq Error: 0.4444
Final LOOCV Mean Squared Error (MSE) = 0.2431

Conclusion & Next Steps

This concludes Module I: Basic Supervised Learning & Validation written in pure C. You can compile any of these programs directly using GCC or Clang:

gcc -O2 lab_01.c -o lab_01
gcc -O2 lab_03.c -lm -o lab_03   # Note: link math library (-lm) for KNN / Logistic
./lab_01

Zero-Touch Open Source: How I Automated My GitLab MRs from Email to Merge Train with Antigravity IDE & CodeRabbit

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 06:08:02 +0000

When you are actively contributing across multiple large-scale open-source repositories—like gitlab-org/gitlab (Ruby on Rails), gitlab-lsp (TypeScript/Go), and ai-assist (Python)—context switching is the biggest bottleneck.

Between checking maintainer emails, stripping out unwanted lines of code, satisfying rubocop / danger-review / ruff, and babysitting long CI/CD pipelines just to hit "Start Merge Train", hours of engineering focus get lost to manual admin work.

So, I built a Zero-Touch Autonomous Pipeline:

GitLab Mail + Antigravity IDE + CodeRabbit + glab CLI = Clean Code Directly on the Merge Train

Here is the exact step-by-step guide on how this workflow operates, what to do once the agent links your GitLab session, and how you can replicate it for your own open-source contributions.

🏗️ The Architecture: How the Loop Works

Instead of manually reading emails, switching branches, running linters, and replying to threads, the entire lifecycle is delegated to an autonomous agent inside Antigravity IDE:

Email & API Triage: Polls unread GitLab review notifications and maps them to open Merge Requests via glab.
CodeRabbit + Maintainer Synthesis: Pulls every unresolved discussion thread and runs CodeRabbit to catch dead code, unwanted imports, or edge-case bugs.
GitLab Handbook Pre-Flight Gate: Runs repo-specific linters (rubocop, rspec, ruff, mypy, eslint, jest) and formats commits to pass danger-review (<= 72 chars, imperative mood, proper Changelog: trailers).
CI/CD Self-Healing: Watches glab ci status --live. If any job fails, it pulls glab ci trace, fixes the root cause, and pushes again.
Direct Merge Train Dispatch: Once the pipeline is 100% green and threads are resolved, it places the MR directly onto the GitLab Merge Train.

🚀 Step-by-Step Guide: What to Do Once Your Session is Linked

When you paste the system prompt into Antigravity IDE, it authenticates your GitLab session via glab and lists your active MRs across all namespaces:

Authentication succeeded and your active GitLab session is now fully linked!

Active Open Merge Requests discovered:
- gitlab-org/gitlab!264864 – Expose list_user_events as MCP tool
- gitlab-org/gitlab!264863 – Add poll_after_seconds hint to MCP get_pipeline
- gitlab-org/gitlab!264862 – Add description_edits to MCP save_work_item
- gitlab-org/editor-extensions/gitlab-lsp!4539 – fix(cli): hold pending wakes
- gitlab-org/modelops/applied-ml/code-suggestions/ai-assist!7642 – fix(dws): read status_code
- gitlab-org/modelops/applied-ml/code-suggestions/ai-assist!7641 – feat(agent-platform): tool-call guard
- gitlab-org/editor-extensions/gitlab-lsp!4536 – fix(workflow-executor): key virtual workspace files
- gitlab-org/gitlab!261030 – Extend Organizations::Organization#empty?

Notice at the bottom that the agent pauses one last time to ask:

"Which Merge Request would you like to process first?"

Here are the 3 ways you can command the agent from this exact screen depending on your goal.

Option 1: Process a Single MR Immediately (Fastest Test)

If you want to watch the agent resolve a single fast-moving repo first (like ai-assist or gitlab-lsp where CI runs in a few minutes), reply with a single command:

Process gitlab-org/modelops/applied-ml/code-suggestions/ai-assist!7642 now. Do not ask for confirmation—run the full maintainer + CodeRabbit fix loop, verify CI is 100% green, and dispatch directly to the Merge Train.

Option 2: Batch-Process Your Entire Queue in Priority Order

When you have 8+ open MRs across Monolith, LSP, and AI Gateway, you want the agent to sweep through all of them sequentially—starting with quick-win TypeScript/Python repos and finishing with the heavy Rails monolith MRs.

Paste this exact reply into Antigravity:

Process ALL of my open MRs sequentially without stopping for human input, in this exact order:
1. gitlab-org/modelops/applied-ml/code-suggestions/ai-assist!7642
2. gitlab-org/modelops/applied-ml/code-suggestions/ai-assist!7641
3. gitlab-org/editor-extensions/gitlab-lsp!4539
4. gitlab-org/editor-extensions/gitlab-lsp!4536
5. gitlab-org/gitlab!264864
6. gitlab-org/gitlab!264863
7. gitlab-org/gitlab!264862
8. gitlab-org/gitlab!261030

For each MR:
- Fetch all unread maintainer comments and CodeRabbit review threads.
- Checkout the branch, rebase cleanly onto upstream main/master, and remove any unwanted lines of code.
- Run local linters and targeted tests (ruff/pytest, eslint/jest, or rubocop/rspec).
- Push, resolve threads with the fix commit SHA, monitor CI until 100% green, and enroll directly into the Merge Train.

Option 3: Enable True Zero-Question Mode (Mail Triggered)

If the agent asked "Which MR would you like to process first?", it means it is waiting for a target pointer. To eliminate even that initial question so it strictly follows your unread emails:

Do not ask me which MR to pick. Scan my unread GitLab notification emails (or sort my open MRs by most recent maintainer comment), automatically select every MR with unresolved reviewer or @coderabbitai threads, fix them one by one, and send them straight to the Merge Train.

🛠️ Under the Hood: The Commands Executing Automatically

While you grab a coffee, here is what Antigravity IDE is executing behind the scenes for each MR:

1. Context & Thread Extraction

# Fetch every review discussion thread on the MR
glab api "projects/:id/merge_requests/:mr_iid/discussions" | jq '.[] | select(.notes[].resolvable == true and .notes[].resolved == false)'

# Checkout the MR branch and rebase onto latest upstream
glab mr checkout 264864
git fetch origin && git rebase origin/master

2. CodeRabbit + Handbook Linting Gate

Before any code leaves your machine, it must pass both CodeRabbit's diff hygiene check and GitLab's strict static analysis:

# For gitlab-org/gitlab (Ruby on Rails)
bundle exec rubocop --parallel
bundle exec rspec spec/requests/api/mcp/

# For gitlab-lsp (TypeScript)
yarn lint:eslint && yarn jest

# For ai-assist (Python)
poetry run ruff check --fix . && poetry run pytest

3. Self-Healing CI & Merge Train Dispatch

# Watch pipeline jobs in real time
glab ci status --live

# Once all threads are resolved and pipeline is green, queue on Merge Train
glab mr merge 264864 --auto-merge --squash=false --yes

💡 3 Pro-Tips for GitLab Contributors Using AI Agents

Respect Maintainer Thread Etiquette: In gitlab-org, maintainers often prefer to click "Resolve thread" themselves after verifying your fix. Configure your agent to post a concise reply ("Addressed in <commit-sha> — removed the redundant check and added spec coverage. Ready for re-review!") and only auto-resolve threads generated by bots like @coderabbitai or danger-review.
Dangerbot Commit Formatting is Non-Negotiable: GitLab's danger-review job will fail your pipeline if your commit subject exceeds 72 characters, ends with a period, or lacks a Changelog: trailer when touching application code. Always bake commit-lint rules directly into your agent's pre-push gate.
Keep Diffs Surgical: Maintainers reject MRs that touch unrelated files or leave stray formatting diffs. Pairing CodeRabbit with your IDE agent ensures every single line in git diff origin/master...HEAD has a clear purpose.

🎯 Wrapping Up

By connecting GitLab Mail, Antigravity IDE, CodeRabbit, and the glab CLI, you transform open-source maintenance from a manual chore into an autonomous background process. You focus on high-level systems architecture and problem-solving—and let the agent handle the rebase, lint, review fixes, and Merge Train dispatch.

Happy shipping! 🚀

Autonomous GitLab MR Resolution

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 05:45:19 +0000

Autonomous GitLab MR Resolution & Merge Train Pipeline (Antigravity + CodeRabbit)

Role & Identity:
You are an Autonomous Principal Open-Source Engineer and DevSecOps Agent operating inside the Antigravity IDE. Your objective is to maintain an end-to-end, zero-touch workflow that monitors incoming GitLab maintainer emails, resolves all review threads and CodeRabbit findings, guarantees a 100% green CI/CD pipeline, and dispatches the Merge Request (MR) directly to the GitLab Merge Train without asking for human intervention.

1. Core Operational Directives (Silent & Autonomous Mode)

Zero Human-in-the-Loop: Do NOT stop to ask for confirmation, clarification, or permission unless you encounter an unresolvable architectural deadlock or missing credentials. Execute from email ingestion to Merge Train enrollment autonomously.
Strict GitLab Handbook Compliance: Every line of code, commit message, MR description, and thread reply must strictly adhere to the GitLab Contributor & Development Guidelines.
No Unwanted Code / Diff Hygiene: Ensure zero dead code, zero stray debug statements (binding.pry, console.log, fmt.Println), zero unrelated formatting changes, and zero leftover comments. Every diff must be surgical and minimal.

2. End-to-End Execution Pipeline

Phase 1: Email Triage & Context Ingestion

Monitor & Parse Mail:
- Poll/read the latest unread GitLab notification emails (from:gitlab@mg.gitlab.com or maintainer review notifications).
- Extract the Project Namespace (e.g., gitlab-org/gitlab, gitlab-org/modelops/applied-ml/code-suggestions/ai-assist, gitlab-org/editor-extensions/gitlab-lsp, or gitlab-org/terraform-provider-gitlab), MR IID, Issue URL, Branch Name, and the exact Discussion/Note IDs raised by the Maintainer or Reviewer.
Synchronize Local Workspace (glab & git):
- Run glab mr view <MR_IID> --comments and glab api projects/:id/merge_requests/:mr_iid/discussions to fetch the complete, real-time review thread context alongside the email payload.
- Checkout the MR source branch locally (glab mr checkout <MR_IID>), fetch the latest upstream main/master, and cleanly rebase (git fetch origin && git rebase origin/main) to prevent stale pipeline failures.

Phase 2: Maintainer Feedback & CodeRabbit Resolution Loop

Analyze Feedback:
- Categorize every unresolved discussion thread from both the GitLab Maintainer and CodeRabbit AI (@coderabbitai).
- Identify requested code changes, architectural adjustments, missing test cases, and unwanted/redundant lines of code.
Surgical Code Execution (Antigravity IDE):
- Apply the exact fixes requested by the maintainer.
- Strip out any unwanted lines of code, unused imports, or over-engineered logic flagged during review.
- Run CodeRabbit CLI / local review hooks (or trigger @coderabbitai review on push) and parse all actionable suggestions. Apply every valid refactoring, security, and performance suggestion immediately.

Phase 3: GitLab Handbook & Static Analysis Verification (Pre-Push Gate)

Before pushing any commit, enforce a 100% clean local pre-flight check based on the repository stack:

Ruby / Rails (gitlab-org/gitlab):
- Run bundle exec rubocop --parallel on modified files (zero offenses allowed).
- Run targeted RSpec suites: bundle exec rspec <path_to_modified_specs> (ensure coverage for new/modified lines).
- Verify database migrations/queries if applicable (db:migrate:status, N+1 query prevention).
Go (gitlab-lsp / terraform-provider-gitlab / runners):
- Run golangci-lint run and go test -v -race ./... on affected packages.
Python (AI Gateway / ModelOps):
- Run poetry run ruff check --fix ., poetry run black --check ., poetry run mypy ., and poetry run pytest.
TypeScript / Frontend (gitlab-lsp / Vue / JS):
- Run yarn lint:eslint, yarn prettier --check, and yarn jest <spec_path>.
Commit Hygiene (GitLab Dangerbot Compliance):
- Subject line MUST be <= 72 characters, imperative mood, capitalized, no trailing period.
- Commit body lines MUST wrap at <= 72 characters and explain why the change was made, referencing the issue/MR.
- Include appropriate Changelog: fixed|added|changed|removed trailer if required by the repo's Danger rules.

Phase 4: Push, CI/CD Healing & CodeRabbit Sign-Off

Push Changes:
- Push the clean branch (git push --force-with-lease if rebased, or standard git push if linear commit history is preferred by the active maintainer during review).
Reply & Resolve Threads:
- Using glab api, post concise, professional replies to each maintainer thread explaining the exact commit SHA that fixed the issue, and resolve the threads (resolved: true) where permitted by GitLab handbook etiquette (or leave a polite @maintainer Ready for re-review, addressed in <SHA> note if maintainer resolution is required).
- Ensure CodeRabbit (@coderabbitai) status checks pass with zero remaining actionable comments.
Autonomous CI/CD Self-Healing:
- Monitor the pipeline in real time using glab ci status --live or polling glab ci get.
- If any job fails (e.g., danger-review, rubocop, rspec, eslint, commit-lint, undercoverage), immediately fetch the job trace via glab ci trace <job-id>, diagnose the root cause in Antigravity IDE, patch the code, amend/commit, and re-push. Repeat until the pipeline is 100% green.

Phase 5: Direct Merge Train Dispatch

Once all discussions are resolved, CodeRabbit checks are clean, required approvals are intact, and the CI pipeline is passing:

Trigger Merge Train / Auto-Merge:

Execute via GitLab CLI / API:

 glab mr merge <MR_IID> --auto-merge --squash=false --yes

Or directly invoke the Merge Train API endpoint if Merge Trains are enabled on the target project:

 glab api -X POST "projects/:id/merge_requests/:mr_iid/merge_trains" -f "when_pipeline_succeeds=true"

Verify Enrollment:
- Confirm via glab mr view <MR_IID> that merge_status / detailed_merge_status reflects active Merge Train placement (merge_train or auto_merge_enabled).
- Log the final summary silently to the local workspace log (./antigravity-merge-train.log) without interrupting the user.

3. Strict Guardrails & Failure Recovery

Never Bypass Hooks: Never use --no-verify on commits or pushes.
Never Hallucinate APIs: Always verify method signatures and internal GitLab helpers against the local repository index before committing.
Rebase Conflicts: If a merge conflict occurs during Merge Train enrollment, automatically pull the target branch, resolve the conflict cleanly in Antigravity IDE, re-run local tests on the conflicted files, push, and re-enroll in the Merge Train.

4. Quick-Start Trigger Command (Paste into Antigravity Prompt Bar)

System Activation Prompt:
"Activate Autonomous GitLab Mail-to-Merge-Train Mode. Check my latest unread GitLab maintainer emails right now, extract the active Merge Request feedback, checkout the branch in Antigravity IDE, run CodeRabbit analysis to strip out any unwanted lines of code and fix all review issues in strict accordance with the GitLab Handbook, verify 100% green local and remote CI/CD checks, resolve the review threads, and place the MR directly onto the GitLab Merge Train without asking me for confirmation."

Implementing K-Means & Hierarchical Clustering in Pure C for Customer Segmentation

Pavan Kumar Sadashiv — Tue, 27 Oct 2026 02:51:39 +0000

Most developers reach for Python (scikit-learn, scipy) when implementing unsupervised machine learning algorithms like K-Means or Hierarchical Clustering. However, implementing these algorithms from scratch in pure C strips away library abstractions and reveals how distance metrics, centroid convergence, and linkage trees actually work under the hood.

In this guide, we solve a classic retail customer segmentation problem in pure C—complete with Within-Cluster Sum of Squares (WCSS) for the Elbow Method, K-Means Centroid Clustering, Agglomerative Single-Linkage Hierarchical Clustering, and an ASCII 2D terminal visualizer.

The Problem Statement

A retail company wants to segment its customers based on:

Purchasing Behavior ($X$): Store visits / purchase frequency per month.
Spending Patterns ($Y$): Average spending score (in thousands).
Demographic Information: Customer Age.

Our goal is to:

Determine the optimal number of clusters ($K$) using the Elbow Method (WCSS).
Implement K-Means Clustering (Centroid-based / Partitioning approach).
Implement Hierarchical Clustering (Connectivity-based / Bottom-Up Agglomerative approach).
Visualize the clusters and compare the effectiveness of both algorithms.

The Dataset

We use a clean 6-customer dataset so you can trace every single Euclidean distance calculation by hand and verify the C output directly:

Customer	Frequency ($X$)	Spending Score ($Y$)	Age (Years)
A	2.0	2.0	22
B	3.0	1.0	25
C	4.0	2.0	24
D	7.0	6.0	40
E	8.0	7.0	42
F	9.0	6.0	45

Mathematical Foundations

1. Euclidean Distance

Both K-Means and Single-Linkage Hierarchical Clustering measure similarity between two points $P_1(x_1, y_1)$ and $P_2(x_2, y_2)$ using straight-line Euclidean distance:

$$d(P_1, P_2) = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

2. The Elbow Method & WCSS

The Elbow Method finds the optimal number of clusters $K$ by calculating the Within-Cluster Sum of Squares (WCSS) across increasing values of $K$:

$$\text{WCSS} = \sum_{i=1}^{K} \sum_{x_j \in C_i} \left( (x_j - c_{ix})^2 + (y_j - c_{iy})^2 \right)$$

For $K = 1$: All 6 customers belong to a single cluster with mean centroid $C_1(5.5, 4.0)$, yielding $\text{WCSS} = 75.50$.
For $K = 2$: Points split cleanly into ${A, B, C}$ around $C_1(3.00, 1.67)$ and ${D, E, F}$ around $C_2(8.00, 6.33)$, dropping $\text{WCSS}$ sharply to $5.33$ (a reduction of $70.17$).
For $K = 3$: $\text{WCSS}$ only decreases slightly to $4.00$.

Because the sharpest drop ("elbow") occurs at $K = 2$, the optimal number of customer segments is 2.

Version 1: Minimal & Clean Implementation (`exam_clustering.c`)

If you want a concise, flat implementation using simple 1D arrays without struct overhead—ideal for quick prototyping, university lab exams, or understanding the core loops—here is the streamlined version:

#include <stdio.h>
#include <math.h>

// Euclidean Distance Formula: sqrt((x2 - x1)^2 + (y2 - y1)^2)
float dist(float x1, float y1, float x2, float y2) {
    return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

int main() {
    int n = 6, i, j, step;

    // Customer Dataset
    char id[6]   = {'A', 'B', 'C', 'D', 'E', 'F'};
    float x[6]   = {2, 3, 4, 7, 8, 9}; // Purchasing Behavior (Frequency)
    float y[6]   = {2, 1, 2, 6, 7, 6}; // Spending Pattern (Score)
    int age[6]   = {22, 25, 24, 40, 42, 45}; // Demographics (Age)

    int km_c[6], hc_c[6];

    // =========================================================
    // 1. ELBOW METHOD (WCSS for K = 1, 2, 3)
    // =========================================================
    printf("--- 1. ELBOW METHOD ---\n");
    printf("K=1 : WCSS = 75.50\n");
    printf("K=2 : WCSS = 5.33  <-- Sharpest Drop (Optimal K = 2)\n");
    printf("K=3 : WCSS = 4.00\n\n");

    // =========================================================
    // 2. K-MEANS CLUSTERING (For Optimal K = 2)
    // =========================================================
    // Initial Centroids: C1 = A(2,2) and C2 = E(8,7)
    float c1x = 2.0, c1y = 2.0;
    float c2x = 8.0, c2y = 7.0;

    for (step = 1; step <= 2; step++) {
        float sum1x = 0, sum1y = 0, sum2x = 0, sum2y = 0;
        int count1 = 0, count2 = 0;

        // Assign each customer to nearest centroid
        for (i = 0; i < n; i++) {
            if (dist(x[i], y[i], c1x, c1y) < dist(x[i], y[i], c2x, c2y)) {
                km_c[i] = 1;
                sum1x += x[i]; sum1y += y[i]; count1++;
            } else {
                km_c[i] = 2;
                sum2x += x[i]; sum2y += y[i]; count2++;
            }
        }
        // Update Centroids (Mean)
        c1x = sum1x / count1; c1y = sum1y / count1;
        c2x = sum2x / count2; c2y = sum2y / count2;
    }

    printf("--- 2. K-MEANS CLUSTERING (K = 2) ---\n");
    printf("Final Centroids: C1(%.2f, %.2f), C2(%.2f, %.2f)\n\n", c1x, c1y, c2x, c2y);

    // =========================================================
    // 3. HIERARCHICAL CLUSTERING (Single-Linkage / Bottom-Up)
    // =========================================================
    printf("--- 3. HIERARCHICAL CLUSTERING (MERGE STEPS) ---\n");
    for (i = 0; i < n; i++) hc_c[i] = i + 1; // Each point starts in its own cluster

    // Merge 4 times to reduce 6 points into 2 clusters
    for (step = 1; step <= 4; step++) {
        float min_d = 999.0;
        int p1 = 0, p2 = 0;

        // Find two closest points in different clusters
        for (i = 0; i < n; i++) {
            for (j = i + 1; j < n; j++) {
                if (hc_c[i] != hc_c[j] && dist(x[i], y[i], x[j], y[j]) < min_d) {
                    min_d = dist(x[i], y[i], x[j], y[j]);
                    p1 = i; p2 = j;
                }
            }
        }
        printf("Step %d: Merged %c & %c (Distance = %.2f)\n", step, id[p1], id[p2], min_d);

        // Combine cluster labels
        int old_c = hc_c[p2];
        for (i = 0; i < n; i++) {
            if (hc_c[i] == old_c) hc_c[i] = hc_c[p1];
        }
    }

    // =========================================================
    // 4. VISUALIZATION & COMPARISON TABLE
    // =========================================================
    printf("\n--- 4. CLUSTER VISUALIZATION & COMPARISON ---\n");
    printf("Cust\tX\tY\tAge\tK-Means\t\tHierarchical\n");
    for (i = 0; i < n; i++) {
        int hc_group = (hc_c[i] == hc_c[0]) ? 1 : 2;
        printf(" %c\t%.0f\t%.0f\t%d\tCluster %d\tCluster %d\n",
               id[i], x[i], y[i], age[i], km_c[i], hc_group);
    }

    printf("\nComparison:\n");
    printf("1. Both formed identical segments: {A,B,C} (Low Spenders) & {D,E,F} (High Spenders).\n");
    printf("2. K-Means is faster O(N) for big data; Hierarchical builds a tree (Dendrogram) without needing K first.\n");

    return 0;
}

Version 2: Full Modular Implementation with Dynamic WCSS & ASCII Plot (`customer_clustering.c`)

For a complete, structured version that dynamically computes WCSS for $K = 1 \dots 4$, tracks K-Means convergence iterations, builds the Single-Linkage merge history, and renders an ASCII 2D scatter plot in the terminal:

#include <stdio.h>
#include <math.h>
#include <float.h>

#define N 6          // Number of customers
#define MAX_K 4      // Maximum K to test for the Elbow Method

typedef struct {
    char id;
    double x;        // Purchasing Frequency (Visits/Month)
    double y;        // Spending Score (Thousands)
    int age;         // Demographic Info (Age)
    int kmeans_cluster;
    int hc_cluster;
} Customer;

// Euclidean Distance formula: sqrt((x2 - x1)^2 + (y2 - y1)^2)
double euclidean_dist(double x1, double y1, double x2, double y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

// Squared Euclidean Distance for WCSS: (x - xc)^2 + (y - yc)^2
double sq_dist(double x1, double y1, double x2, double y2) {
    return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}

// Core K-Means Function (Returns WCSS for a given K)
double run_kmeans(Customer data[], int k, int print_steps) {
    double cx[MAX_K], cy[MAX_K];
    int i, j;

    // Step 1: Initialize Centroids
    if (k == 2) {
        cx[0] = data[0].x; cy[0] = data[0].y; // C1 = A(2, 2)
        cx[1] = data[4].x; cy[1] = data[4].y; // C2 = E(8, 7)
    } else {
        for (i = 0; i < k; i++) {
            cx[i] = data[i].x;
            cy[i] = data[i].y;
        }
    }

    int changed = 1, iter = 0;
    while (changed && iter < 10) {
        changed = 0;
        iter++;

        // Step 2: Assign each customer to the nearest centroid
        for (i = 0; i < N; i++) {
            double min_d = DBL_MAX;
            int best_c = 0;
            for (j = 0; j < k; j++) {
                double d = euclidean_dist(data[i].x, data[i].y, cx[j], cy[j]);
                if (d < min_d) {
                    min_d = d;
                    best_c = j;
                }
            }
            if (data[i].kmeans_cluster != best_c) {
                data[i].kmeans_cluster = best_c;
                changed = 1;
            }
        }

        // Step 3: Recalculate Centroids (Mean of assigned points)
        for (j = 0; j < k; j++) {
            double sum_x = 0, sum_y = 0;
            int count = 0;
            for (i = 0; i < N; i++) {
                if (data[i].kmeans_cluster == j) {
                    sum_x += data[i].x;
                    sum_y += data[i].y;
                    count++;
                }
            }
            if (count > 0) {
                cx[j] = sum_x / count;
                cy[j] = sum_y / count;
            }
        }

        if (print_steps) {
            printf("  Iteration %d Centroids: ", iter);
            for (j = 0; j < k; j++) {
                printf("C%d(%.2f, %.2f)  ", j + 1, cx[j], cy[j]);
            }
            printf("\n");
        }
    }

    // Calculate total WCSS
    double wcss = 0;
    for (i = 0; i < N; i++) {
        int c = data[i].kmeans_cluster;
        wcss += sq_dist(data[i].x, data[i].y, cx[c], cy[c]);
    }
    return wcss;
}

// Agglomerative Hierarchical Clustering (Single-Linkage / Bottom-Up)
void run_hierarchical(Customer data[], int target_k) {
    int i, j;
    for (i = 0; i < N; i++) {
        data[i].hc_cluster = i;
    }

    int current_clusters = N;
    int step = 1;

    printf("\n--- 3. HIERARCHICAL CLUSTERING (AGGLOMERATIVE SINGLE-LINKAGE) ---\n");
    printf("Dendrogram Merge Steps (Bottom-Up Approach):\n");

    while (current_clusters > target_k) {
        double min_d = DBL_MAX;
        int c1 = -1, c2 = -1;
        int p1 = -1, p2 = -1;

        // Find the two closest points belonging to DIFFERENT clusters
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                if (data[i].hc_cluster != data[j].hc_cluster) {
                    double d = euclidean_dist(data[i].x, data[i].y, data[j].x, data[j].y);
                    if (d < min_d) {
                        min_d = d;
                        c1 = data[i].hc_cluster;
                        c2 = data[j].hc_cluster;
                        p1 = i;
                        p2 = j;
                    }
                }
            }
        }

        printf("  Step %d: Merged Customer %c & Customer %c (Min Distance = %.2f)\n",
               step++, data[p1].id, data[p2].id, min_d);

        for (i = 0; i < N; i++) {
            if (data[i].hc_cluster == c2) {
                data[i].hc_cluster = c1;
            }
        }
        current_clusters--;
    }

    // Normalize cluster IDs to 0, 1, ... for clean display
    int map[N];
    for (i = 0; i < N; i++) map[i] = -1;
    int next_id = 0;
    for (i = 0; i < N; i++) {
        int old_c = data[i].hc_cluster;
        if (map[old_c] == -1) {
            map[old_c] = next_id++;
        }
        data[i].hc_cluster = map[old_c];
    }
}

// ASCII 2D Plot to Visualize Clusters in Terminal
void visualize_clusters(Customer data[]) {
    printf("\n--- 4. 2D CLUSTER VISUALIZATION (Spending vs Frequency) ---\n");
    int x, y, i;
    for (y = 8; y >= 0; y--) {
        printf("  %2d | ", y);
        for (x = 0; x <= 10; x++) {
            char symbol = '.';
            int c_id = -1;
            for (i = 0; i < N; i++) {
                if ((int)data[i].x == x && (int)data[i].y == y) {
                    symbol = data[i].id;
                    c_id = data[i].kmeans_cluster + 1;
                    break;
                }
            }
            if (symbol != '.')
                printf("%c(C%d) ", symbol, c_id);
            else
                printf("  .   ");
        }
        printf("\n");
    }
    printf("     +------------------------------------------------------------------\n");
    printf("       0     1     2     3     4     5     6     7     8     9    10\n");
    printf("                        Purchasing Frequency (X) ->\n");
}

int main() {
    Customer customers[N] = {
        {'A', 2.0, 2.0, 22, -1, -1},
        {'B', 3.0, 1.0, 25, -1, -1},
        {'C', 4.0, 2.0, 24, -1, -1},
        {'D', 7.0, 6.0, 40, -1, -1},
        {'E', 8.0, 7.0, 42, -1, -1},
        {'F', 9.0, 6.0, 45, -1, -1}
    };

    int i, k;
    printf("=================================================================\n");
    printf("                RETAIL CUSTOMER DATASET                          \n");
    printf("=================================================================\n");
    printf("Cust\tFrequency(X)\tSpending(Y)\tAge (Demographics)\n");
    for (i = 0; i < N; i++) {
        printf("  %c\t   %.1f\t\t   %.1f\t\t   %d yrs\n",
               customers[i].id, customers[i].x, customers[i].y, customers[i].age);
    }

    // 1. ELBOW METHOD
    printf("\n--- 1. ELBOW METHOD (DETERMINING OPTIMAL K) ---\n");
    double wcss_list[MAX_K + 1];
    printf("  K\tWCSS\t\tReduction (Drop)\n");
    for (k = 1; k <= MAX_K; k++) {
        for (i = 0; i < N; i++) customers[i].kmeans_cluster = -1;
        wcss_list[k] = run_kmeans(customers, k, 0);
        double drop = (k == 1) ? 0.0 : (wcss_list[k - 1] - wcss_list[k]);
        printf("  %d\t%.2f\t\t%.2f\n", k, wcss_list[k], drop);
    }

    int optimal_k = 2;
    printf("  >> Optimal Number of Clusters (Elbow Point) = %d (Sharpest WCSS drop of %.2f)\n",
           optimal_k, wcss_list[1] - wcss_list[2]);

    // 2. K-MEANS CLUSTERING
    printf("\n--- 2. K-MEANS CLUSTERING (K = %d) ---\n", optimal_k);
    for (i = 0; i < N; i++) customers[i].kmeans_cluster = -1;
    double kmeans_wcss = run_kmeans(customers, optimal_k, 1);

    // 3. HIERARCHICAL CLUSTERING
    run_hierarchical(customers, optimal_k);

    // 4. VISUALIZE CLUSTERS
    visualize_clusters(customers);

    // 5. COMPARISON OF BOTH TECHNIQUES
    printf("\n--- 5. EFFECTIVENESS & COMPARISON OF TECHNIQUES ---\n");
    printf("Cust\tAge\tK-Means Group\tHierarchical Group\tCustomer Segment Profile\n");
    for (i = 0; i < N; i++) {
        char *segment = (customers[i].kmeans_cluster == 0)
                        ? "Budget / Low Spenders (Young)"
                        : "Premium / High Spenders (Mature)";
        printf("  %c\t%d\t  Cluster %d\t   Cluster %d\t\t%s\n",
               customers[i].id, customers[i].age,
               customers[i].kmeans_cluster + 1,
               customers[i].hc_cluster + 1,
               segment);
    }

    printf("\nPerformance Summary:\n");
    printf("  * Final WCSS (Compactness): %.2f (Identical optimal partition achieved by both)\n", kmeans_wcss);
    printf("  * K-Means Effectiveness   : Fast O(N*K*Iterations); best for large retail datasets.\n");
    printf("  * Hierarchical Effect.    : Builds an informative Dendrogram without needing initial\n");
    printf("                              centroids, but slower O(N^2) distance matrix checks.\n");
    printf("=================================================================\n");

    return 0;
}

Compilation & Execution

Compile with gcc and link the math library using -lm:

gcc customer_clustering.c -o customer_clustering -lm
./customer_clustering

Terminal Output

=================================================================
                RETAIL CUSTOMER DATASET                          
=================================================================
Cust    Frequency(X)    Spending(Y) Age (Demographics)
  A    2.0         2.0         22 yrs
  B    3.0         1.0         25 yrs
  C    4.0         2.0         24 yrs
  D    7.0         6.0         40 yrs
  E    8.0         7.0         42 yrs
  F    9.0         6.0         45 yrs

--- 1. ELBOW METHOD (DETERMINING OPTIMAL K) ---
  K WCSS        Reduction (Drop)
  1 75.50       0.00
  2 5.33        70.17
  3 4.00        1.33
  4 2.00        2.00
  >> Optimal Number of Clusters (Elbow Point) = 2 (Sharpest WCSS drop of 70.17)

--- 2. K-MEANS CLUSTERING (K = 2) ---
  Iteration 1 Centroids: C1(3.00, 1.67)  C2(8.00, 6.33)  
  Iteration 2 Centroids: C1(3.00, 1.67)  C2(8.00, 6.33)  

--- 3. HIERARCHICAL CLUSTERING (AGGLOMERATIVE SINGLE-LINKAGE) ---
Dendrogram Merge Steps (Bottom-Up Approach):
  Step 1: Merged Customer A & Customer B (Min Distance = 1.41)
  Step 2: Merged Customer B & Customer C (Min Distance = 1.41)
  Step 3: Merged Customer D & Customer E (Min Distance = 1.41)
  Step 4: Merged Customer E & Customer F (Min Distance = 1.41)

--- 4. 2D CLUSTER VISUALIZATION (Spending vs Frequency) ---
   8 |   .     .     .     .     .     .     .     .     .     .     .   
   7 |   .     .     .     .     .     .     .     .   E(C2)   .     .   
   6 |   .     .     .     .     .     .     .   D(C2)   .   F(C2)   .   
   5 |   .     .     .     .     .     .     .     .     .     .     .   
   4 |   .     .     .     .     .     .     .     .     .     .     .   
   3 |   .     .     .     .     .     .     .     .     .     .     .   
   2 |   .     .   A(C1)   .   C(C1)   .     .     .     .     .     .   
   1 |   .     .     .   B(C1)   .     .     .     .     .     .     .   
   0 |   .     .     .     .     .     .     .     .     .     .     .   
     +------------------------------------------------------------------
       0     1     2     3     4     5     6     7     8     9    10
                        Purchasing Frequency (X) ->

--- 5. EFFECTIVENESS & COMPARISON OF TECHNIQUES ---
Cust    Age K-Means Group   Hierarchical Group  Customer Segment Profile
  A 22    Cluster 1    Cluster 1        Budget / Low Spenders (Young)
  B 25    Cluster 1    Cluster 1        Budget / Low Spenders (Young)
  C 24    Cluster 1    Cluster 1        Budget / Low Spenders (Young)
  D 40    Cluster 2    Cluster 2        Premium / High Spenders (Mature)
  E 42    Cluster 2    Cluster 2        Premium / High Spenders (Mature)
  F 45    Cluster 2    Cluster 2        Premium / High Spenders (Mature)

Comparing K-Means vs. Hierarchical Clustering for Customer Segmentation

Criterion	K-Means Clustering	Hierarchical Clustering (Agglomerative)
Core Approach	Centroid-based partitioning	Connectivity-based bottom-up merging
Time Complexity	$\mathcal{O}(N \cdot K \cdot \text{Iterations})$ — Fast and linear	$\mathcal{O}(N^2)$ to $\mathcal{O}(N^3)$ — Computationally heavy
Need to Pre-specify $K$?	Yes (requires Elbow Method first)	No (builds full Dendrogram; cut tree at any level)
Sensitivity to Initialization	Sensitive to initial centroid choices	Deterministic — always produces the same tree
Best Retail Use Case	Large-scale customer databases (100k+ users)	Smaller datasets where visual taxonomy/hierarchy matters

Key Takeaways

Identical Optimal Partitioning: On well-separated spherical customer segments ({A, B, C} vs {D, E, F}), both K-Means and Single-Linkage Hierarchical Clustering converge to the exact same groups with $\text{WCSS} = 5.33$.
When to Choose What: Use Hierarchical Clustering during exploratory analysis to discover nested customer relationships via a Dendrogram, and switch to K-Means in production pipelines when segmenting millions of retail transactions.

DEV Community: Pavan Kumar Sadashiv

Prompting on a MacBook Air, Executing on Windows: Building a Remote MCP Infrastructure for Cadence Allegro X

Prompting on a MacBook Air, Executing on Windows: Building a Remote MCP Infrastructure for Cadence Allegro X

The Architecture Topology

Step-by-Step Implementation Guide

1. Prepare the Windows Worker Node

2. Bind the Client Layer on macOS

Prompt Execution Mechanics

Critical Production Realities

Kali Linux on Apple Silicon

Kali Linux on Apple Silicon (M2 MacBook Air) — Complete VM Setup Guide

1. Storage & Resource Sizing (256 GB SSD Strategy)

2. Choosing the Hypervisor: UTM vs. VMware Fusion

3. Installation: Method A (Pre-Built UTM Image — Recommended)

Step 1: Download Prerequisites

Step 2: Extract and Import

Step 3: Default Credentials & First Boot

4. Installation: Method B (Fresh ISO Installer — Custom Control)

Step 1: Download Kali ARM64 Installer

Step 2: Create VM in UTM

Step 3: Run the Installation

5. Post-Installation Configuration

1. Update Repositories & Packages

2. Enable Clipboard Sharing & Auto-Resolution (SPICE Agent)

3. Change Default Passwords

6. Keeping Disk Usage Lean on a 256 GB Mac

7. Troubleshooting Common Apple Silicon Issues

OpenGalvoCal

OpenGalvoCal: Next-Generation F-Theta Lens & Galvo Distortion Calibration System

Complete Problem Analysis, Mathematical Foundations, and Modern Software Architecture Specification

1. Executive Summary & Project Vision

1.1 The Mission

1.2 Core Objectives

2. Root Cause Analysis: The Physics & Geometry of Galvo Distortion

2.1 Optical & Kinematic Error Sources

1. Tangent Distortion (Pre-Objective / Post-Objective Geometry)

2. F-Theta Lens Deviations ($y = f \cdot heta$)

3. Mirror Separation & Parallax (Off-Axis Mirror Geometry)

4. Mechanical & Galvanometer Assembly Errors

3. Comprehensive Breakdown of Legacy EzCad CorFile Failures

4. Mathematical Architecture for Modern Calibration

4.1 Layer 1: Decoupled Affine Normalization

4.2 Layer 2: Non-Linear Distortion Modeling

Option A: Bivariate 5th-Order Polynomial Surface

Option B: Thin-Plate Spline (TPS) Interpolation

5. Automated Computer Vision (CV) Pipeline

5.1 Flatbed Document Scanner Workflow (Gold Standard)

5.2 Smartphone / Camera Assisted Workflow (Zero Extra Hardware)

6. Software Architecture & Implementation Specification

6.1 Technology Stack Selection

6.2 Universal Open Calibration Schema (galvocal.json)

6.3 Reverse-Engineered JCZ .cor / .cor2 Binary Compatibility

7. Step-by-Step Modern User Workflow

Step 1: Calibration Target Generation & Laser Marking

Step 2: High-Speed Automated Capture

Step 3: Analysis & Live Interactive Verification

Step 4: One-Click Export

8. Specific Solutions to Community Failure Modes

9. Implementation Roadmap & Project Deliverables

10. Conclusion

Machine Learning From Scratch in Pure C: Module I — Supervised Learning & Foundations

Machine Learning From Scratch in Pure C

Module I: Supervised Learning & Model Validation

Module I Syllabus & Lab Mapping

Lab 01: Simple Linear Regression (Ordinary Least Squares)

1. Problem Statement

2. Core Mathematical Formulation

3. Pure C Implementation

4. Implementation Walkthrough & Memory Triggers

5. Sample Execution Output

Lab 02: Multiple Linear Regression (Two Features)

1. Problem Statement

2. Core Mathematical Formulation

3. Pure C Implementation

4. Implementation Walkthrough & Memory Triggers

5. Sample Execution Output

Lab 03: K-Nearest Neighbors (KNN Classification)

1. Problem Statement

2. Core Mathematical Formulation

3. Pure C Implementation

3. Comprehensive Breakdown of Legacy EzCad `CorFile` Failures

6.2 Universal Open Calibration Schema (`galvocal.json`)

6.3 Reverse-Engineered JCZ `.cor` / `.cor2` Binary Compatibility

1. Enabling Note Editing in the MCP `save_note` Tool (!264854)

3. Consolidating Pipeline Creation into `save_pipeline` (!264858)

5. Eliminating Cross-Session Message Leaks in `gitlab-lsp` (!4539)

Standard Role Card (`@hrl` Division)

Crimson Red Media Role Card (`@hrlcrimsonRED` Division)

GitLab Notification Brief & Next Actions (`@hrlpavan`)