WEBVTT
Kind: captions
Language: en

00:00:12.849 --> 00:00:14.559
Hi everybody.

00:00:14.559 --> 00:00:16.559
I'm Mike Deutsch.

00:00:16.779 --> 00:00:24.179
And I'm here to present this pre-recorded session for OAME 2020 and I'm calling Math by way of micro:bits

00:00:25.930 --> 00:00:28.289
Welcome to the session. You're watching this pre-recorded

00:00:29.050 --> 00:00:35.550
coming to you live from my basement in Montreal and I want to start by thanking the organizers of OAME.

00:00:36.219 --> 00:00:38.219
First for inviting speakers

00:00:38.559 --> 00:00:40.619
second for for accepting this talk and

00:00:41.230 --> 00:00:43.469
third for helping the show go on.

00:00:43.469 --> 00:00:49.259
I came to my first OAME in 2019 last year in Ottawa and

00:00:49.629 --> 00:00:55.319
just had a blast. So I'm really excited to present again. So this is a reprise of last year's session:

00:00:55.870 --> 00:01:00.030
Math by way of micro:bits and as the session description suggests

00:01:00.460 --> 00:01:04.890
I've updated it to put more focus on sense making.

00:01:05.500 --> 00:01:08.519
The pedagogical approach that a lot of OAME

00:01:09.670 --> 00:01:11.850
talks speak about

00:01:12.610 --> 00:01:17.429
that I've taken to heart and have started to build into kidscode jeunesse

00:01:18.070 --> 00:01:19.600
programming.

00:01:19.600 --> 00:01:21.869
So with that introduction, let's begin -

00:01:23.259 --> 00:01:25.259
Math by way of micro:bits.

00:01:27.820 --> 00:01:32.610
I'll actually start by talking a little bit about kidscode jeunesse, the organization I work for.

00:01:33.159 --> 00:01:36.449
So KCJ is a non-profit a charity

00:01:37.030 --> 00:01:39.540
that began in Montreal and is now

00:01:40.659 --> 00:01:43.289
present all across Canada. We have people in every

00:01:44.110 --> 00:01:46.110
province.

00:01:46.149 --> 00:01:51.929
And as an organization, we're bilingual we deliver all of our services in English and French and

00:01:52.570 --> 00:01:54.570
what we produce is

00:01:54.909 --> 00:01:56.909
materials and

00:01:57.399 --> 00:01:59.399
workshops and teacher training

00:02:01.119 --> 00:02:03.718
dealing with computational thinking, coding and

00:02:04.960 --> 00:02:06.700
artificial intelligence.

00:02:06.700 --> 00:02:10.259
So I'm going to share with you today a portion of that.

00:02:10.899 --> 00:02:12.310
We do

00:02:12.310 --> 00:02:19.750
Scratch, we do micro:bits, we do AI and we do other platforms besides as as they come and go over the years.

00:02:20.840 --> 00:02:26.050
We're also the sponsors of Code Club all across Canada. So

00:02:27.680 --> 00:02:29.680
you may have seen a

00:02:29.750 --> 00:02:34.179
Code Club or you may have seen someone from kids code jeunesse come into your classroom

00:02:34.180 --> 00:02:37.150
or you may have even attended a teacher training seminar.

00:02:38.480 --> 00:02:41.350
In 2018-2019 school year we were

00:02:42.110 --> 00:02:44.559
everywhere in Ontario as you see on the map here.

00:02:45.080 --> 00:02:49.509
Working with all kinds of school boards and in 2019-2020, of course

00:02:49.520 --> 00:02:56.380
we've been cut short for the time being but we've had four in-person teacher training events - two in English - two in French and

00:02:57.110 --> 00:03:05.110
almost 300 in classroom workshops across the province. So we're no strangers to Ontario and we

00:03:05.750 --> 00:03:11.320
love working with you all. So I'm based in Montreal but we have a great team around Ontario.

00:03:13.459 --> 00:03:17.679
Our primary audience at KCJ is middle grade

00:03:18.980 --> 00:03:21.160
schooling, grades 3 to 8.

00:03:22.340 --> 00:03:24.340
We focus primarily on

00:03:24.530 --> 00:03:28.089
generalist teachers and students. So by that we mean we're not

00:03:28.610 --> 00:03:33.190
so focused on specialists, we don't get deep deep into stem and robotics

00:03:33.380 --> 00:03:36.969
but what we are really good at is being the first step or two

00:03:37.640 --> 00:03:45.160
on your journey into coding in a way that you could use coding for all different kinds of curricular and on curricular applications.

00:03:46.850 --> 00:03:48.850
As far as our pedagogical approach

00:03:51.049 --> 00:03:54.189
computing education varies. There are lots of different approaches to it.

00:03:55.730 --> 00:04:00.640
You may have seen if you've done coding lessons in the past, a kind of follow me approach

00:04:01.400 --> 00:04:08.170
where I build something and I do all of it and then just tell you to follow me and copy what I did.

00:04:08.780 --> 00:04:10.869
We try very hard not to do that.

00:04:12.320 --> 00:04:18.189
We try to teach in a way that supports sense making - a topic close to OAME's heart

00:04:19.160 --> 00:04:20.239
and

00:04:20.239 --> 00:04:25.538
our feeling is that when you teach the right way and you give teachers and students agency

00:04:26.150 --> 00:04:31.280
they're able to develop self-efficacy. And of course, there's positive effect that comes out of that.

00:04:32.820 --> 00:04:34.820
So myself I'm the director of

00:04:35.370 --> 00:04:41.120
Educational R&D at KCJ. I came to KCJ and computing education as a second career.

00:04:41.120 --> 00:04:47.299
I spent almost 20 years in the software world and doing various jobs as a product manager.

00:04:48.470 --> 00:04:51.739
I joined KCJ two years ago in 2018

00:04:51.980 --> 00:04:55.009
and I've also for a few years now been working on an MA,

00:04:55.250 --> 00:05:01.520
a master's degree in math education at McGill and so a lot of the pedagogical approach that KCJ has been adopting in the last couple

00:05:01.520 --> 00:05:04.879
of years comes from the things that I'm learning in the math community.

00:05:06.840 --> 00:05:11.690
You all are doing fantastic innovative stuff and if you're an OAME veteran you know that.

00:05:13.350 --> 00:05:20.689
So here's what I expect your profile look something like. You're an experienced teacher if you're attending OAME probably.

00:05:21.660 --> 00:05:26.570
You already know mathematics, you know the content that you teach and you know, how you like to teach it.

00:05:27.120 --> 00:05:32.840
Um, you may have been attracted to this session because you're aware of micro:bits and you have micro:bits

00:05:34.350 --> 00:05:38.629
accessible to you or maybe you're just curious about investing in them and

00:05:39.780 --> 00:05:43.760
you want to try building an exercise that explores math through code.

00:05:44.610 --> 00:05:47.600
So I don't assume that you've done any coding.

00:05:49.230 --> 00:05:53.089
You won't need any previous experience to complete the things that we're going to do here.

00:05:53.090 --> 00:05:58.489
So I say maybe you've done some block coding before, Scratch or Blockly or something like that.

00:05:58.490 --> 00:06:00.740
But maybe you haven't and and that won't hurt you here.

00:06:03.090 --> 00:06:05.090
Okay

00:06:05.430 --> 00:06:10.640
So here's a rundown of what I expect to cover here, I'm gonna start by laying some context.

00:06:10.860 --> 00:06:14.150
I'll talk about the background of math and coding and how they fit together.

00:06:15.240 --> 00:06:21.919
I'll connect that back to some of the things that I saw at OAME 2019 and the pedagogical approach

00:06:22.860 --> 00:06:27.110
that KCJ tries to use and then we'll actually look at a micro bit

00:06:28.740 --> 00:06:35.090
and how they work. And from there we'll spend the bulk of our time demonstrating five starter projects and

00:06:35.789 --> 00:06:42.989
tasks classroom tasks that go along with it that are focused on number sense and numeration and patterning and

00:06:43.390 --> 00:06:49.140
algebra. Those are the mathematics strands in the Ontario curriculum that are most closely aligned with what you'll see here today.

00:06:49.750 --> 00:06:53.459
So I expect because this is prerecorded you'll be able to build along with me.

00:06:54.490 --> 00:06:58.859
Much like we do when we teach online remotely like in classroom webinars

00:06:59.710 --> 00:07:02.579
I'll build some things on the screen just by necessity

00:07:02.580 --> 00:07:06.090
I don't have the ability to turn it over to you and ask you well

00:07:06.090 --> 00:07:08.100
how do you think you'd do this or let you tinker?

00:07:08.170 --> 00:07:10.740
So what I'm gonna do is demonstrate how these things are built

00:07:10.930 --> 00:07:15.930
and then I'll leave the code on the screen where you can pause and then build along to match me.

00:07:16.960 --> 00:07:21.960
And then I hope that you'll be able to brainstorm some adaptations for how you would use this in your classroom.

00:07:24.010 --> 00:07:29.459
What I think you'll find is that the code over the course of these five projects

