Living Museum of Learning
The First Circle Enning Taught Herself
Our 🌱 Living Museum of Learning keeps growing.
And so does Enning.
Only a few days ago, Enning had essentially zero coding experience.
Since then, she has completed her first iOS app, learned the basics of p5.js, drawn grids and geometric shapes, explored function parameters, learned to use documentation, and become increasingly comfortable navigating her own development environment.
She has also developed a habit of reaching for the dictionary when she encounters an unfamiliar English word.
But today's milestone is different.
For the first time in her young life, Enning taught herself a new p5.js function.
The function was:
circle()
I didn't teach her the syntax directly.
I gave her a simple challenge:
“Draw some circles on your canvas, some beautiful ones.” 😀
And she went to work.
Earlier, we had explored square() and triangle().
Enning was beginning to understand that functions aren't magic words.
They have parameters.
Those parameters have an order.
And those numbers describe things in the geometric world.
Then came the circles.
At one point she asked:
“Should I fill them?”
😂
That question was very Enning.
She wasn't satisfied with merely completing:
“Draw some circles.”
She was already thinking:
What should these circles look like?
So she experimented.
She changed the stroke.
She changed the fill.
She changed the position.
She changed the size.
And somewhere along the way, she discovered:
circle()
herself.
Her finished code looked like this:
// circle
stroke(120, 100, 10);
fill(10, 200, 80);
circle(600, 500, 100);
// circle
stroke(200, 200, 10);
fill(10, 0, 80);
circle(700, 700, 200);
// circle
stroke(150, 150, 10);
fill(70, 50, 80);
circle(600, 500, 50);
// circle
stroke(250, 200, 120);
fill(80, 0, 100);
circle(550, 700, 150);
Four circles.
Different positions.
Different sizes.
Different strokes.
Different fills.
One even overlaps another.
She wasn't simply copying a finished example.
She was playing with parameters.
She was discovering that one function can become many different things simply by changing its inputs.
At 7:56 in the morning, she sent one word:
“finish”
😊
The Next Little Challenge
After she finished, I didn't immediately give her another big assignment.
I asked:
“Could you find a way to make the filling color transparent so we can see through it?”
She replied:
“ok l will done later”
And I answered:
“Take your time and good luck.”
I particularly liked this little exchange.
The transparent-fill question wasn't something she had to finish immediately.
It was an invitation to explore.
She could search.
Experiment.
Try different parameters.
Break something.
Look at the documentation.
Try again.
The teacher could wait.
That is an important transition.
The problem belongs to her now.
There is a subtle but important difference between:
“I learned the circle() function.”
and:
“I needed to draw circles, so I figured out the circle() function.”
The second is much more powerful.
It is the beginning of self-directed programming.
The learner encounters a need.
The learner searches.
The learner experiments.
The learner makes something work.
And then the function becomes hers.
That is the habit I want to cultivate.
The ultimate goal is not for Enning to remember every p5.js function I teach her.
It is for her to eventually be able to say:
“I don't know how to do this yet. Let me find out.”
What Comes Next
And now we have another door waiting to open.
So far, Enning's circles are static.
They sit at positions such as:
circle(600, 500, 100);
Next time, we can help her make a circle move.
Suddenly the numbers will no longer be just coordinates describing a picture.
They can become variables that change over time.
The circle can move.
Then perhaps bounce.
Then perhaps follow the mouse.
Then perhaps several circles can move independently.
And without announcing it as a grand curriculum plan, Enning will be walking naturally from:
drawing
→ coordinates
→ parameters
→ variables
→ change
→ motion
→ animation
That's how a little circle can become a doorway into programming.
Why This Moment Matters
Enning is not simply accumulating programming commands.
She is accumulating something much more valuable:
the confidence to find the next command herself.
Five days ago:
almost zero coding experience.
Today:
“I need circles.”
→ discover circle()
→ experiment with parameters
→ create four different circles
→ finish the assignment
→ receive a new challenge
→ “I'll do it later.”
That last step is important.
She is beginning to own the learning process.
The Museum Grows
A museum is made of artifacts.
Our Living Museum is also made of moments when something becomes possible for the first time.
The first iOS app.
The first geometric drawing.
The first triangle.
The first successful debugging.
The first unfamiliar English word sent to the dictionary.
And now:
The first p5.js function Enning taught herself.
circle()
It's only one function.
But behind that function is something much bigger:
independence.
And next time, perhaps that circle will move.
The museum will gain another little artifact.
And Enning will gain another little piece of the world. 🌱
A learner can move from zero coding experience to independently discovering the tools needed to create something meaningful.
Give a concrete challenge, provide guidance when needed, then leave enough space for the learner to search, experiment, make mistakes, and discover.
Because the ultimate goal of teaching isn't to make the student dependent on the teacher.
It is to help the student eventually say:
“I don't know how to do this yet. Let me figure it out.”
And then make the circle move. 🌱