Software Engineering for Analytics, Data Science and AI Engineering

Pingala | Numerics

May 31, 2026

Contents

1 Overview 1

2 Month 1: Advanced Python & Vectorized Thinking 1

2.1 Week 1: Data Structures Under the Hood . . . . . . . . . . . . . . . . . . . . . . . . 1

2.2 Week 2: Functions, Closures, and Variable Scopes . . . . . . . . . . . . . . . . . . . . 1

2.3 Week 3: Object References and Garbage Collection . . . . . . . . . . . . . . . . . . . 2

2.4 Week 4: Capstone — The NumPy Paradigm Shift . . . . . . . . . . . . . . . . . . . 2

3 Month 2: Pure Functional Accelerated Computing (JAX) 2

3.1 Week 5: Introduction to Functional Math Purity . . . . . . . . . . . . . . . . . . . . 2

3.2 Week 6: Automatic Differentiation & Gradient Tracing . . . . . . . . . . . . . . . . . 2

3.3 Week 7: JIT Compiling and Vectorized Mapping . . . . . . . . . . . . . . . . . . . . 2

3.4 Week 8: Capstone — Stateless Neural Engine . . . . . . . . . . . . . . . . . . . . . . 3

4 Month 3: Multiple Dispatch (Julia) & System Architecture (DDD) 3

4.1 Week 9: Thinking in Types and Multiple Dispatch . . . . . . . . . . . . . . . . . . . 3

4.2 Week 10: Writing C-Speed Math in Julia . . . . . . . . . . . . . . . . . . . . . . . . . 3

4.3 Week 11: Domain-Driven Design Fundamentals . . . . . . . . . . . . . . . . . . . . . 3

4.4 Week 12: Final Capstone — The Production Architect . . . . . . . . . . . . . . . . . 4

5 Development Environment Setup 4

DS Python Curriculum

Overview

This 3-month curriculum turns the programming track of your master roadmap into daily, actionable targets. It assumes a dedication of roughly 10 to 12 hours per week and completely bypasses basic syntax, focusing entirely on native mastery, functional compiling, high-performance execution and system architecture.

Month 1:

Advanced Python & Vectorized Thinking

Goal: Transition from basic loops to elite, idiomatic Python code and vector spaces.

2.1 Week 1: Data Structures Under the Hood

• Reading: Fluent Python (Chapters 1, 2 & 3).

• Theory Focus: Understand the Python Object Model, the performance costs of mutable vs.

immutable sequences, and how dictionaries handle hashing under the hood.

• Practice: Replace standard for loops with list comprehensions, generator expressions, and

advanced slicing.

2.2 Week 2: Functions, Closures, and Variable Scopes

• Reading: Fluent Python (Chapters 5, 6 & 7).

• Theory Focus: Master functions as first-class objects, the mechanics of variable scopes

(global vs. nonlocal), and closures.

• Practice: Write custom decorators to track memory allocations and function execution times.

2.3 Week 3: Object References and Garbage Collection

• Reading: Fluent Python (Chapter 11).

• Theory Focus: Understand how Python passes variables by reference, shallow vs. deep

copies, object identity (is vs. =), and how the Garbage Collector clears memory.

• Practice: Refactor a script to eliminate accidental variable mutation bugs.

2.4 Week 4: Capstone — The NumPy Paradigm Shift

• Reading: ISLP Python Labs (Chapters 2 & 3).

• Theory Focus: The architecture of contiguous memory blocks in CPU caches.

• Practice Project: Write an entire Ordinary Least Squares (OLS) Linear Regression model

from scratch.

• Rule: You are forbidden from using any loop. Every step—from matrix transposition to

calculating residuals—must be written as raw, vectorized numpy matrix calculations.

Month 2:

Pure Functional Accelerated Computing (JAX)

Goal: Master stateless programming and functional compilation to optimize mathematical functions automatically.

3.1 Week 5: Introduction to Functional Math Purity

