Phase 2: Horizon Scanning & Deep Learning (Modules 21-50)

Objective: To systematically explore and gain hands-on proficiency in a curated set of emerging technologies. This phase emphasizes active, project-based learning over passive consumption, with a core tenet of embracing rapid failure as a learning mechanism. Each module is designed to produce a tangible artifact—a piece of code, a trained model, a working demo—which serves as both a learning tool and a potential portfolio piece, thereby energizing the PKES flywheel.

Sub-theme: Generative AI & LLMs (Modules 21-30)

This sub-theme focuses on building practical skills in the dominant technology trend of the 2020s. The projects move from foundational theory to building and deploying sophisticated AI applications.

  • Module 21: Refresher: Linear Algebra with Python/Mathematica: Revisit Jupyter and Mathematica notebooks from Day 12-13. Focus specifically on the concepts underpinning transformer architectures: vector spaces, dot products (as a measure of similarity), matrix multiplication, and Singular Value Decomposition (SVD). Implement a simple attention mechanism calculation in a notebook to solidify the mathematical intuition.
  • Module 22: Building a RAG Application with LlamaIndex: Follow a tutorial to build a complete Retrieval-Augmented Generation (RAG) application.32 Use a personal dataset, such as a collection of past technical reports, articles, or even the notes from this 100-day plan. The goal is to create a question-answering system over this private data. Deploy it locally using a simple FastAPI wrapper. This project provides immediate personal utility and a powerful demonstration of context-augmented LLMs.
  • Module 23: Fine-Tuning a Foundational Model: Gain hands-on experience with model customization. Using a framework like Hugging Face's transformers library and a platform with free GPU access like Google Colab, fine-tune a small, open-source LLM (e.g., a member of the Llama 3 or Mistral family) on a specific, narrow task.35 A practical project is to create a dataset of your own commit messages from a key project and fine-tune the model to generate new commit messages in your personal style. This demonstrates an understanding of the full training and tuning loop.
  • Module 24: Building an AI Agent with LangChain: Construct a basic autonomous agent that can reason and use tools. Using LangChain or LangGraph, define two tools: a search tool (e.g., Tavily Search) and a code execution tool (e.g., a Python REPL). Create an agent that can answer a question like, "What is the current price of Apple stock and what is its P/E ratio?" by first searching for the price and then using the REPL to calculate the ratio. This project demonstrates the core concepts of agentic workflows.38
  • Module 25: Exploring Generative AI in the SDLC: Dedicate a full day to integrating Generative AI into a typical software development workflow. Select an AI-native code editor like Cursor or use GitHub Copilot extensively within your preferred IDE.41 Take on a small coding task (e.g., building a simple web app) and use the AI assistant for every stage: generating boilerplate, writing functions, creating unit tests, explaining unfamiliar code, and writing documentation. Meticulously document the experience in your PKES, noting productivity changes, quality of generated code, and points of friction. This provides a first-hand, critical evaluation of how GenAI is transforming the development lifecycle.43
  • Modules 26-30: Project: Build an "AI Research Analyst" Agent: Synthesize the skills from this sub-theme into a multi-day project. Build an autonomous agent that fully automates the workflow designed in Modules 7-10. The agent's task, triggered daily, is to: 1) Fetch new papers from your arXiv feed. 2) For each paper, decide if it's relevant based on a set of criteria. 3) If relevant, summarize the paper using the LLM tool. 4) Check Papers With Code for an associated implementation. 5) Compile the findings into a structured daily brief in Markdown format. 6) Push the Markdown file to a dedicated GitHub repository that powers a section of your technical blog.

Sub-theme: Modern Data Engineering (Modules 31-35)

