CS110A Week 2 Day 1 lesson on 08/25/2026

Overview

Indika Walimuni introduces CS110A students to computational thinking as a two-stage process: first develop a correct algorithm in plain English, then translate it into Python. The class practices this approach through a turtle-graphics triangle, Canvas and Trinket file-submission exercises, and a stepwise-refinement assignment, while also covering Bloom’s taxonomy, software collaboration, and computer hardware.

Key takeaways

A reliable programming workflow starts by deriving a correct English algorithm, then translating that plan into Python; CS110A begins this practice before formal coding in week four.
The four computational-thinking concepts are decomposition, pattern recognition, algorithm design, and abstraction, which together help create solutions that generalize beyond one input.
The turtle triangle example uses three sides of length 100 and 120-degree turns; correctness is judged by whether the algorithm draws the intended equilateral triangle.
Python files are text files distinguished by the .py extension, and Notepad++ is a practical workaround for creating one when Canvas or a downloaded Trinket ZIP causes trouble.
Computer performance depends on hardware tradeoffs: gigahertz clock rates enable billions of cycles per second, while faster processors and data centers require more power and cooling.
Bloom’s revised taxonomy has six levels, from remembering through creating; stronger critical thinking requires both foundational recall and practice applying, analyzing, evaluating, and creating.

Chapters

0:00 CS110A Honors Projects and Early Course Assignments

Indika Walimuni invites students to consider the CCSF honors program, describing last semester’s students who developed projects and one student who presented an accepted abstract at a Stanford honors consortium.
Honors work adds a manageable extension to course material, can be based on a student’s own question, and is recorded on the transcript.
Students have September to decide, and Walimuni says there is no fixed enrollment cap for his honors students.

2:54 Posting Turtle-Graphics Work in the Canvas Discussion

The turtle assignment uses a Python program to draw a fish; changing a size parameter to about 180 or 190 brings the drawing inside the display.
Students should post the code in a Canvas discussion reply as preformatted text and include a Trinket link rather than embedding the whole project.
Walimuni cautions that embedding a roughly 77 MB page for 20 students could consume more than 1 GB and slow the discussion page.

8:30 Submitting a Python File Through Canvas

The follow-up assignment gives students practice attaching a file, a skill they will need for the midterm project.
Canvas accepts a Python file with a .py extension; students can use Notepad++ to paste the program and save it as a Python file.
Walimuni previews a small midterm project expected around mid-October and says its submission format will depend on the project.

14:36 Renaming and Uploading Python Files on Windows and Mac

For Windows users, Walimuni demonstrates saving code with a .py extension and using underscores instead of spaces in filenames, such as draw_fish.py.
Students locate the saved file in Documents or Downloads, attach it through Canvas, and select Submit.
For Mac users, he suggests using a text editor, pasting the copied code, and saving the result with a .py extension.

22:00 Troubleshooting Trinket Downloads and Windows ZIP Files

Trinket downloads a ZIP archive that may appear empty when opened or extracted through Windows, an issue Walimuni attributes to Windows security behavior.
The downloaded archive can contain a file named main.py; extracting it or using an alternative ZIP utility such as 7-Zip can expose the Python file.
Walimuni says the previous classroom coding tool had been hacked, prompting the switch to Trinket.

27:42 Computational Thinking Translates English Solutions into Python

Walimuni describes computational thinking as moving from a solution expressed in English to an algorithm, then translating that plan into Python grammar.
Students should work out the problem-solving logic before worrying about how to express it as code.
Python turtle graphics will begin in week four, but the class first studies the algorithm behind a drawing.

30:00 A 100-Unit Equilateral Triangle Demonstrates Algorithm Correctness

The turtle algorithm puts the pen down, moves forward, and turns left by 120 degrees between sides to draw an equilateral triangle with side length 100.
A 120-degree turn produces the triangle’s 60-degree interior angle, so the steps meet the drawing’s intended result.
An algorithm is correct when it solves the stated problem, regardless of the particular sequence of implementation details.

34:00 Why Correct Algorithms Matter in Safety-Critical Software

Walimuni emphasizes that software defects can cause real-world harm, citing fireworks misfiring toward a launch platform and software-related problems associated with the Boeing 737 MAX.
He also refers to a rocket explosion attributed to a code bug as an example of the consequences of faulty software.
Programs for systems such as air-traffic control and autopilot require especially careful correctness because human lives may depend on them.

39:30 Problem Solving as Input, Process, and Output

A computational problem can be described using three elements: input, the process that transforms it, and the expected output.
Input devices include keyboards, microphones, touchpads, and game controllers; the keyboard and screen are the common classroom input and output devices.
For a microwave, food is the input, warming is the process, and warmed food is the output.

41:30 From Prime-Number Testing to a General Problem-Solving Process

The prime-number example tests divisibility starting at 2 and continuing through successive candidate divisors to determine whether an input is composite.
A simple way to specify an input in code is assigning a value directly, such as number = 25; later course material will cover passing inputs to functions.
The class uses real-world analogies, such as preparing food, to make the input-process-output structure of computing easier to understand.

46:30 The Four Computational-Thinking Concepts

Decomposition breaks a complex problem into smaller problems that are easier to solve.
Pattern recognition finds a reusable approach that works across different inputs rather than only one example.
An algorithm or pseudocode is a numbered, top-to-bottom plan, usually written in English; abstraction generalizes a solution across related scenarios.
Walimuni says students will practice a problem-solving technique called the umpire technique beginning in week four.