• Reading: JAX in Action (Chapters 1 & 2) + JAX: The Sharp Bits documentation.

• Theory Focus: The mathematical differences between stateful objects and pure functions. Understand why side-effects ruin parallelized compilation.

• Practice: Write basic algebraic mathematical formulas in JAX. Enforce total immutability no changing array elements in place.

3.2 Week 6: Automatic Differentiation & Gradient Tracing

• Reading: JAX in Action (Chapter 3).

• Theory Focus: How automatic differentiation works via computational graphs, tracing, and

forward/reverse-mode accumulation.

• Practice: Build a custom mathematical function with multiple variables, and use jax.grad

to automatically generate its calculus derivative function.

3.3 Week 7: JIT Compiling and Vectorized Mapping

• Reading: JAX in Action (Chapters 4 & 5).

• Theory Focus: How XLA (Accelerated Linear Algebra) compiles Python code into optimized

machine instructions. Understand how jax.vmap automatically vectorizes a function over batches of inputs.

• Practice: Use jax.jit and jax.vmap to speed up a raw mathematical operation by 100x,

measuring the hardware performance differences.

3.4 Week 8: Capstone — Stateless Neural Engine

• Practice Project: Build a multi-layer neural network from scratch using nothing but Google

JAX.

• Execution: Manually create a dictionary of static weight matrices. Write a pure function for

the forward pass, use jax.grad to automatically compute the gradient of the loss function,

and update the static weight dictionary by outputting a fresh, updated matrix every iteration.

Month 3:

Multiple Dispatch (Julia) & System Architecture (DDD)

Goal: Write hardware-speed math algorithms in Julia, then use Domain-Driven Design to build

robust production systems.

4.1 Week 9: Thinking in Types and Multiple Dispatch

• Reading: Hands-On Design Patterns with Julia (Chapters 1–4).

• Theory Focus: The radical shift away from Object-Oriented programming. How Julia uses

type hierarchies and Multiple Dispatch to execute the exact function signature needed at

runtime.

• Practice: Code a mathematical matrix operation that behaves completely differently de-

pending on whether you pass it integers, floating-point numbers, or custom abstract algebraic

vectors.

4.2 Week 10: Writing C-Speed Math in Julia

• Reading: Julia High Performance (Chapters 1, 2 & 4).

• Theory Focus: Type stability, type inference, and how to eliminate hidden heap memory

allocations in performance-critical loops.

• Practice: Rewrite your Month 1 NumPy regression model in native Julia. Use the @code_warntype

macro to profile the compiler and optimize the code until it runs at raw C hardware speed.

4.3 Week 11: Domain-Driven Design Fundamentals

• Reading: Architecture Patterns with Python (Chapters 1, 2 & 3 / free on cosmicpython.com).

• Theory Focus: The architecture of Bounded Contexts, Domain Models, and the critical

abstraction layer of the Repository Pattern.

• Practice: Create a blueprint of a data pipeline system where the core mathematical equations

are isolated into an independent, pure "Domain Model" file that contains zero dependencies

on databases or web frameworks.

4.4 Week 12: Final Capstone — The Production Architect

• Practice Project: Combine everything you have learned into a clean production architecture.

• Execution: Write a core machine learning algorithm (like a Decision Tree or Logistic Re-

gression engine) in pure, stateless JAX or Julia. Wrap this mathematical engine in a Python

software architecture using Domain-Driven Design patterns. Build an interface where an ex-

ternal data pipeline can feed in data via a strict Repository interface without the core math

model ever needing to know where the data originated.

5 .Development Environment Setup

To begin Month 1 without friction, set up a clean workspace on your computer:

1. Install Python: Use an isolated environment manager like Miniforge or uv to keep your

global machine clear.

2. The Stack: Install numpy, pandas, and scikit-learn strictly to run the Phase 1 textbook

labs.

3. IDE: Use Visual Studio Code (VS Code) or Cursor, making sure to configure the standard

interactive Python environment (Jupyter notebooks) for testing your raw matrix code.