How to Read This Tutorial

This is more of a mind-map for now…

Foundations

  • File Systems and Architecture (files.qmd)
    • The Directory Tree: Abstracting the local operating system as a rooted, directed tree graph.
    • Coordinates of the Machine: Absolute vs. relative pathing (./ and ../) and maintaining workspace portability.
    • The Plaintext Guarantee: Differentiating human-readable source formats (.txt, .tex, .py, .qmd) from opaque binary blobs (.docx, .png).
    • Dotfiles and Hidden Metadata: Demystifying system configuration files and hidden directories (like .git and .DS_Store).
  • The Terminal Emulator (terminal.qmd)
    • Anatomy of a Shell: Understanding terminal emulators as text-based control layers, contrasting zsh and bash.
    • Navigating the Tree: The baseline commands for spatial awareness and locomotion: pwd, ls (with flags like -la), and cd.
    • Structural Editing: Modifying directories and files without a mouse: mkdir, cp, mv, and the absolute permanence of rm.
    • Streams and Pipes: Textual data redirection using stdout, pattern filtering via grep, and functional chaining with the Unix pipe operator (|).
    • Philosophy of the superuser (sudo), permissions, and digital safety habits regarding remote execution scripts (curl | bash).
  • Package Managers (managers.qmd)
    • Registries and Dependency Graphs: How automated package systems resolve configuration prerequisites across an ecosystem.
    • Homebrew on macOS: Installing, upgrading, and cleanly purging software packages using system formulae and graphical casks.
    • Alternative Environments: A comparative nod to the Linux rolling-release environment (pacman), highlighting systemic diversity without wandering down supply-chain vulnerabilities.
    • The Environment Search Path: Demystifying the PATH variable and configuring shell configuration profiles (.zprofile or .zshrc) to map custom executable binaries.
  • Digital Security (security.qmd)
    • Entropy vs. Complexity: The mathematics of password cracking and why long, random passphrases outclass complex, short passwords.
    • Asymmetric Cryptography: A non-technical introduction to public/private key pairs and why they form the backbone of modern digital identity.
    • Remote Shell Authorization: Generating custom SSH keys, configuring passphrases, and pairing public keys with GitHub to secure data pipelines without typing passwords.
    • Two-Factor Protocol (2FA): Securing administrative accounts against SIM-swapping using Time-based One-Time Password (TOTP) authenticators.
    • Version Control (git.qmd)
      • The Directed Acyclic Graph: Conceptualizing development history as a structured DAG of snapshot deltas rather than a sequence of file duplicates.
      • The Local Lifecycle: Executing the standard staging pipeline: Working Directory \(\to\) Staging Area (git add) \(\to\) Local Repository (git commit).
      • Branching and Merging: Diverging from the stable main branch to experiment safely with calculations and proofs before unification.
      • Distributed Collaboration: Mapping local repositories to hosted remote servers via GitHub (git push, git pull).
      • Conflict Resolution: Dissecting line collisions, interpreting Git merge markers, and manually restoring graph harmony.
  • Integrated Development Environments (editors.qmd)
    • The Extensible Workplace: Why modern development favors modular, lightweight IDE platforms like VS Code over monolithic programs.
    • Command Palette Mastery: Bypassing menus entirely using keyboard shortcuts (Cmd/Ctrl + Shift + P) to trigger actions.
    • Configuration as Code: Bypassing graphical menus by modifying settings.json directly to bind themes, linters, and compiler hooks.