50:00 Canvas File-Submission Workarounds and Course Navigation

Walimuni revisits the .py upload problem and uses the extracted main.py file as a workaround for students whose ZIP archive looks empty.
Students should follow the Canvas module structure, where course activities and assignments are intended to be available.
The class pauses individual troubleshooting before moving to a learning video on Bloom’s revised taxonomy.

1:02:00 Bloom’s Revised Taxonomy Builds Toward Creating

The classroom video presents six cognitive levels: remembering, understanding, applying, analyzing, evaluating, and creating.
Higher-order thinking depends on a foundation of remembering and understanding, so students need both foundational knowledge and practice using it.
The video recommends anticipating exam questions at different levels, using vampire and werewolf examples to distinguish recall, comparison, judgment, and creation.

1:08:20 Software Teams Use Collaboration and Version-Control Tools

Walimuni notes that software projects commonly involve many contributors, with Photoshop and open-source projects as examples.
Collaboration tools mentioned include Google Groups, Slack, and Skype; version-control platforms include GitHub, GitLab, and Mercurial.
One midterm-project option is building a resume as a GitHub project and publishing it as a web page; students will choose among several topics and submission formats.

1:11:00 CPU Components: The ALU and Control Unit

The central processing unit, or CPU, executes program instructions after they are represented as streams of zeros and ones.
The arithmetic logic unit, or ALU, handles arithmetic such as addition and division, along with logical operations such as AND, OR, and XOR.
The control unit coordinates the CPU’s attached components and responds to instructions involving input and output devices.

1:17:00 RAM Addresses, Random Access, and Computer Input and Output

Random access memory stores data in cells that can be reached directly by address, rather than requiring a sequential scan from the beginning.
A memory chip contains many cells, and an address identifies the location where the computer should read or write data.
Keyboards are common input devices and screens are common output devices, but computers can use many other kinds of each.

1:19:00 CPU Clock Speed and the Human Response-Time Analogy

CPU clock frequency is measured in hertz; a gigahertz-scale clock performs billions of cycles per second.
A basic CPU instruction can execute in a cycle, which at roughly 1 GHz is about one nanosecond, though actual performance also depends on other factors.
Walimuni contrasts this with human visual reaction time, discussed in the microsecond-to-millisecond range, and explains how roughly 30 film frames per second appear to form continuous motion.

1:24:00 Quantum Computing, Data-Center Power, and Cooling Limits

Walimuni presents quantum computing as a developing approach related to the limits of conventional computing, while noting that it is not yet widely accessible.
He says quantum machines require very cold operating conditions and expensive helium-based refrigeration, limiting access largely to major universities and national laboratories.
Faster processors draw more current and produce more heat; large data centers may need substantial water or rack-level cooling infrastructure.

1:29:00 A CPU Clock-Speed Animation Shows Instruction Throughput

An animation compares a 2 GHz CPU with a faster processor by showing how many instruction cycles each can complete over the same interval.
A simple operation, such as adding 2 and 3, is used as an example of an instruction handled in a CPU cycle.
The class answers a question about factors that decrease the number of instructions a CPU can execute.

1:31:00 Assignment: Write a Numbered Real-World Algorithm

Students choose a practical task, with making a peanut-butter-and-jelly sandwich or an omelet offered as examples, and write a plan to solve it.
The algorithm should use numbered steps and include at least one expanded substep, such as 3.1 and 3.2 under step 3.
Walimuni uses a go-to-school example to show how a high-level plan can be refined into more specific actions.

1:39:00 The Smoothie Algorithm Is Submitted as English, Not Code

The assigned example is making a smoothie; students should type their English algorithm, including substeps, directly into the Canvas discussion.
The earlier sandbox and code-upload instructions are removed because students have not yet learned programming syntax.
Starting in week four, students will translate algorithms like this one into Python.

1:45:00 Python Comments, Local Installation, and Collaborative Practice

Students can mark English lines as Python comments by prefixing them with the # character, though the current algorithm assignment does not require a Python file.
Walimuni plans to demonstrate installing Python in week four; for now, students will run programs online.
He asks students to work in pairs on upcoming 20-to-30-minute problems and says he will revisit the current exercise at the start of Thursday’s class.

Transcript excerpt

0:04 I last night I posted actually the um recording YouTube recording but I'll try to uh try my best to do at least the next day so that you guys have time to review. Okay. So this is our agenda for today. Okay. So um so we're going to go over well before this we before we go over the discussion uh I want to um um talk with you on honors program. Okay. So last uh semester I had uh three honor students in this class. Uh and then one of the student actually presented in um honors consortium in Stanford the same same semester. So last semester actually uh her abstract got um accepted and then um

0:55 um uh she was uh presenting in one of the um um um simple like you know uh presentation session. Um it's not that difficult like you know it's honest programs basically means you do something little extra compared to the others curriculum. Okay. So and then you can come up with your own question and we'll adapt what we learning in the class into that or you can talk to me and then I can give you something. Okay. So in in particular to last year students um both of them came up with their own and and then we adapted something we are learning in the class to that as well. Okay. So um it's not a whole lot of extra. Okay. So don't

1:43 get intimidated by okay you have to present some men know it's just uh something a little extra and then that's qualified for the uh honors program okay and it's I will determine that so the whether you can do this in in within the semester so I'll be reasonable to uh do that as well okay so I I highly

This is the start of the transcript. Save this video free for the whole transcript, searchable and time-coded.

Related notes

Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, indika walimuni.