00:07:30.250 --> 00:07:33.959
the code over these five projects will slowly build in complexity.

00:07:34.000 --> 00:07:38.820
We won't ever reach anything that's too intricate for you to understand even if you're a newcomer.

00:07:40.090 --> 00:07:43.649
And as we build up the code complexity across those five projects

00:07:43.650 --> 00:07:47.070
you'll see that the tasks you can accomplish with those, the instructional routines

00:07:47.070 --> 00:07:50.489
you can do also get a little more complex and a little more rich

00:07:51.280 --> 00:07:52.480
mathematically.

00:07:52.480 --> 00:07:55.079
And my hope is that the two will reinforce each other.

00:07:55.690 --> 00:07:57.690
I'm going to show you a

00:07:58.210 --> 00:08:00.660
manipulative essentially built on a micro:bit.

00:08:01.660 --> 00:08:07.469
We'll talk about what you can do with an instructional routine that uses this manipulative and we'll have to understand okay

00:08:07.470 --> 00:08:09.100
well if I want to build that

00:08:09.100 --> 00:08:13.379
what are the code steps that I need to build in order to get the micro:bit to do this thing?

00:08:13.600 --> 00:08:18.899
I'll have to understand a little bit of code to build it and I'll do that instructional routine and that

00:08:19.180 --> 00:08:25.290
probably will prompt me to think well, okay, this is cool. What if I wanted to push this further? I'll have to think about

00:08:25.840 --> 00:08:32.040
mathematically, how do I want to go further and then translate that into code and and back and forth and back and forth and you'll

00:08:32.040 --> 00:08:34.040
see that expand over five projects.

00:08:35.110 --> 00:08:39.689
Okay, so a little bit of mathematical pedagogical background.

00:08:40.600 --> 00:08:44.699
There's actually quite a long history several decades of computing education

00:08:45.370 --> 00:08:47.370
overlapping with math.

00:08:47.530 --> 00:08:50.610
There are some very natural surface-level reasons

00:08:50.610 --> 00:08:58.419
which are that there's common terminology and common mechanisms between math computing. Things like repeating the same step multiple times,

00:08:59.600 --> 00:09:02.950
holding on to distinct values at the same time.

00:09:04.340 --> 00:09:07.689
But there's actually commonalities deeper than that and those include

00:09:08.690 --> 00:09:14.080
the reasons that coding activates so many of the practices that we try to develop in math.

00:09:14.270 --> 00:09:19.509
The mindset that you take on as a coder is very similar to the mindset you take on as a mathematician -

00:09:20.420 --> 00:09:21.800
performing calculations,

00:09:21.800 --> 00:09:25.120
trying to prove and explore and make models work.

00:09:26.150 --> 00:09:31.569
So I've taken a quote here from Mark Guzdial who's a computing education researcher and professor.

00:09:32.210 --> 00:09:39.819
And he actually comes from the original school of computing education, which was Seymour Papert and the Logo school.

00:09:42.050 --> 00:09:49.240
Mark is now a researcher at University of Michigan and he presented this at the special interest group for computer science education,

00:09:49.760 --> 00:09:51.170
SIGCSE

00:09:51.170 --> 00:09:57.820
which is part of the ACM, the Association for Computing Machinery. And what he says was that teaching mathematics with code

00:09:58.370 --> 00:10:04.599
is a unique learning experience. In this kind of class students have opportunities to quote unquote teach mathematics.

00:10:06.230 --> 00:10:08.349
Not just learn mathematics but teach mathematics.

00:10:08.350 --> 00:10:13.060
So what does he mean by that? When a student writes code the student is teaching the computer

00:10:13.220 --> 00:10:16.870
how to complete a task and that's a very deep idea that comes from

00:10:17.810 --> 00:10:24.310
the very very first generation of computing education with Logo and the turtle out of MIT.

00:10:24.310 --> 00:10:26.310
You may have heard the name Seymour Papert.

00:10:26.720 --> 00:10:28.460
He and

00:10:28.460 --> 00:10:31.449
and others were the ones who became the originators of that.

00:10:32.360 --> 00:10:38.830
Now so I can even link that to specific mathematical processes that are in the Ontario

00:10:39.380 --> 00:10:45.010
Mathematics curriculum. This is the grade 1 to 8 math curriculum and the URL is there.

00:10:45.680 --> 00:10:51.880
So when you're coding just as in math, you're problem-solving. You have to reason and prove out

00:10:52.760 --> 00:10:59.559
why your ideas will work or not work. You reflect on the things that you tried and succeeded or failed at.

00:10:59.870 --> 00:11:01.870
You have to choose which tools

00:11:02.210 --> 00:11:04.210
from among the ones that are at your disposal

00:11:04.610 --> 00:11:06.389
Etc, etc.

00:11:06.389 --> 00:11:11.568
So there are some real big commonalities. Um next I want to talk about OAME from last year.

00:11:11.569 --> 00:11:16.789
That was my first time at the conference and my eyes were really opened. So I've been studying this

00:11:17.339 --> 00:11:19.458
academically for a few years in my master's program.

00:11:20.970 --> 00:11:25.429
But to see an entire conference full of speakers and attendees

00:11:26.220 --> 00:11:29.089
nodding their heads and really getting these ideas was

00:11:29.879 --> 00:11:35.058
just spectacular for me. So Ontario math community, you're doing something right.

00:11:35.819 --> 00:11:43.069
I'll talk specifically about two speakers that I remember very clearly and I took photos from. One was Graham Fletcher.

00:11:44.189 --> 00:11:48.978
Now last year he challenged us to think about two different things that I thought were worth discussing here.

00:11:49.769 --> 00:11:55.188
One is are we asking students to learn math in order to solve problems?

00:11:56.339 --> 00:12:03.318
In other words, okay kids I'm gonna show you how this part of math works. I'll just instruct you on how to do this

00:12:04.049 --> 00:12:06.469
then we're gonna pivot to solve problems

00:12:07.289 --> 00:12:13.009
where these tools are helpful. That that I think is what he takes to be the classic way of teaching math.

00:12:13.769 --> 00:12:18.258
But now there seems to be a pendulum swing right and and we've reversed that so

00:12:18.989 --> 00:12:24.589
the popular way of teaching math more and more is to confront kids with problems that

00:12:25.350 --> 00:12:28.909
they're going to have to grapple with without already

00:12:29.489 --> 00:12:32.029
knowing the mathematical tools that will get that job done.

00:12:32.029 --> 00:12:37.909
And the way he positioned that is to flip it around that we're asking them to solve problems in order to learn math.

00:12:38.129 --> 00:12:41.538
The problem comes first, and that's how we confront problems in the world

00:12:41.759 --> 00:12:45.589
and we have to figure out or maybe invent the tools to solve those.

00:12:48.029 --> 00:12:50.029
Second idea I captured from Graham

00:12:51.359 --> 00:12:54.859
was he challenged us to think. In any given hour of

00:12:55.470 --> 00:12:57.470
math instruction that we do

00:12:57.600 --> 00:13:04.100
who is in control of the learning the teacher or the students? And he has this bar chart here.

00:13:08.519 --> 00:13:10.259
The the classic

00:13:10.259 --> 00:13:15.498
math room probably looks like the teachers in control of the learning doing more and more instructing

00:13:15.499 --> 00:13:19.488
the students are absorbing and then trying to

00:13:20.120 --> 00:13:25.099
repeat back or or do what the teacher has modeled and he challenged us to invert that.

00:13:28.170 --> 00:13:32.539
The second person that really struck me that I captured was Marian Small.

00:13:33.480 --> 00:13:35.870
And she and a number of other speakers

00:13:36.480 --> 00:13:43.310
illustrated a bunch of tasks that were very very thought-provoking and she said in particular here are some tasks that ask students to think.

00:13:44.550 --> 00:13:48.080
She had a very specific definition of that. To think

00:13:48.450 --> 00:13:52.460
the way she was thinking of it here is to make sense of something and to figure out what to do.

00:13:54.210 --> 00:13:57.589
So contrast a more classic way of asking

00:13:58.980 --> 00:14:00.720
this kind of task.

00:14:00.720 --> 00:14:03.290
Students, I want you to decompose the number 42

00:14:03.839 --> 00:14:08.989
into tens and ones. That might be the old way of doing it. And the new way might be

00:14:09.450 --> 00:14:11.839
what are the ways that we could decompose

00:14:12.360 --> 00:14:14.360
42 into groups and

00:14:15.270 --> 00:14:16.980
why?

00:14:16.980 --> 00:14:23.210
So it's easy to see how the second one pulls the students attention to very different things than the first one does.

00:14:24.300 --> 00:14:26.300
In the first one, it's it's

00:14:26.459 --> 00:14:31.759
presupposing that I've taught you how to decompose into tens and ones what tens are and what ones are.

00:14:32.279 --> 00:14:34.279
The second one doesn't seem to presuppose that.

00:14:34.560 --> 00:14:37.250
You could give that problem to a younger student who

00:14:37.470 --> 00:14:42.410
doesn't know the rudiments and you just see what sense they make of this and in a classroom full of kids