Computation & Illustration

  • Pure Python (python.qmd)
    • Standard Collection Architectures: Working with primitive data types alongside indexed lists, immutable tuples, and rapid hash-map dictionaries.
    • Index Slicing Mechanics: Navigating arrays and sequences cleanly via pythonic notation: [start:stop:step].
    • Control Flow and Comprehensions: Implementing boolean conditional logic, loops, and translating mathematical set-builder notation \(\{x^2 \mid x \in S\}\) directly into concise list comprehensions.
    • Functions and Inductive Logic: Modular design using parameters, scope tracking, and structural abstraction via recursive functions.
    • The Isolation Problem: Why global installations break system integrity. Setting up local python environments (python -m venv or uv) and maintaining reproducibility via requirements.txt.
    • Capstone Project: Building a fully deterministic Conway’s Game of Life cellular automaton engine using pure Python dictionaries and lists, emphasizing grid state lookups and relational data storage before external math libraries are ever loaded.
  • Scientific Computing (scientific.qmd)
    • The Architecture of Speed: Why pure Python loops are slow for heavy computation, and how NumPy serves as a high-performance wrapper for pre-compiled, raw C and Fortran blocks in memory.
    • Vectorization vs. Iteration: Rewriting element-by-element loops into simultaneous vector and matrix array computations.
    • Multidimensional Array Broadcasting: The mathematical rules governing operations on arrays with mismatched matrix dimensions without duplicating memory.
    • Numerical Approximation with SciPy: Executing numerical integration routines, finding matrix decompositions (LU and SVD), and tracking dynamical changes via Ordinary Differential Equation solvers (scipy.integrate.solve_ivp).
    • Capstone Project: Designing and simulating a Chaotic Double Pendulum system, leveraging NumPy array structures for vectorization and SciPy’s ODE suites to compute the chaotic equations of motion.
  • Symbolic Computation (sagemath.qmd)
    • Symbolic Engines vs. Floating Points: Declaring formal algebraic variables (var('x')) to calculate exact mathematical truths (derivatives, exact integration, and limits) rather than decimal approximations.
    • Structural Computer Algebra: Evaluating equations exactly over defined mathematical structures: rings of polynomials, arbitrary precision fields, and rational spaces.
    • Abstract Algebra and Group Suites: Leveraging SageMath’s deep integration with the GAP interface to build permutation groups, inspect symmetry operations, and output exact group character tables.
    • Advanced Polynomial Elimination: Moving beyond standard linear Gaussian elimination to compute Gröbner bases for non-linear systems of algebraic equations.
    • Capstone Project: Applying Elimination Theory via Gröbner Bases to solve complex multi-variable Lagrange Multiplier problems that are traditionally algebraically impossible for students to solve by hand, isolating intersection curves of polynomial ideals.
  • Mathematical Animation (manim.qmd)
    • Visual Scripting Principles: Constructing geometric animation frames programmatically via Python scripts rather than manually keyframing in video software.
    • Mobjects and coordinate mapping: Working with Vectorized Mathematical Objects (VMobjects) and pinning structures to an internal coordinate plane.
    • Updaters and Dynamic States: Binding properties together so that moving one mathematical object (e.g., a point on a circle) automatically updates dependent assets (e.g., a tangent line or a coordinate graph).
    • Rendering Pipelines: Using the terminal to execute compilation parameters, managing output resolution, and handling vector frames.
    • Capstone Project: Creating a highly polished, cinematic geometric animation illustrating Monodromy and the action of the Braid Group, showcasing how path-tracking around singularities permutes the branches of a multi-valued complex function.
  • GPU Shaders (shadertoy.qmd)
    • Massive Parallelism: Contradicting a CPU (a handful of ultra-fast sequential processing cores) with a GPU (thousands of parallel cores running the exact same code execution simultaneously for every pixel on a screen).
    • Normalized Coordinate Spaces: Writing in GLSL (OpenGL Shading Language) where the core loop evaluates screen positions normalized between 0 and 1, outputting color values in real-time.
    • Signed Distance Fields (SDFs): Defining geometry implicitly through mathematical functions that map any spatial point to its shortest distance to a surface.
    • Raymarching Engines: Programming a custom camera ray loop to step through space along vectors to calculate exactly where lines of sight intersect algebraic equations.
    • Capstone Project: Authoring a custom fragment shader on Shadertoy that uses raymarching to render three-dimensional algebraic surfaces and fractals in real-time with smooth blending, lighting vectors, and specular reflections driven purely by vector math equations.

Communication

  • LaTeX (latex.qmd)
    • Motivation and Scope: Semantic separation of content from presentation; why WYSIWYG breaks at scale.
    • Core Concepts: Document distributions, compilation pipelines, multiple passes, auxiliary files, and log file parsing for human debugging.
    • Anatomy of a Document: Preamble setup, semantic structuring, math mode, and multi-line equations.
    • Best Practices and Automation: Structural labeling schemas (\label{sec-...}), macro generation (\newcommand), and building automated compilation chains inside VS Code.
  • Markdown (markdown.qmd)
    • Lightweight Syntax: Speed-writing headers, nested lists, bold formatting, and inline links without code bloat.
    • The MathJax Bridge: Injecting standard LaTeX math environments directly into lightweight text files for rapid note-taking.
    • Personal Knowledge Management: Using markdown engines like Obsidian to form network-linked conceptual graphs using double-bracketed wiki-links ([[Concept]]).
    • Universal Conversion: Understanding Pandoc as the background parsing machine that translates markdown formatting effortlessly across document types.
  • Quarto (quarto.qmd)
    • The Grand Unification: Knitting markdown text, LaTeX equations, and live executable code engines into a single, cohesive document format.
    • Anatomy of Front Matter: Configuring document compilation outputs, structural templates, and global styling parameters via hierarchical YAML configurations.
    • Executable Code Chunks: Setting up cell parameters (#| fig-cap, #| fig-alt) to run live computation blocks and embed calculations, tables, and figures automatically during compiling.
    • Polyglot Publishing: Building a single Quarto source file into an accessible, interactive web page (HTML) or a beautiful, publication-ready article (PDF).
  • Bibliographies (bibliography.qmd)
    • The Plaintext Reference Database: Managing citations securely via automated .bib text files populated with explicit citation keys.
    • Academic Ingestion: Utilizing open-source reference software like Zotero to scrape web metadata, manage collections, and auto-export dynamic .bib repositories to your local projects.
    • Syntactic Citations: Referencing database keys across raw LaTeX formats (\cite{}) and Quarto styles (@key) to automatically generate cleanly formatted bibliographies.
  • Deployment (deployment.qmd)
    • Static Hosting Paradigms: Why serving static HTML asset trees is fast, highly secure, and universally free for open academic research profiles.
    • Continuous Integration / Continuous Deployment: Binding local Git workspaces to automated compilation triggers.
    • Cloud Infrastructure: Deploying static mathematics portals using cloud drag-and-drop systems like Netlify or automated, code-triggered tools like GitHub Pages.

graph LR
  subgraph Foundations [Part I: Foundations]
    files --> terminal --> managers --> security --> git --> editors
  end

  subgraph Computation [Part II: Mathematical Computing]
    python --> scientific --> manim
    python --> sagemath
    scientific --> shadertoy
  end

  subgraph Communication [Part III: Communication]
        direction TB
        latex --> bibliography
        quarto --> bibliography
        latex --> quarto --> deployment
        markdown --> quarto
    end

  editors --> python --> quarto
  editors --> latex
  editors --> markdown