This sub-theme addresses the shift in data architecture, moving beyond monolithic data warehouses to more flexible, scalable, and decentralized paradigms. For a senior engineer, understanding these system-level trends is crucial.46

  • Module 31: End-to-End MLOps with MLflow: Go beyond a simple model.fit() call and embrace the discipline of MLOps. Using a classic dataset like the UCI Wine Quality dataset, train a scikit-learn model, but with a focus on the operational aspects.47 Set up a local MLflow tracking server. In your training script, log hyperparameters, evaluation metrics (e.g., RMSE, MAE), and the trained model itself as an artifact. Use the MLflow UI to compare several runs with different hyperparameters. Finally, register the best-performing model in the MLflow Model Registry, promoting it to a "Staging" or "Production" tag. This project covers the core lifecycle of a managed ML model.48
  • Module 32: Data Mesh Proof-of-Concept: Build a small-scale simulation of a data mesh architecture to understand its core principles. Create two separate Python scripts or services. The first, the "Users Domain," generates mock user data and exposes it via a simple API as a "data product." The second, the "Orders Domain," does the same for mock order data. Create a third "Analytics" service that acts as a data consumer, pulling data from both domain APIs to answer a business question (e.g., "What is the average order value for users in California?"). This hands-on exercise demonstrates the principles of decentralized data ownership and data-as-a-product, contrasting it with a centralized data warehouse approach.52
  • Modules 33-35: Project: Real-Time Data Processing Pipeline (Comparative Study): Build a small but complete real-time data pipeline. Use a public streaming data source. The core task is to implement a simple consumer and transformation process twice, first using a traditional message queue like Apache Kafka and then using a unified processing framework like Apache Beam. Document the architectural differences, development overhead, and performance trade-offs in your PKES. This comparative approach deepens understanding beyond a single tool.

Sub-theme: The Next Frontiers (Modules 36-45)

This section focuses on gaining conceptual and practical fluency in technologies that represent significant long-term shifts in computing.55 The objective is not mastery but the ability to understand the fundamentals and identify potential future applications.

  • Module 36: Quantum Computing Fundamentals (Comparative Study): Demystify the core concepts of quantum computation. Using IBM's Qiskit open-source framework, implement a simple algorithm like creating an entangled Bell state. Then, repeat the same exercise using Google's Cirq framework. Document the differences in syntax, circuit construction, and overall developer experience. This provides a concrete understanding of concepts like superposition and entanglement from the perspective of two major ecosystems.
  • Modules 37-38: Neuromorphic & Brain-Computer Interfaces: Shift focus from quantum to another frontier: brain-inspired computing.
  • Day 37 (Neuromorphic Concepts): Research the principles of neuromorphic computing and spiking neural networks (SNNs). Investigate current hardware like Innatera's Pulsar and IBM's NorthPole. Create a detailed summary in your PKES comparing the architecture of these chips to traditional von Neumann architectures.
  • Day 38 (BCI Exploration): Explore the open-source Brain-Computer Interface (BCI) landscape. Research the hardware and software stacks of OpenBCI 91 and commercial platforms like Emotiv. The goal is to understand the types of data (EEG, EMG) they capture and the kinds of projects the communities are building.
  • Modules 39-40: AR/VR for Education & Training: Replace the Web3 focus with an exploration of immersive technologies for learning, aligning with interests in simulation and education.
  • Day 39 (Intro to WebXR): Set up a basic development environment for WebXR. Work through a "Hello, World" tutorial to render a simple 3D object in a browser that can be viewed in VR or AR on a compatible device. This provides a low-barrier entry into immersive development.97
  • Day 40 (Educational AR/VR Prototype): Brainstorm and create a simple proof-of-concept for an educational AR/VR experience. For example, an AR app that displays a 3D model of a molecule when the phone camera is pointed at a marker, or a simple VR scene that visualizes a mathematical concept. The focus is on rapid prototyping, not a polished application.99
  • Modules 41-45: Project: Advanced Frontier Exploration: Select one of the frontier topics (Generative AI, BCI, or AR/VR) and build a more in-depth project.
    • AI Option: Build and deploy a multi-modal application (e.g., an image captioning model) to a Hugging Face Space, making it publicly accessible.
    • BCI Option: Download a public EEG dataset and use Python libraries to perform basic signal processing and visualization, attempting to identify simple patterns (e.g., eye blinks).
    • AR/VR Option: Expand the educational prototype from Day 40, adding more interactivity or information overlays to create a more comprehensive learning module.

Sub-theme: Review & Synthesis (Modules 46-50)

Sub-theme: Review & Synthesis (Modules 46-50)

  • Tasks: This process is now even more natural with mdBook. For each major technology explored, create a main chapter that serves as a "Map of Content" (MOC), linking to all the sub-pages (project notes, tutorials, etc.) you've written on the topic. This makes your book's structure itself a tool for synthesis.
  • Deliverable: A set of highly organized, interconnected chapters within your mdBook. This transforms the raw learning experience into a structured, searchable, and reusable knowledge asset.