00:14:42.690 --> 00:14:45.499
you'll find interesting things and from that you can

00:14:46.709 --> 00:14:50.119
consolidate their understanding and start to give things formal names.

00:14:51.750 --> 00:14:53.750
So I sat at OAME

00:14:54.420 --> 00:15:02.029
2019 and and just really loved this. It brought so many things together that for me are directly applicable to teaching coding.

00:15:03.089 --> 00:15:08.449
And so that's why in the spirit of of those things I just discussed in the rest of this workshop

00:15:08.450 --> 00:15:14.539
we're going to build five sample projects five simple projects together. And as I said, they slowly build up in complexity.

00:15:15.959 --> 00:15:21.139
And the idea is that you and your students will be able to build these yourselves and use them in the classroom

00:15:21.480 --> 00:15:24.380
like manipulatives that you yourself have built

00:15:25.140 --> 00:15:27.140
in instructional routines.

00:15:27.330 --> 00:15:31.159
So you probably already have instructional routines that you lean on

00:15:32.210 --> 00:15:33.990
on a regular basis

00:15:33.990 --> 00:15:35.190
and

00:15:35.190 --> 00:15:37.429
my hope is that these will fit right into that.

00:15:38.070 --> 00:15:42.020
And I want to be clear in in contrast with other kinds of coding education

00:15:42.120 --> 00:15:46.370
you may have seen other coding lessons the emphasis here will not be on

00:15:47.010 --> 00:15:50.989
you know what amazing things I got this micro:bit to do.

00:15:52.500 --> 00:15:55.940
There there's plenty of room for that later on but when you're a beginning coder

00:15:57.240 --> 00:16:00.979
it's better to put the focus on the thinking that I can do

00:16:01.230 --> 00:16:05.089
with this programs tool that I made and that's where we're gonna look today.

00:16:05.880 --> 00:16:12.739
The coding that goes into the micro:bit and the mathematical thinking that you do with the micro:bit will reinforce one another.

00:16:14.160 --> 00:16:15.720
Okay

00:16:15.720 --> 00:16:20.060
so as I say I've been inspired by OAME and and this school of

00:16:20.399 --> 00:16:21.690
pedagogy and

00:16:21.690 --> 00:16:28.010
so I've built an instructional routine that we now use pretty pretty often at kids code jeunesse. When we walk into a classroom and introduce

00:16:28.010 --> 00:16:30.010
students to micro bits

00:16:30.420 --> 00:16:35.959
we don't simply open up a browser and start to code. What we've started to do is start with a finished product.

00:16:36.570 --> 00:16:40.879
Start with a micro:bit or a scratch project or whatever platform we're teaching that day

00:16:41.850 --> 00:16:43.850
start with a finished product that we've built

00:16:44.339 --> 00:16:51.409
that has our thinking embedded inside this and our tinkering and our mistakes and corrections built inside here.

00:16:52.470 --> 00:16:54.470
And we invite students

00:16:54.839 --> 00:16:56.839
into an instructional routine.

00:16:58.440 --> 00:17:01.010
And we ask them much like you would in math class

00:17:03.270 --> 00:17:06.079
to notice what you see on this micro bit.

00:17:07.020 --> 00:17:11.389
Notice what it's doing. Notice how I'm interacting with it and think about

00:17:12.480 --> 00:17:14.689
what can't you see that you'd like to know more about.

00:17:16.199 --> 00:17:19.699
So just like a classic notice and wonder routine that you've done in math

00:17:20.100 --> 00:17:22.370
this puts everybody in the classroom on an equal footing.

00:17:22.439 --> 00:17:29.119
This is all about for the first few minutes of this lesson with your eyes and ears and your senses and your and your noggin,

00:17:29.640 --> 00:17:31.640
what what sense do you make of this?

00:17:32.820 --> 00:17:36.950
So, let me actually put my micro:bit down for a moment and because I've got this nice and enlarged

00:17:38.130 --> 00:17:39.920
version of a micro bit on the screen

00:17:39.920 --> 00:17:46.019
I'm just gonna mouse around the micro:bit here. If you've never seen one before it's worth just to look around what on it.

00:17:47.080 --> 00:17:49.080
So the first thing is

00:17:49.570 --> 00:17:56.249
this 5x5 grid of red LED lights and that's used as a readout screen or display.

00:17:56.679 --> 00:17:59.158
You can put icons you can put numbers letters

00:17:59.679 --> 00:18:01.679
scrolling messages.

00:18:01.960 --> 00:18:03.960
You can plot

00:18:03.999 --> 00:18:09.118
points on this field of LEDs with an XY grid by coordinate.

00:18:10.629 --> 00:18:14.039
Another thing that jumps out is these two buttons here A and B.

00:18:14.259 --> 00:18:16.738
And when you hold the micro:bit in your hands it has this wonderful

00:18:17.710 --> 00:18:25.679
you know Nintendo feel to it. It really lends itself to, oh man, I want to play games with this thing. It's very very interactive.

00:18:26.349 --> 00:18:28.349
But only two buttons so it's approachable.

00:18:28.929 --> 00:18:32.638
It has a strip of connecting pins down here.

00:18:33.369 --> 00:18:39.899
And these can be used for connecting to third party electronics kits, stem kits that you can buy from other providers

00:18:40.690 --> 00:18:46.889
or just with alligator clips or aluminum foil, you can connect up to circuitry and

00:18:49.029 --> 00:18:51.329
attach the micro:bit to other accessories.

00:18:52.599 --> 00:18:54.599
On the back which you can't see there

00:18:57.489 --> 00:19:01.139
it's got some sensors built in. I can see the processor.

00:19:02.169 --> 00:19:04.169
I can see the circuitry.

00:19:04.330 --> 00:19:11.099
It tells me here that there's an antenna. This can send and receive radio signals between micro bits and it can send and receive

00:19:11.470 --> 00:19:14.189
bluetooth messages from your tablet or computer.

00:19:15.940 --> 00:19:20.129
A reset button here. There's an accelerometer built in.

00:19:20.649 --> 00:19:27.059
So the micro:bit that can sense when it's being moved or tilted or accelerated. You can use that for science projects.

00:19:28.989 --> 00:19:34.469
What else? There's a magnetometer on here which can act as a compass if I calibrate it and

00:19:35.649 --> 00:19:40.888
a temperature sensor. It's built on to the chip so it can be a very rudimentary

00:19:42.609 --> 00:19:44.609
thermometer.

00:19:44.710 --> 00:19:45.639
And-and-and-and, right.

00:19:45.639 --> 00:19:53.008
So I've I've powered this one by connecting it to a USB cable to my laptop that I'm doing this presentation on right now.

00:19:53.009 --> 00:19:56.669
So it's powered you can see my yellow LED is lit up here.

00:19:57.540 --> 00:20:00.239
But you can also attach it to a battery pack and

00:20:00.850 --> 00:20:08.310
then untether yourself from a computer and use your micro bit in the field. So micro bits are good for gym class for taking measurements

00:20:09.310 --> 00:20:11.310
out in a field

00:20:11.920 --> 00:20:18.329
in school. So they're they're a really versatile accessible tool. You can do a lot with micro:bits.

00:20:20.980 --> 00:20:24.690
So I'm going to begin with this notice and wonder routine and I'm going to

00:20:26.470 --> 00:20:28.470
pause my sharing for the moment

00:20:29.980 --> 00:20:34.199
and just concentrate here, okay, so I've got a micro bit in front of me

00:20:35.440 --> 00:20:37.440
Um, and I want you to notice

00:20:38.320 --> 00:20:40.320
what it can do.

00:20:40.870 --> 00:20:43.260
Tapping the A button it's not doing anything with that.

00:20:44.620 --> 00:20:46.620
Tapping the B button it's not doing that

00:20:48.010 --> 00:20:50.550
If I invert it or tilt it

00:20:51.220 --> 00:20:53.220
that doesn't seem to be doing anything and

00:20:54.010 --> 00:20:59.520
as you can see it's not connected to any circuitry or other accessories. So what is this micro:bit set to do?

00:21:04.210 --> 00:21:08.820
Well, one thing I mentioned that I haven't tried yet is to shake it. So if I shake it

00:21:10.930 --> 00:21:12.930
something appears on the screen and

00:21:15.460 --> 00:21:18.150
I'm gonna stick a little piece of masking tape over the front here.

00:21:19.420 --> 00:21:20.820
This is a trick

00:21:20.820 --> 00:21:24.929
we've learned in the classroom that when you when you have a piece of tape or post-it note or something over it

00:21:25.000 --> 00:21:27.000
it's just a little easier

00:21:27.310 --> 00:21:31.589
in full daylight to see those LEDs. So I shook it. And what is that?

00:21:33.760 --> 00:21:38.520
So those of you that have some experience with micro:bits will immediately know what that is. Let me let me shake it again. Oh

00:21:40.150 --> 00:21:43.589
that didn't change nope. I shook it again.

00:21:46.510 --> 00:21:50.910
Can you figure out what this is now? This is a canonical

00:21:53.050 --> 00:21:56.909
introductory micro:bit project I've built a rock-paper-scissors game here, right?

