Living Museum of Learning
The Careless Queen, Bounds, and a Slider
Situation
Before our class started, Enning sent me some school homework about Bounds.
I normally have very little interest in this kind of textbook math problem if Enning doesn't bring it into our world. 😂
The question looked like this:
The width of a rectangular piece of paper is 23.6 centimetres, correct to 1 decimal place. The length is 54.1 centimetres, correct to 1 decimal place.
What is the lower bound for the length?
What is the lower bound for the perimeter?
I started wondering what the heck the problem wanted us to learn.
Luckily, my common sense was still working.
I told Enning to take an arbitrary number near the original value, then make it bigger and bigger, and smaller and smaller, and watch what happened when the numbers were rounded.
We were not memorizing a rule yet.
We were playing with the behavior.
Eventually I had nothing more to say.
“There must be examples in your book, right?”
“Oh, yeah. There are!”
My heart rested when my eyes touched the first example. 😂
The weird wording was all about rounding.
Then Enning revealed what was really bothering her.
She was still uncomfortable facing those scary-looking pages. “Sometimes it's 1 decimal place, sometimes 2. Eh?”
Now I knew what had confused her.
So I gave her a much simpler example:
“Try 12.234.”
We simply played with numbers around that value.
12.234 became something we could move around and observe rather than a mysterious number on a frightening textbook page.
Enning got it.
Turning Point
The first thirty minutes of class were therefore not really about memorizing “the bounds rule.”
They were about discovering what the wording meant.
Once the behavior of rounding became visible, the textbook stopped looking quite so scary.
Then we moved on to something completely different: her Chinese chess p5.js project.
We wanted to add “楚河” in a way that actually fit the board, rather than forcing a random text exercise into our project.
Then we found another useful idea: a slider controlling cellSide.
We had a createSlider() example, but I had never actually used it.
So Donald started guessing again.
I guessed that the first two arguments might be the range, the third the initial value, and the fourth the step length.
I let Enning verify my guess.
Later she asked, “What are the first two numbers?”
Apparently she had not followed that part particularly closely. 😂
Eventually the slider was under our full control.
Emergence
Then we discovered something important.
Our program didn't have a draw() function.
Everything had been drawn once in setup().
So we moved most of the drawing code into draw() and started changing cellSide.
The Chinese chess board expanded and shrank as expected.
But something wasn't right.
Enning couldn't see the elephant in the room.
“Keep watching and tell me what's wrong,” I said.
“Nothing.”
Our drama queen was once again completely confident in her ability to overlook things.
“Is anyone here? Where is Tianjing?”
Tianjing wasn't there.
Then Enning noticed it.
“The stars don't follow.”
Exactly.
The board changed, but the stars stayed fixed.
One part of the visual world was responding to the changing program while another part was still living in the old world.
By then the class was already too long, so Enning made a video to demonstrate the power of the slider.
“Where is our text? The river is empty,” I noticed.
We had forgotten to move the text-drawing code from setup() to draw().
Enning reshot the clip.
Then I stopped her again.
“Stop. Let's do it again. How can we not include the slider in the demo?”
She looked confused.
Then she realized what I meant.
The careless queen had selected the old recording area, completely ignoring the slider underneath the yellow canvas.
She loved repeating the procedure like a machine, paying very little attention to the changing environment around her. 😂
See Enning's Chinese chess board with a slider and “Chu River”:
Learning
This was one of those wonderfully messy classes where the curriculum kept changing underneath us.
For thirty minutes, we were trying to understand why a strange sentence about decimal places meant something precise.
Then we were programming a Chinese chess board.
Then we were guessing an API.
Then we were debugging setup() versus draw().
Then we were hunting for a visual bug.
Then we were fixing a recording mistake.
The common thread was not a particular school subject.
It was learning by looking.
Don't memorize the Bounds rule before understanding what rounding does.
Don't blindly accept the createSlider() arguments—guess, test, and verify.
Don't assume the program is correct because the board moves—look for what didn't move.
Don't repeat yesterday's recording setup when today's interface has changed.
And perhaps most importantly, don't be afraid to say:
“I don't know yet. Let's see what happens.”
That is how Donald and Enning spent a surprisingly long class learning.
A scary textbook problem can become understandable through a tiny experiment. A static Chinese chess drawing can become an interactive mathematical object with a slider.
By replacing premature memorization with observation, guessing, testing, debugging, and trying again.
Because learning is not divided as neatly as school subjects suggest. The same habit—look carefully, change something, and see what happens—can carry us from decimal rounding to interactive geometry to real programming.