I've done it! I've completed the first course in my Will Hunting Challenge: Introduction to Computer Science and Programming in Python. It took longer than I wanted or expected, but as a working father with a wife in graduate school, I'm proud I stuck with it long enough to reach this milestone. I'm treating this challenge as a marathon, not a sprint.

What I've Been Learning

Since my last post, the remaining lessons covered Object-Oriented Programming (OOP), complexity, basic search and sort algorithms, using libraries, and data analysis. Most of that — OOP, complexity, algorithms, libraries — has been second nature since I completed my coding boot camp, and I use it on the job every day. Honestly, part of why I went quiet for a while is that I simply hadn't come across anything new. For reference, the algorithms the course covered were:

• Linear Search
• Bisection Search
• Bogo Sort
• Bubble Sort
• Selection Sort
• Merge Sort

The final two lectures, though, were a different story. They focused on plotting data and running simulations — topics my boot camp didn't cover and that rarely come up in my day-to-day work. That said, I'm not a total stranger to programmatic charting. A couple of years ago, I built a data analytics project where I automated reporting by extracting data from multiple databases, transforming it, and generating charts using CraftMyPDF. In some cases, I was given a chart design to recreate; in others, I designed the charts myself. The API calls to CraftMyPDF included JSON with the data needed for the JavaScript ApexCharts library to construct each chart. I also used ApexCharts directly in my MoveMinder portfolio project. So these lectures weren't a first introduction to charting — but they did surface some concepts worth keeping:

• The Matplotlib and SciPy libraries
• Visualization principles, such as rules for labeling and describing each axis
• A clear, step-by-step framework for running simulations

On that last point: I had expected simulations to be intimidating, but I was pleasantly surprised by how simple the core concept turned out to be. A simulation is essentially repeating an experiment k times and tracking the results. More specifically, it follows five steps:

1. Observe an event and identify an aspect of it to calculate.
2. Design a computational experiment of that event.
3. Run the experiment k times.
4. Track the outcome across all runs.
5. Report the value of interest.

I recognize this course only scratched the surface of simulations, but the foundational idea is elegant in its simplicity. Given my existing coding experience, I feel confident I can tackle more complex simulations as they come up.

Key Takeaways from the Course

Even in a course where most of the material was familiar ground, I walked away with a handful of genuinely useful nuggets:

• All Python functions return a value — even without a return statement. In the absence of a return statement, the function returns None.
• Glass-box testing uses scenarios that test every path through the code, with full visibility into the implementation. Black-box testing verifies that code meets its specifications using only inputs and outputs, with no visibility into the code itself.
• Identifying partitions in possible input values gives you a systematic approach to building a test suite.
• Integration testing verifies data flow between modules or components; functional testing verifies the entire system against user and business requirements.
• In Python, you can customize the behavior of operators like +, +=, and < for your own classes using dunder methods.
• Simulations aren't a complex, advanced technique — they follow a simple, five-step process.

Reflecting on the Course as a Whole

In my first post about this course, I expressed surprise at how heavily the MIT course leaned into Python syntax, statistics, big data, and machine learning — in contrast to the Turing Machines, logic gates, pseudocode, and programming paradigms I studied in my college Intro to CS course. Having completed it, I can confirm my initial read was mostly accurate.

The course is Python-heavy and statistics-adjacent, with only a minimal amount of anything else. A couple of nuances are worth noting, though: the lectures spent more time on functional and object-oriented paradigms than the syllabus and textbook suggested they would. And the course ended up being lighter on statistics and math than it initially appeared — many equations were presented, but understanding them wasn't required. They were used as calculations to implement in Python, serving as vehicles for programming concepts rather than ends in themselves.

My overall take: completing this course prepares students to write basic programs in a useful, modern language. But the concepts I learned in my college Intro to CS course did a better job preparing me to learn advanced programming concepts, because they taught me how computers and software "think." There's real value in that theoretical grounding.

What's Next

As I move forward with the Will Hunting Challenge, I'm curious whether some of those foundational theoretical concepts will resurface in upcoming courses, such as Fundamentals of Programming or Software Construction. I'm excited to find out. One course down, fourteen to go. How do you like them apples?