00:21:56.980 --> 00:22:02.610
So it uses the accelerometer that's built-in and the instructions I've given it are when when I shake it

00:22:04.060 --> 00:22:10.769
Randomly pick rock paper or scissors and show it on the LED screen. So this is a great introductory project, but I'll leave this here.

00:22:14.620 --> 00:22:16.620
And I'll come back

00:22:18.520 --> 00:22:20.520
to my presentation.

00:22:30.480 --> 00:22:32.070
So

00:22:32.070 --> 00:22:34.519
Now we're gonna start building these projects, okay.

00:22:35.190 --> 00:22:38.720
A series of five projects that I'm calling click counting.

00:22:38.970 --> 00:22:42.769
That's the kind of project we're gonna do. We're not going to get into circuitry or

00:22:43.350 --> 00:22:47.779
taking data measurements or angles or anything like that. Although the micro:bit can do those.

00:22:48.510 --> 00:22:51.710
Today we're gonna focus on number sense numeracy.

00:22:53.010 --> 00:22:54.690
So the overall

00:22:54.690 --> 00:23:00.710
outline of all five projects is the same. We're going to instruct the micro:bit to remember a numerical value.

00:23:01.050 --> 00:23:03.050
Keep that in its computer memory.

00:23:03.510 --> 00:23:06.920
When we click the buttons, it's going to do a math operation on it.

00:23:06.920 --> 00:23:10.730
And then it's going to show the value on the LED screen and that's it.

00:23:11.550 --> 00:23:13.550
Super super simple.

00:23:13.980 --> 00:23:15.980
Okay

00:23:16.500 --> 00:23:23.330
The first one is a simple click counter and I'm just going to focus on the first one here and then we'll flip over

00:23:24.150 --> 00:23:25.320
to

00:23:25.320 --> 00:23:29.570
the micro:bit interface and we'll actually build this a simple click counter.

00:23:30.690 --> 00:23:35.269
When I power up the micro:bit I want it to start by remembering a value of zero.

00:23:35.850 --> 00:23:38.990
We use a variable to do that. When I click a button

00:23:38.990 --> 00:23:44.539
I want it to add 1 to that value and then show the value show the current value of that variable.

00:23:45.660 --> 00:23:50.090
Okay, and when you've got this built it's easy to imagine it

00:23:50.730 --> 00:23:55.999
being used in the classroom to keep score if you're playing a game in class or in gym.

00:23:56.970 --> 00:24:02.659
To count off steps if you're measuring something or even to act out some simple addition problems.

00:24:03.720 --> 00:24:10.339
So let's move over to my browser. And did I have the URL? Yeah I am going to leave the URL here for a sec.

00:24:11.910 --> 00:24:17.720
If you've never been there this is the URL to go to makecode.microbit.org

00:24:23.670 --> 00:24:29.700
So much like scratch if you've never used that or most other block coding platforms these days

00:24:31.120 --> 00:24:35.070
all of your coding takes place right in a web browser. You're on their website and

00:24:36.190 --> 00:24:44.159
the people who built this have given us a whole vocabulary of instructions that we can use in the form of blocks

00:24:46.090 --> 00:24:48.779
to give instructions to a micro:bit.

00:24:49.030 --> 00:24:55.739
Okay, so down the center here is the entire vocabulary the entire instruction set that they've given us and

00:24:56.260 --> 00:25:00.030
like in other platforms these are color-coded by theme.

00:25:00.970 --> 00:25:07.409
So they've decided they're certain a set of core instructions that are the most common to use and they call this the basic group.

00:25:07.750 --> 00:25:12.359
Then there's inputs and that's anything that uses the data sensors or the buttons.

00:25:13.750 --> 00:25:20.820
There's music. There's LEDs where you can plot and unplot the LEDs on the screen by XY coordinates.

00:25:21.160 --> 00:25:23.279
There's radio communication and

00:25:24.910 --> 00:25:28.590
mathematical operations, we'll get into those in a moment and on and on and on.

00:25:30.070 --> 00:25:33.989
But just to orient you to where you are on the screen the vocabulary that you have to work with

00:25:33.990 --> 00:25:35.990
your instruction set is here in the middle.

00:25:36.700 --> 00:25:39.869
You're going to actually drag those blocks on to the workspace

00:25:40.000 --> 00:25:44.369
here where we build the script what our micro:bit is actually going to do and

00:25:45.580 --> 00:25:48.479
then over on the left they've given us this nice emulator.

00:25:50.110 --> 00:25:56.460
That emulator can do basically anything a real physical micro:bit can do which is wonderful. It means that when we go into classrooms

00:25:58.330 --> 00:26:05.609
if they've got micro bits or if they don't first of all every kid doesn't need to have their own we do pairs or triples.

00:26:06.910 --> 00:26:08.650
So

00:26:08.650 --> 00:26:11.670
your micro:bits can go farther than one-to-one, which is nice

00:26:12.040 --> 00:26:16.649
but also you can do this on a computer without a physical micro:bit and I'm betting that

00:26:17.020 --> 00:26:21.420
most of you don't have a micro:bit at home while you're attending this conference remotely either.

00:26:21.730 --> 00:26:26.850
So you'll be able to do all of this coding and test out everything that you do inside this emulator.

00:26:27.250 --> 00:26:32.580
Every time I add or change to my code that emulator is going to refresh we'll see that in a minute

00:26:33.430 --> 00:26:35.350
and then we can run

00:26:35.350 --> 00:26:41.850
our program and verify that it does we want to do. So as I showed you in our first routine

00:26:42.790 --> 00:26:48.690
this is a click counter.  If you can still see in my in my small window here

00:26:50.230 --> 00:26:52.799
I'm going to stop presenting. We'll come back to this for a sec.

00:26:53.680 --> 00:26:58.919
All this does my click counter is starts at 0 when I start up if I

00:26:59.350 --> 00:27:03.629
Hit the reset button on the back here,  it starts back at 0 and it displays its value

00:27:04.990 --> 00:27:08.699
and every time I click it counts up, that's all it does.

00:27:09.520 --> 00:27:13.020
Super super simple. And in fact, we can accomplish this with 4 lines of code.

00:27:13.690 --> 00:27:19.230
And this will keep going and going and going in and what's going to happen when we get to 10

00:27:20.860 --> 00:27:28.139
it just automatically starts to scroll right because you can't fit that number on a single screen full so it scrolls

00:27:29.320 --> 00:27:30.790
um

00:27:30.790 --> 00:27:33.029
So that's that's it. I'm going to leave that down.

00:27:36.040 --> 00:27:38.040
Let's come back to make code.

00:27:41.260 --> 00:27:43.560
Every make code project when you start a new one

00:27:44.020 --> 00:27:46.710
starts with these two starter blocks the micro:bit

00:27:46.990 --> 00:27:50.639
is ready to take anything that you want to do when it first powers up

00:27:50.740 --> 00:27:54.569
Is there anything you want me to do to get started before your program really gets going?

00:27:55.480 --> 00:27:56.850
Yes, we're gonna hold on to that.

00:27:56.850 --> 00:28:01.529
And is there anything that you want running forever and ever and ever in the background in a loop?

00:28:02.650 --> 00:28:06.930
Um while it's doing other things and in this case, no, I'm not interested in that.

00:28:07.990 --> 00:28:12.539
So code along with me or you can wait a few minutes until I'm done

00:28:12.540 --> 00:28:16.560
I'll take a pause and you can copy what I've done. The first thing I need to do in

00:28:17.230 --> 00:28:22.649
my algorithm is create a counter. I need to create a value that the micro:bit is gonna hold in its memory

00:28:23.830 --> 00:28:26.460
and I'm gonna I'm just going to call that count.

00:28:28.240 --> 00:28:32.459
In in the world of math, you know middle school algebra

00:28:33.220 --> 00:28:35.220
you don't tend to use

00:28:35.230 --> 00:28:40.799
variables that are a word right a variable in mathematical sense is usually thought of as a single letter a

00:28:41.410 --> 00:28:44.610
Latin or Greek letter but in the world of computing

00:28:44.740 --> 00:28:51.679
we typically give them descriptive names because it's easier to remember what they're doing then if simple simple letter. So I'm gonna

00:28:52.140 --> 00:28:55.489
create a variable. I did a little two-step here. I created a variable.

00:28:55.490 --> 00:29:00.680
I did make a variable. It gave that to me now and it created a block that wasn't there before.

00:29:01.680 --> 00:29:03.320
And it gave me these other blocks

00:29:03.320 --> 00:29:09.320
which is I can set that variable to have a value of my choice and I can change that variable

00:29:10.950 --> 00:29:12.810
incrementally by

00:29:12.810 --> 00:29:18.619
some value that I want. And these these white ovals here, I can fill in any value that I like.

00:29:18.960 --> 00:29:22.790
So what I've done so far is I set count to zero. And

00:29:23.670 --> 00:29:30.409
the next next thing I need to do is on my emulator like it's done now but I don't see it because I haven't told

00:29:30.410 --> 00:29:36.889
the micro:bit to actually put that out on the screen. So I have to set count and then show.

