Abstract:

This video is a pedagogical session on problem-solving and Python programming, structured around George Polya's four-step "How to Solve It" framework. Using an Advent of Code challenge as a practical example, the lesson demonstrates an iterative, exploratory coding style within the Solveit environment. The instructors, Jonno and Jeremy Howard, present multiple solutions to the same text-parsing problem, introducing and contrasting fundamental techniques such as basic string splitting, functional programming concepts with fastcore.utils.L, regular expressions, and Python sets for efficient matching.

A significant portion of the video is dedicated to a detailed walkthrough of the previous lesson's homework: implementing an agentic tool loop from scratch. This segment models an effective learning process, showing how to use an AI assistant to deconstruct a problem, verify understanding with small experiments, and incrementally build a solution by first performing the steps manually and then encapsulating the logic in a loop. The session begins by highlighting a student's advanced work implementing a recent academic paper on "Recursive Language Models," underscoring the course's focus on practical application and deep understanding.

Solveit Lesson 3: Problem-Solving, Regex, Sets, and Agentic Loops

• 1:04 Student Spotlight & Learning Philosophy: The lesson begins by showcasing a student's implementation of "Recursive Language Models," a new technique from an academic paper. This is used to emphasize the value of applying concepts through homework to achieve a deeper understanding beyond passive watching.
• 9:41 The Polya Framework: The core pedagogical structure for the lesson is introduced: George Polya's four-step problem-solving method: 1) Understand the problem, 2) Devise a plan, 3) Carry out the plan, and 4) Look back and reflect.
• 12:19 Reusable Code Utilities: The concept of creating reusable utility modules is demonstrated. Code cells from a Solveit dialogue are exported to an aoc_utils.py file, which can then be imported into other projects to automate setup tasks.
• 21:51 Iterative String Parsing: The initial approach to solving the Advent of Code problem involves parsing an input string incrementally, building up a complex expression piece-by-piece in a single cell and checking the output at each stage.
• 32:26 Functional Programming with fastcore: An alternative solution is presented using fastcore.utils.L, a list-like object with added methods. This introduces the functional programming concept of mapping a function (like int) over a list of items (.map(int)).
• 34:41 Introduction to Regular Expressions: As a more powerful alternative for parsing structured text, regular expressions (regex) are introduced. Key concepts are explained, including matching any character (.), one or more repetitions (+), digits (\d), character classes ([]), and whitespace (\s).
• 50:27 Using Sets for Efficient Matching: To find common numbers between two lists, the Python set data structure is introduced. The efficiency and utility of set operations, specifically intersection using the & operator, are demonstrated as a superior alternative to looping.
• 53:54 List Comprehensions: Python's list comprehension syntax ([n for n in numbers if condition]) is explained as a built-in, elegant way to perform map and filter operations.
• 1:05:24 Building Loops Incrementally: When solving the problem's second part, a method for safely building complex loops is shown: write the loop's body, use a break statement to run it only once, and print intermediate values to verify the logic before running the full loop.
• 1:16:37 Homework Walkthrough: Building a Tool Loop: The final, extensive segment is a step-by-step completion of the previous lesson's homework.
  • 1:17:52 Effective Learning Setup: Jeremy Howard demonstrates his process for tackling a complex problem: loading the original lesson dialogue, adding the transcript and documentation as context for the AI, and then using the AI as a tutor to ask clarifying questions.
  • 1:48:30 Manual to Automated Loop: The core logic of the agentic tool loop is built not by writing a loop first, but by manually executing each step: 1) get the AI's first tool call, 2) run the tool, 3) create a new history with the tool's result, 4) send the new history to the AI to get the next step.
  • 1:55:26 Final Implementation: After manually performing the steps twice, the repeated pattern is identified and encapsulated within a while loop that continues as long as the AI's "stop reason" indicates a tool use. This demonstrates a robust method for developing loops: do it manually first, then automate.