00:29:38.580 --> 00:29:41.060
But I don't just want to show the number zero.

00:29:42.480 --> 00:29:45.589
I mean I could change that to show the number one or

00:29:46.740 --> 00:29:52.699
show the number two and you'll see my emulator is refreshing and it just shows what I'm telling it to show.

00:29:53.580 --> 00:29:57.710
But that's not a counter right? That's that's me coming in and

00:29:58.500 --> 00:30:03.859
messing with my code, doctoring my code each time. What I really want to do and this is the first leap

00:30:04.320 --> 00:30:08.780
that you're gonna have to make with your students is using a variable and

00:30:10.140 --> 00:30:12.650
plugging it into that oval. See that.

00:30:14.070 --> 00:30:21.020
So one cool thing about block programming languages that makes it really helpful for beginners is things are not only color coded, but they're

00:30:21.960 --> 00:30:23.700
shaped coded as well.

00:30:23.700 --> 00:30:27.080
So the shape of that 2 is an oval that

00:30:27.270 --> 00:30:31.790
suggests to me that I can snap in this oval block inside it and and that works.

00:30:32.610 --> 00:30:38.390
So already I've got my first two instructions when it starts up. It's going to set a variable called count to zero.

00:30:38.940 --> 00:30:41.540
Show that number on the LED screen

00:30:42.330 --> 00:30:43.830
Okay

00:30:43.830 --> 00:30:45.210
but

00:30:45.210 --> 00:30:49.730
so far on my emulator, I can see the A button isn't doing anything.

00:30:49.730 --> 00:30:54.980
I need to tell it that it's gonna do something. So on my inputs I have

00:30:55.500 --> 00:30:56.670
on

00:30:56.670 --> 00:30:58.670
button A pressed

00:30:59.010 --> 00:31:03.619
So I'm gonna get a second step of instructions that this micro:bit knows how do

00:31:04.289 --> 00:31:06.289
and I could say

00:31:06.360 --> 00:31:12.620
you know when button A is pressed do these instructions or B or even A and B together. For now

00:31:12.620 --> 00:31:14.620
I'm going to stick with A.

00:31:14.789 --> 00:31:22.069
When A is pressed again, I'm going to come back to that variable group. I'm gonna change that count by one.

00:31:26.549 --> 00:31:33.619
Okay, well it doesn't seem to be doing anything and why it doesn't seem to be doing anything is that I haven't

00:31:34.409 --> 00:31:40.789
shown what that value is now. I keep changing it and changing it and changing it and and I have to trust the micro:bit's

00:31:40.789 --> 00:31:46.069
doing that in it's memory but it's not updating that display. So I gotta ask you to do that again.

00:31:46.740 --> 00:31:48.740
Show number

00:31:49.529 --> 00:31:57.499
and I dragged it underneath this instruction because things execute step by step from top to bottom and

00:31:58.500 --> 00:32:00.500
just like I did up here, I

00:32:01.830 --> 00:32:05.569
have to show which number do I want to show?

00:32:07.049 --> 00:32:10.878
Count is the number I want to show that's going to be a numeric value.

00:32:11.519 --> 00:32:14.959
So I think that even maybe it look at that four lines of code.

00:32:16.950 --> 00:32:18.950
Does it work now?

00:32:22.559 --> 00:32:29.298
Voila and just like my demonstrator. I keep tapping and it goes up and up and up and up and up. Okay stop.

00:32:30.210 --> 00:32:36.259
I've reached a plateau. This is my click counter. It's done and so in the micro:bit interface if I want to save that

00:32:37.919 --> 00:32:45.439
I'm gonna call it how about a simple click counter. Click the that save icon.

00:32:47.549 --> 00:32:50.028
It downloads something on my browser

00:32:50.700 --> 00:32:52.700
you'll notice that it does the same and

00:32:53.129 --> 00:32:55.129
downloading is is a whole other thing.

00:32:55.350 --> 00:32:57.259
When we teach micro bits in the classroom

00:32:57.259 --> 00:33:03.589
you need to know how to download your instructions from the browser to your hard drive or your Google Drive and

00:33:04.169 --> 00:33:06.979
how to get that over a USB cable

00:33:07.379 --> 00:33:10.849
into the memory of your micro:bit. We're not going to deal with that right now.

00:33:10.850 --> 00:33:16.669
That's it's own thing but there are nice tutorials online for now. I'm just gonna stay in the browser simple

00:33:16.669 --> 00:33:20.989
Click counter. I have my plateau I've stopped and in fact, I'm gonna go home.

00:33:22.200 --> 00:33:25.670
So I'm back on makecode.micorbit.org

00:33:25.670 --> 00:33:30.769
This is the home page that I was at before and you'll notice that in my projects

00:33:30.770 --> 00:33:37.160
I now have this thing that I just saved 35 seconds ago. So if I ever came back to this browser on this machine

00:33:37.710 --> 00:33:41.510
It would keep this and a history of every other project that I built here.

00:33:43.080 --> 00:33:45.080
Even if I don't download

00:33:45.330 --> 00:33:49.280
The the code file and put it on the micro:bit. It's held here in my browser.

00:33:49.470 --> 00:33:55.370
If I want I can save that to my machine and I can email it. I can upload it to my classroom app

00:33:56.340 --> 00:33:58.340
and save it that way like a file.

00:33:59.700 --> 00:34:01.700
For now, I'm just keeping it in my browser and

00:34:03.210 --> 00:34:09.500
I'm gonna flip back to my presentation. So we've done this simple simple click counter. I'm gonna keep moving ahead.

00:34:09.500 --> 00:34:12.770
I'm now gonna do a skip counter and what does that algorithm look like?

00:34:13.500 --> 00:34:17.090
Start with 0 just like we did before when the button is clicked add

00:34:18.030 --> 00:34:19.560
something.

00:34:19.560 --> 00:34:21.769
Well as a teacher I can choose

00:34:22.200 --> 00:34:26.629
strategically like what numbers do I want my students to play with is it just adding by adding one?

00:34:27.480 --> 00:34:35.419
Well, what if we're ready to start adding two and adding three and adding five and higher numbers and then show the value same

00:34:35.419 --> 00:34:37.409
same outline and

00:34:37.409 --> 00:34:39.589
once we've got a micro:bit that works that way

00:34:40.500 --> 00:34:43.760
what what are the sorts of tasks that we could do?

00:34:44.399 --> 00:34:47.659
We could practice addition skip counting

00:34:48.690 --> 00:34:56.540
I could ask you that the Marian Small way.  I could ask my students. Okay, how could you get to the number 24 just using twos?

00:34:57.510 --> 00:34:59.689
With your skip counter?

00:35:00.450 --> 00:35:05.300
How many skips does it take? And your prompting them to learn repeated addition.

00:35:06.060 --> 00:35:12.590
If I wanted to do it a more Marian Small way, I would then ask, what are the different ways you could get to 24?

00:35:14.340 --> 00:35:19.189
And you'll see what I mean in a sec, so let's let's go back into the simple click counter.

00:35:20.390 --> 00:35:21.410
I'm just going to start here

00:35:21.410 --> 00:35:26.149
I'm gonna make some changes and then I'm gonna give it a new name and save it and I'll have two projects.

00:35:27.809 --> 00:35:32.179
So on start it's going to initialize a new variable.

00:35:34.109 --> 00:35:41.328
Code speak. On button A pressed, it's gonna change the count by one. I'm gonna change that to change the count by two.

00:35:44.069 --> 00:35:46.939
Let me just test that and see if it works the way I think it will

00:35:48.299 --> 00:35:51.439
2 4 6 8

00:35:53.819 --> 00:35:59.058
10 okay. Right away if you've got that built and you hold that up at the front of the room,

00:35:59.059 --> 00:36:01.059
you've got a choral counting exercise

00:36:01.410 --> 00:36:03.950
that you and your students can can fiddle with.

00:36:05.970 --> 00:36:09.769
So that's that button A let's say I'm gonna make button A be skip counting by 2

00:36:11.069 --> 00:36:17.538
and I want to give button B something else to do. So, I'm gonna drag that into my screen here on button B pressed

00:36:19.619 --> 00:36:23.028
You notice there it came as button A and it was greyed out like that.

00:36:23.819 --> 00:36:26.869
That's the micro:bit interface telling us we've got

00:36:27.180 --> 00:36:32.210
2 things that are trying to work on button A and it's not gonna allow that so it disables one of them.

00:36:32.309 --> 00:36:35.179
But if I switch this to B, then they'll both work.

00:36:36.930 --> 00:36:38.930
I want to

00:36:38.999 --> 00:36:44.238
just gonna copy that code change the count by 5 let's say. And again

00:36:46.470 --> 00:36:50.569
show number. Which number do I want to show? I want to show my

00:36:51.660 --> 00:36:52.859
variable.

00:36:52.859 --> 00:36:57.619
Count. Okay. So my emulator just refreshed and came back. Let's see

00:36:57.619 --> 00:37:01.578
I have a skip counter with 2 on the A button and

00:37:02.970 --> 00:37:04.970
if I click B

00:37:05.730 --> 00:37:10.609
it skips from 6 to 11 and now to 16 and

00:37:11.880 --> 00:37:13.880
now it's a 21 great.

00:37:15.839 --> 00:37:17.839
And I'm going to call this one

00:37:18.690 --> 00:37:22.999
instead of simple quick counter, I'm gonna give it another save I'm gonna call it skip counter.

00:37:29.750 --> 00:37:30.840
And

00:37:30.840 --> 00:37:33.049
when I go back home, I now have

00:37:34.200 --> 00:37:38.060
skip counter and I can come back to it. Did I not save properly?

00:37:39.270 --> 00:37:40.920
whoops

00:37:40.920 --> 00:37:42.920
Save skip counter okay.

00:37:43.140 --> 00:37:45.830
And it downloads this thing. That's a hex file.

00:37:46.830 --> 00:37:49.610
All right, like a PDF or a doc or an XLS.

00:37:49.610 --> 00:37:54.319
This is a hex file and that's that's the code file for any micro:bit project.

00:37:56.850 --> 00:37:59.029
So let's let's come back to the presentation here.

00:37:59.910 --> 00:38:02.600
We've done the simple click counter. We've done the skip counter.

00:38:03.270 --> 00:38:05.479
In fact, I told you I would pause and

00:38:06.270 --> 00:38:08.270
leave my code on the screen for you to

00:38:09.270 --> 00:38:12.050
copy and I forgot that the first time through so let me pause here.

00:38:13.530 --> 00:38:16.850
If you were watching the recorded version of this, of course you can pause and

00:38:18.780 --> 00:38:20.780
and then I'll continue momentarily

00:38:28.590 --> 00:38:29.610
Okay

00:38:29.610 --> 00:38:35.029
So let's continue with the third project. Now, we have button A and B doing different skip counts.

00:38:35.190 --> 00:38:40.760
What if we did button A adds one and button B doubles?

00:38:41.520 --> 00:38:43.520
my variable?

00:38:44.850 --> 00:38:52.850
Well, if if that's your algorithm algorithm then in your routines you get richer you can you can start practicing doubling instead of just

00:38:52.850 --> 00:38:54.850
addition you're moving into multiplication.

00:38:55.440 --> 00:38:59.960
And I can ask questions in the Marian Small vein like

00:39:00.720 --> 00:39:04.550
students, how can you get to 25 by adding one and doubling?

00:39:05.430 --> 00:39:07.260
What are the different ways

00:39:07.260 --> 00:39:10.850
that you could get to 25 or pick a number strategically

00:39:11.400 --> 00:39:18.080
based on your pedagogical goal. What what are you trying to get your students to get right now?

00:39:19.830 --> 00:39:22.429
So it's it's just a hop skip and a jump

00:39:23.250 --> 00:39:28.729
from the skip counting to add and double. I'm gonna take button A and

00:39:29.370 --> 00:39:31.879
then to changing the count by one

00:39:33.870 --> 00:39:35.870
Refresh my

00:39:36.270 --> 00:39:43.410
emulator is that still working? One, two, three. Okay, skipping by one or adding by one great.

00:39:44.320 --> 00:39:48.749
And then on button B I want it to double my variable.

00:39:49.360 --> 00:39:56.189
So here's a programming trick I could do this a few different ways, which is often the case in programming just as in math.

00:39:56.890 --> 00:39:58.890
I could think of it as

00:39:59.830 --> 00:40:02.309
adding count to count.

00:40:03.340 --> 00:40:10.110
I could think of it as multiplying count by two and I've got I've got all the basic and

00:40:10.780 --> 00:40:12.780
advanced mathematical operators here.

00:40:14.170 --> 00:40:21.480
But the simplest way to think of it rather than multiplying is just adding so I'm going to change count by count

00:40:22.390 --> 00:40:24.390
How's that for meta?

00:40:24.940 --> 00:40:27.870
I'm going to change count by count.

00:40:28.810 --> 00:40:36.330
So that's a very programming way of thinking of it as opposed to a math way, which might stretch your students thinking.

00:40:36.940 --> 00:40:38.940
So maybe they'll just want to copy this

00:40:39.430 --> 00:40:42.660
but if you've got change count by one and change count by count

00:40:43.630 --> 00:40:45.630
effectively add one and double

00:40:46.180 --> 00:40:50.160
then here's what I can do. I can add one add one add one and

00:40:51.100 --> 00:40:53.100
then double.

00:40:54.010 --> 00:40:58.860
How about that and then I reset it it goes back to zero because it runs this code.

00:41:01.750 --> 00:41:06.150
Add add add add add double

00:41:08.530 --> 00:41:10.620
Double nice.

00:41:12.370 --> 00:41:16.769
So I'm going to come back to the presentation here and I want to share a transcript

00:41:16.770 --> 00:41:19.320
so I did this with one of my kids at home and

00:41:21.730 --> 00:41:26.280
I recorded it because it was such a great example of what you might expect to see in the classroom.

00:41:26.590 --> 00:41:30.299
So my son is in grade four. He's ten years old.

00:41:31.450 --> 00:41:38.460
So he's been multiplying now for a year. This was not new to him, but it pushed his thinking a little bit.

00:41:38.980 --> 00:41:42.060
He had to slow himself down and make sure he was reasoning correctly

00:41:42.130 --> 00:41:45.179
So I think this is the kind of thing that you can do in a math classroom

00:41:46.930 --> 00:41:52.200
with older kids as well to push their thinking and get them to slow down and be deliberate.

00:41:53.260 --> 00:41:56.920
I said to him okay if this were my micro:bit

00:41:57.920 --> 00:41:59.920
how could you get to 12?

00:42:00.260 --> 00:42:05.410
starting at zero and his first answer was well, I would count up to six, you know, I

00:42:06.770 --> 00:42:09.610
have my micro:bit so I'll do this in the in the window here.

00:42:11.270 --> 00:42:13.270
Um, I could

00:42:14.900 --> 00:42:20.319
count up to six and he said count not add one. He said count

00:42:21.260 --> 00:42:25.750
which pedagogically is interesting and then double it double and

00:42:26.570 --> 00:42:31.930
it jumps from six to twelve and I've I've reached it. I said, okay well, can you give me another way?

00:42:32.450 --> 00:42:36.730
And his response was well, okay count to three and quadruple it and I

00:42:38.300 --> 00:42:42.009
strategically didn't want to just say okay great quadruple it. I asked him

00:42:42.010 --> 00:42:44.620
I pressed a little I said, well, what do you mean by quadruple?

00:42:44.630 --> 00:42:50.170
And he said, uh, okay, um, get two three and then double it two times. I'm forcing him to

00:42:51.050 --> 00:42:55.060
slow down not jump ahead and justify how he's gonna get there.

00:42:56.030 --> 00:43:01.720
I said okay another way? And he said well this time okay count up to four double it that's eight

00:43:02.090 --> 00:43:07.809
double it again and he caught himself. Oh, wait if I double it at eight I'm gonna get sixteen

00:43:07.810 --> 00:43:12.130
I'm gonna go over. It's like watching him think through a hand of blackjack. I said, right.

00:43:12.770 --> 00:43:14.770
So, uh, okay

00:43:14.990 --> 00:43:19.839
stop at eight and just count the rest of the way four more and that reaches 12.

00:43:21.050 --> 00:43:24.820
And then I changed it up. I said well, what about getting to eleven? And he said okay

00:43:24.820 --> 00:43:28.959
well then I would count to four I would double it to eight and then count the rest of the way.

00:43:29.420 --> 00:43:31.420
And what I want to highlight here is

00:43:32.060 --> 00:43:36.249
he's he's showing counting on he's showing a repeated addition

00:43:36.280 --> 00:43:41.530
he's showing multiplication. All of these things that in an instructional routine routine, you know

00:43:41.530 --> 00:43:46.450
these are goals that you're trying to get to and my hope is that this micro:bit project will help you get there. Okay.

00:43:48.170 --> 00:43:50.230
Final two projects I'm going to buzz through these

00:43:51.320 --> 00:43:52.490
 

00:43:52.490 --> 00:43:56.740
A single place value digit. So when you're teaching place value.

00:44:00.110 --> 00:44:02.470
Stop sharing, and just go in my window here.

00:44:05.330 --> 00:44:07.330
When you're teaching place value

00:44:08.299 --> 00:44:13.869
Oops, you don't want a counter that's simply going to go

00:44:16.609 --> 00:44:18.609
up to nine and

00:44:19.369 --> 00:44:21.369
then ten.

00:44:21.979 --> 00:44:23.979
Students need to understand that

00:44:24.440 --> 00:44:30.549
place value means that a single digit is is counting how many of my unit if I'm in the ones position

00:44:30.549 --> 00:44:32.549
I'm counting how many ones and

00:44:34.009 --> 00:44:37.839
eleven ones really is a one and

00:44:39.920 --> 00:44:42.190
(which way am I focusing here) a ten.

00:44:43.880 --> 00:44:46.930
So you want it to do something different than

00:44:47.569 --> 00:44:52.119
counting up to eleven or counting up to ten you you when you're teaching place value

00:44:52.119 --> 00:44:58.568
you want them to understand a digit that cycles from 0 to 9 and then recycles again to zero so we can model that

00:44:58.849 --> 00:45:00.849
in a micro:bit and

00:45:02.269 --> 00:45:04.269
I'll share again.

00:45:09.859 --> 00:45:15.479
So what does that look like, in a micro:bit? Well, I'm gonna get rid of button B.

00:45:17.800 --> 00:45:19.920
I'm gonna say when button A is pressed

00:45:19.920 --> 00:45:24.809
I'm going to change my count by one and I want to just be able to repeat repeat repeat repeat, right?

00:45:26.770 --> 00:45:31.650
But I have to build in a logic check. If I reach 10

00:45:33.160 --> 00:45:37.889
then what I actually want to do is reset myself back to zero. So what does that look like?

00:45:37.890 --> 00:45:41.369
I have to come into the logic if true then

00:45:43.060 --> 00:45:45.060
this

00:45:45.520 --> 00:45:47.520
I'm gonna squeeze that

00:45:48.820 --> 00:45:50.820
in the middle here.

00:45:52.000 --> 00:45:53.770
Change the count by one.

00:45:53.770 --> 00:45:56.130
If I just reached 10

00:45:56.680 --> 00:46:02.099
by adding one more and that helped me reach 10, and really what I want to do is reset back to zero.

00:46:02.920 --> 00:46:06.569
So I've introduced a new shape here. When you're dealing with logic

00:46:07.630 --> 00:46:11.309
testing whether things are greater than less than true or false.

00:46:12.670 --> 00:46:14.670
This uses a hexagon shape.

00:46:15.160 --> 00:46:21.210
And those are all this green and they're in the logic section. So I have this

00:46:22.120 --> 00:46:27.029
check if one number equals another number and I can also do doesn't equal,

00:46:27.700 --> 00:46:30.419
greater than, greater equal to, less than, less than equal to.

00:46:31.210 --> 00:46:33.210
If

00:46:33.760 --> 00:46:35.760
count is

00:46:36.550 --> 00:46:38.550
equal to ten

00:46:39.880 --> 00:46:41.020
then

00:46:41.020 --> 00:46:44.580
what do I want to do? I already know how to do this. I'm going to set the count

00:46:45.190 --> 00:46:48.869
back to zero right same instruction as I have here on start.

00:46:50.920 --> 00:46:57.509
Change the count by one. If the count just became ten then set it back down to zero.

00:46:59.080 --> 00:47:01.259
If that's not the case if I'm still at

00:47:01.360 --> 00:47:07.289
0 1 2 3 4 5 6 7 8 or 9 then I I don't do this. I continue down my logic

00:47:07.960 --> 00:47:11.369
continue down my sequence and then I just show the number count.

00:47:12.970 --> 00:47:19.739
So reload this 1 2 3 4 5 6 7 8 9

00:47:21.130 --> 00:47:23.130
What's gonna happen next?

00:47:25.080 --> 00:47:29.510
Zero not ten. It didn't scroll. It's just zero.

00:47:31.710 --> 00:47:35.419
Now, is there any way for me to test what that count is right now?

00:47:35.420 --> 00:47:40.579
No, I can just output it to the LEDs. So I think this is working now.

00:47:41.910 --> 00:47:43.910
And I'm gonna call this

00:47:45.990 --> 00:47:49.040
Single digit

00:48:00.570 --> 00:48:05.960
Its just gonna give me my downloaded hex file again.  Okay

00:48:08.910 --> 00:48:14.960
So, what's the last one I wanted to do? Oh, I I could say that you can extend this to

00:48:15.600 --> 00:48:19.190
other instructional routines other tasks. What if you had

00:48:19.530 --> 00:48:26.839
three students doing 3 micro:bits and each of them had to build a single digit that rotated from 0 to 9 and

00:48:27.270 --> 00:48:29.270
you asked them to act out

00:48:30.510 --> 00:48:33.409
2 digit or 3 digit addition using place value.

00:48:33.870 --> 00:48:39.020
The first student in the ones position would go up a certain number of units and then

00:48:39.570 --> 00:48:43.130
you'd force them to carry the one somehow. How are you gonna carry the one?

00:48:44.100 --> 00:48:50.270
Well, you could elbow your neighbor here and say you you go up one digit and they'd have to do that, too.

00:48:50.670 --> 00:48:56.990
So this is something I tried with middle school students who've been doing addition, you know for five years

00:48:58.020 --> 00:49:01.399
but it forced them to understand what does place value really mean and

00:49:02.460 --> 00:49:04.669
so mathematically that's not a big stretch for them

00:49:05.670 --> 00:49:08.389
but it is a coding stretch for them.

00:49:08.390 --> 00:49:13.819
So you see the balance start to shift between pushing the mathematical thinking and pushing the coding thinking.

00:49:14.100 --> 00:49:16.250
And in fact this last one that we're gonna do

00:49:16.950 --> 00:49:18.950
counting with multiples is sometimes

00:49:19.980 --> 00:49:24.169
used as an exercise for introductory computing even at the high school and university level.

00:49:24.960 --> 00:49:26.700
 

00:49:26.700 --> 00:49:32.689
You may know this you (just check that I'm sharing yeah) you may know this game as fizzbuzz.

00:49:33.240 --> 00:49:35.240
Or you may know it by a different name

00:49:35.840 --> 00:49:38.870
and the idea is it's almost like a choral counting game.

00:49:39.930 --> 00:49:44.329
As a class we're gonna count or maybe we're gonna count one student at a time.

00:49:45.060 --> 00:49:50.210
Just counting up by ones 1 2 3 4 5 6 7 8 9 10 etc, etc.

00:49:50.970 --> 00:49:53.720
But every time I reach a number that's divisible by

00:49:54.630 --> 00:50:00.890
3 every time I reach a multiple of 3 instead of the number, I'm gonna I'm gonna give a special signal,

00:50:01.710 --> 00:50:08.539
to show that I know I'm divisible by 3. I'm gonna count 1 2 and the special signal is usually fizz.

00:50:10.140 --> 00:50:12.140
So choral counting like this

00:50:12.630 --> 00:50:17.809
this may be confusing choral counting like this around the class would sound like 1 2

00:50:18.570 --> 00:50:20.250
fizz

00:50:20.250 --> 00:50:21.420
4

00:50:21.420 --> 00:50:22.710
5

00:50:22.710 --> 00:50:24.540
fizz

00:50:24.540 --> 00:50:31.460
7 8 fizz and that on its own is a good choral counting exercise.

00:50:32.790 --> 00:50:38.749
Where it really starts to get tricky is if you press it a little further and the classic version I know is threes and fives.

00:50:39.240 --> 00:50:45.410
So I'm watching out for multiples of three and I'm watching out for multiples of five and five gets its own separate signal.

00:50:45.510 --> 00:50:47.749
So three is fizz five is buzz.

00:50:48.990 --> 00:50:52.160
Choral counting like that would look like one two fizz

00:50:53.070 --> 00:50:54.780
4

00:50:54.780 --> 00:50:56.780
buzz and

00:50:57.060 --> 00:50:59.330
the six we're right back to fizz

00:51:00.120 --> 00:51:02.120
seven eight buzz

00:51:02.760 --> 00:51:04.760
fizz and so on.

00:51:05.490 --> 00:51:08.150
This sounds like it's easy.

00:51:08.670 --> 00:51:13.969
But man, it's hard to focus and get it right and the class will probably be in giggles

00:51:14.670 --> 00:51:16.050
before too long.

00:51:16.050 --> 00:51:21.800
So like I say, this is a real programming exercise. This this is where we reach the point where the coding

00:51:22.410 --> 00:51:29.269
is more difficult to do than the mathematics the mathematics here is you're just listening for multiples, right?

00:51:29.450 --> 00:51:33.919
But the coding gets a little trickier. So I'm going to go ahead and code this.

00:51:34.650 --> 00:51:36.650
And I'm using this single digit

00:51:37.200 --> 00:51:42.259
Place value as my starting point because it has this nice little if in here.

00:51:46.240 --> 00:51:50.409
What I'm gonna do is I need a remainder because that's that's actually

00:51:51.860 --> 00:51:56.439
the mathematical operation I need to do every time I change my count by one. I

00:51:58.160 --> 00:52:04.750
need to check whether the remainder of of count divided by three

00:52:07.940 --> 00:52:12.100
is zero. That's how I'm gonna check in coding terms.

00:52:12.950 --> 00:52:19.240
With the logic and the mathematics that they give me here. That's how I can express a check for is

00:52:20.060 --> 00:52:21.650
this number count

00:52:21.650 --> 00:52:29.050
now divisible by three. I have to say in a roundabout sort of way is the remainder of count divided by three zero?

00:52:29.869 --> 00:52:31.869
If so

00:52:32.060 --> 00:52:34.060
then

00:52:34.430 --> 00:52:36.430
I'm going to show

00:52:39.440 --> 00:52:45.940
In fact what I'm gonna do is show and no I'm not going to show LEDs I'm gonna show a string.

00:52:49.640 --> 00:52:51.640
Get rid of that guy.

00:52:51.980 --> 00:52:59.260
If the remainder of divided by three is zero meaning this is divisible by three then I'm gonna show the string

00:52:59.900 --> 00:53:01.900
f for fizz.

00:53:01.910 --> 00:53:03.500
A text string.

00:53:03.500 --> 00:53:05.919
So in programming speak that's what we mean by text.

00:53:08.270 --> 00:53:12.040
I've got this plus here. I'm gonna expand that and now I have a second condition.

00:53:12.800 --> 00:53:19.810
Suppose it's not divisible by three suppose this logic check is not true. Um, what else might I do?

00:53:23.420 --> 00:53:31.060
Else I'm gonna show the number count. So let me let me stop there and try this in the emulator.

00:53:32.540 --> 00:53:34.540
1 2

00:53:34.850 --> 00:53:36.530
fizz

00:53:36.530 --> 00:53:38.530
4 5

00:53:38.960 --> 00:53:40.220
fizz

00:53:40.220 --> 00:53:42.220
Okay, see

00:53:42.320 --> 00:53:45.850
That's not bad. Okay, if I want to add buzz.

00:53:47.570 --> 00:53:50.439
Well, then I need to add another if

00:53:51.140 --> 00:53:54.310
else condition in here and I'll show you a shortcut at this point.

00:53:54.310 --> 00:54:00.070
I can right click in this environment on any code block and I can duplicate it.

00:54:00.640 --> 00:54:02.640
And that's a nice shortcut.

00:54:02.710 --> 00:54:05.550
That's a nice shortcut for having to reconstruct that whole thing.

00:54:05.620 --> 00:54:11.790
If this the number count is divisible by three I'm gonna say f if it's divisible by five

00:54:14.530 --> 00:54:19.080
I'm gonna show the string B for buzz

00:54:23.170 --> 00:54:26.850
else I'm just gonna show the number itself. Let's try that.

00:54:28.360 --> 00:54:32.879
Reload my emulator one two fizz four

00:54:34.780 --> 00:54:36.130
Buzz

00:54:36.130 --> 00:54:37.420
fizz

00:54:37.420 --> 00:54:40.440
Seven eight fizz. Okay, great. It works

00:54:41.410 --> 00:54:42.460
Got lucky.

00:54:42.460 --> 00:54:49.290
And now the the crowning achievement of every fizzbuzz game is what happens if it's divisible by three and by five.

00:54:49.480 --> 00:54:53.340
So mathematically, what does that mean means? It's divisible by 15, right?

00:54:56.470 --> 00:54:58.200
I'm gonna have to do that check

00:54:58.200 --> 00:55:03.689
I know as a programmer because I've done this before I'm gonna have to do that check at the top of my list

00:55:04.510 --> 00:55:06.510
because that supersedes everything else.

00:55:07.420 --> 00:55:09.420
Which forces me to do some

00:55:10.390 --> 00:55:14.040
Some messing around here. And in fact, I'm gonna take a shortcut. I'm just gonna load

00:55:16.480 --> 00:55:19.709
just gonna load my fizzbuzz game

00:55:23.500 --> 00:55:25.500
right into my emulator

00:55:28.540 --> 00:55:32.850
and you'll see my finished product. Let me zoom out just a little bit here.

00:55:33.880 --> 00:55:38.970
Same as I had before when I start up I set count to zero and I show it on the screen.

00:55:39.550 --> 00:55:44.550
When button A is pressed I changed the count by one then. I do my logic check.

00:55:45.100 --> 00:55:46.300
If

00:55:46.300 --> 00:55:48.300
count is divisible by 15

00:55:48.790 --> 00:55:54.659
Evenly and then show these LEDs on the screen and it's kind of a crude FB

00:55:56.560 --> 00:55:57.580
If

00:55:57.580 --> 00:56:01.919
it's not divisible by 15, then I go to my next check which is is it divisible by 3

00:56:01.950 --> 00:56:06.000
if so, then fizz. Is it by 5 then buzz. Else

00:56:06.000 --> 00:56:09.629
if it's not any of those then then I get to just show the number

00:56:10.750 --> 00:56:13.270
And then what that looks like is this fizz

00:56:14.240 --> 00:56:16.240
buzz fizz

00:56:17.180 --> 00:56:19.180
fizz buzz

00:56:20.030 --> 00:56:22.030
eleven fizz

00:56:23.480 --> 00:56:25.480
Thirteen

00:56:26.030 --> 00:56:30.340
Fourteen and did it get it right? Fifteen. Fizzbuzz.

00:56:32.450 --> 00:56:38.679
Okay, so I'm gonna leave fizzbuzz here on the screen for just a moment.

00:56:42.620 --> 00:56:44.620
And

00:56:47.180 --> 00:56:49.180
we'll now head back to the

00:56:52.760 --> 00:56:56.290
presentation. So if you have fizzbuzz built

00:56:57.950 --> 00:56:59.950
Um

00:56:59.990 --> 00:57:06.760
You don't have to play fizzbuzz with it really what you're focusing on is multiples and skip counting.

00:57:08.240 --> 00:57:11.800
So you can ask questions like okay class

00:57:11.800 --> 00:57:17.860
how can you get to 24 with just two's? Build a micro:bit that does that and how many twos does it take?

00:57:20.570 --> 00:57:25.749
What are the different ways we can get to 24? If I let you do skip counting in different ways.

00:57:29.960 --> 00:57:31.960
Okay

00:57:33.290 --> 00:57:38.379
I've done all my demonstrating. We've done five projects.

00:57:41.090 --> 00:57:48.189
What I hoped to achieve in this session was to help you build your own manipulatives that you can use in your

00:57:48.590 --> 00:57:49.880
instructional routines.

00:57:49.880 --> 00:57:57.040
You're at OAME so I can assume with some confidence that you're an experienced math teacher. You've got instructional routines

00:57:57.040 --> 00:58:02.800
You know how you like to teach number sense and my hope is that projects like these with a micro:bit

00:58:03.380 --> 00:58:04.520
will

00:58:04.520 --> 00:58:06.520
fit right into your routine

00:58:07.730 --> 00:58:13.000
and be something that you think will help when you incorporate it into class and

00:58:14.990 --> 00:58:16.670
harkening back to

00:58:16.670 --> 00:58:23.170
Graham fletcher at last year's OAME the model is let's build a working computer program

00:58:23.170 --> 00:58:26.020
let's solve a problem in order to learn math.

00:58:27.260 --> 00:58:29.409
Right the mathematical thinking

00:58:30.890 --> 00:58:33.159
really begins once this is built.

00:58:34.940 --> 00:58:42.610
There's some amount of thinking that goes into this especially fizzbuzz that gets a little complex but those click counting ones are so so simple.

00:58:44.570 --> 00:58:50.409
They could just follow you in building those and really the thinking starts once they've got their manipulative.

00:58:52.790 --> 00:58:55.509
And we went through these five projects: the click counter

00:58:55.640 --> 00:59:00.999
skip counting add and double, the place value digit and then finally fizzbuzz.

00:59:04.130 --> 00:59:05.150
Overall

00:59:05.150 --> 00:59:08.920
my goal is to make it clear that these support

00:59:09.530 --> 00:59:15.340
two strands very clearly in the Ontario curriculum number sense and numeration and patterning and algebra.

00:59:15.340 --> 00:59:21.159
And those can be applied, of course at different levels of sophistication with different students.

00:59:22.070 --> 00:59:27.699
Of course micro:bits can do a lot more.  You can plot on the LEDs as I said, you can measure angles,

00:59:28.370 --> 00:59:32.259
work on messaging between micro:bits. There's all kinds of things you can get into.

00:59:32.870 --> 00:59:35.859
So I encourage you if you're interested in micro:bits,

00:59:35.860 --> 00:59:40.959
they're not expensive. A box of 10 a classroom set something like two hundred and fifty dollars.

00:59:41.510 --> 00:59:45.249
So compared to a lot of other kits that you can buy this is pretty cost-effective.

00:59:46.430 --> 00:59:50.350
And there's a lot you can do. They're friendly and accessible.

00:59:52.310 --> 00:59:54.759
So thank you very much again to the OAME

00:59:55.970 --> 00:59:57.970
organizers and to you for watching

00:59:58.850 --> 01:00:00.850
my session.

01:00:00.920 --> 01:00:03.220
If you'd like to learn more about kids code jeunesse,

01:00:03.980 --> 01:00:11.560
and bring us into your classroom or bring us in to do professional development with your school, your board or your region,

01:00:12.230 --> 01:00:16.149
contact us at our website kidscodejeunesse.org

01:00:18.560 --> 01:00:22.929
You'll also see us on social media as kidscodejeunesse or kidscoding and

01:00:23.570 --> 01:00:27.399
of course we also have Code Club Canada. You can search for us that way.

01:00:28.880 --> 01:00:30.880
Thank you very much.

01:00:42.570 --> 01:00:44.570
Enjoy the rest of the conference