Episode 17: Abstraction and Analytical Thinking
Sean Tibor: [00:00:00] Hello and welcome to Teaching Python. This is Episode 17: Abstraction
and Analytical Thinking in Python, recorded on Wednesday, March 27th, 2019. My name is Sean
Tibor. I'm a coder who recently began teaching.
Kelly Paredes: [00:00:32] And my name is Kelly Schuster-Paredes and I'm a teacher who recently
began to code.
Sean Tibor: [00:00:36] Well, so welcome Kelly. We're back to our normal Wednesday recording
day. I know that we've had a lot going on over the past few weeks and the next few weeks
promise to be even busier. Wanted to just check in with you and see how things are going in
your classroom, if you've had any big wins or big moments over the last week.
Kelly Paredes: [00:00:06] Yeah, we've had a really busy time trying to finish up the quarter and
trying to get in as much of Python and extra things as possible . Had a couple of wins. I did the
last two units bread boarding and soldering. I really like that unit. Just getting the kids to see
the difference between the prototyping board and making a a circuit and the kids really like
soldering.
I don't I'm not really sure why. I think you like soldering as well. Right?
Sean Tibor: [00:00:12] it helps me enter into a Zen State.
Kelly Paredes: [00:00:01] I think that's what happens to them because after we were reflecting
on it the process they said the best thing about the about this week was the soldering so which
was good.
Sean Tibor: [00:00:12] Well, it's very satisfying. Melting metal, you're making them stick
together that normally wouldn't and I just find it very relaxing if I have a lot of it to do and I've
got everything laid out. There's a process to it. It just Makes makes me feel relaxed and happy
when I'm done.
Kelly Paredes: [00:00:01] Yeah, it was nice to see that they had though.
they made a lot of connections from what they could do with their prototypes and a couple of
the projects that they're working on with the lights and the speakers and how they can make
that finalized product.
Sean Tibor: [00:00:07] Yeah. It's interesting you moved that to the end of the course now. In my
courses, I do it at the beginning. And then they don't really touch it again. Whereas now you're
doing it at the end of the quarter and that seems to be more timely with the projects that
they're working on.
Kelly Paredes: [00:00:09] Yeah, I like that a lot. When we were prototyping the kids made a
couple of things like traffic lights a racetrack light and a sound a little bit of a sound They use
the speakers from the Pimoroni and just for them to be able to understand the difference from
the LEDs, the long leg the short leg and having that actually stick afterwards was kind of nice. So
I think I'm going to keep it again at the end of the unit. And then we also touched on a little bit
of AI this week. So that was fun.
We're seeing a lot of talking about ethics and bias in AI. And how about you? You had a lot of
fun things with their 20%. You had everything going on.
Sean Tibor: [00:00:06] I had such a wide range of projects this week. Everything from a
commercial for other middle school students to Learn Python, an infomercial that tells them all
the great things that happen in Python, to new quizzes on the kahoot platform to new code and
new games everything so interaction fiction interactive fiction.
I've had some really great things with the optical sensor on the circuit playground. The one that
I am most impressed with is a pair of sixth grade students sixth grade girls who set up a Django
server from zero to webpage. I don't know that they're going to get into actually writing Django
apps or anything like that, but they followed a tutorial from Installing Homebrew and python on
their Mac books all the way up to having a webpage served on one person's computer that was
hosted on the other computer.
Kelly Paredes: [00:00:02] That's fabulous. I was actually talking to some of your sixth graders
and telling them that they need to teach me a couple of those things. Haven't had much time to
learn anything new this week and next week either I guess.
Sean Tibor: [00:00:00] yeah, from now on I'm going to call them the Django girls . It's pretty
amazing.
Kelly Paredes: [00:00:01] Well this topic comes in line with our 20% time projects and solving
problems. This idea came from the episode. We both listened with Michael Kennedy and Talk
Python to me. You call you texted me and said, oh my gosh, we need to listen to this episode.
It was the beginners and experts in software design. there was one point of the recording the
podcast that I said, that's our next podcast! Michael Kennedy made an interesting point about
how do you go about tackling a problem? And he was saying he wished he had a class or he can
design a class to help beginner coders attack problems.
I was driving I said, that's it. We kind of do that. We have that curriculum here at Pine Crest.
Granted, it's at a lower and smaller scale. But I think that's one of the things that we do really
well. And it's that idea of abstraction and analytical thinking.
Sean Tibor: [00:00:08] O ne of things that we do really well is setting the level of difficulty for
the student age and developmentally appropriate for that problem solving approach and what
we're really looking to do is help them combine many different skills together to be able to
approach and solve problems. Everything from defining the problem and identifying that there
is a problem to be solved all the way through to how do you actually deliver a solution for that
problem and test to make sure that it works.
Kelly Paredes: [00:00:20] Let's back up a little bit. I'm going to let you define abstraction for us,
Sean, because you've got a better definition than than my definition. So, can you just explain to
our listeners what abstraction is?
Sean Tibor: [00:00:07] It's interesting to me that we talk about abstraction as a software
development thing because it's something that we all use in our daily lives.
We live in a very complex world with very complex things working for us all the time. the
history of technology has been that the tools that we use , becomes more and more complex.
So if you think back to ancient civilizations, most of the technology that was being used was
very simple. I remember my one of my teachers are telling me why the big breakthroughs in
agriculture was basically a box with seeds in it and a hollow pole that you could use to poke into
the dirt and you shake the box and the seed drops down and goes into the Earth so that
improved the speed at which you can plant seeds, right but everyone knows how that works.
I have a box. I have seeds. I have a hollow tube the seed falls down the hole when I stick it into
the Earth and the seed gets planted and now I have my seed in the ground. It does what I want,
right? but can anyone go out and tell me how a seeder works from her for John Deere? one of
those things you tow behind a tractor and it disperses seeds everywhere.
That would be a hard thing to explain even 40 or 50 years ago in detail and understand how it
works in full. Now add on to the all of the automation and sensors and all of the computational
approach that we've added to agriculture and now it's something where only someone who's a
John Deere engineer could probably explain how the seeder actually works or maybe a really
good farmer or rancher. So we've gone from that very simple everyone can explain it to now,
everything we use is so complex that it's really hard for any one person to describe it in detail.
And just when you think you've unpacked all those layers of technology to understand it, then
you start to get into things like material science.
How do we even have the steel that we use for that tractor? We're talking about levels of
complexity that's really hard to fit into our brains. We don't know how everything works in all
this detail, but we do have the ability to do and what humans are remarkable at doing is
abstracting concepts.
I don't need to know how the seeder works. I just need to know that I hook it up to my tractor. I
put it behind there. I know how to operate it and I put the seed in and seeds get out and maybe
I'll make some adjustments so I'm able to simplify the operation of that equipment to the level
that I need.
I make it more of an abstract concept. This is a seeder and now it works. So the idea in coding is
that there's so much complexity happening behind the scenes that we frankly don't care about
as users or even as programmers and coders and we need ways to abstract that complexity
away from the user so that whoever is using our code whether it's an end user sitting on a web
browser a thousand miles away or whether it's the guy sitting next door to me and writing code.
That when I make my code, he's able to use that code no matter how complex it is in an abstract
way and trust that it's working behind the scenes
Kelly Paredes: [00:00:24] And that's kind of like a nice little safety net for for teachers. Especially
new to coding teachers when it comes to teaching. It's just this week when I was trying to show
the kids again about the neural networks and tensorflow and not the fact that I was teaching
them how to code because we only had a couple days to go over AI, but I was trying to explain
to them that in my mind.
I just have to accept that these neural networks work. And I could probably follow along and I
did follow along pretty well with the coding and I can write out some of the lines but what was
happening behind that complex lines or behind those uh those libraries that we were using I
really don't think I could probably touch on and I was telling them, you know, it's okay.
There's sometimes some things that you need to know and you don't really need to know how
this works and I think that is a is a nice safety for a teacher who's just starting to code and trying
to also help the kids understand what's going on. The kids need to be able to understand the
general process of what what's happening what they're learning and we can actually explicitly
teach them how to identify those things, but they do not need to know everything. It's that
need-to-know basis.
Sean Tibor: [00:00:08] . What's helpful about this from a teaching perspective is that we need to
teach both sides of this abstraction. One is how to use complex elements in an abstract fashion.
The other is how to design abstract interfaces for complex problems or solutions. So we found
that to be a very key aspect of coding in general, but it's also one of the fundamental principles
of Python in particular. That simple is better than complex. The ability to to do things simply and
cleanly and trust the layers of of detail below you the layers of complexity below you to be
efficient is a paramount function of all coding languages, but Python it's part of the core
philosophy.
Kelly Paredes: [00:00:15] That's the biggest thing as a new coder to get across. I always go back
to that matplotlib because that was my biggest aha moment. You don't need to know how to
code those lines. You don't need to know how to put in the data that you've collected.
You just kind of run it put in a couple lines of code and just let the magic happen and if I wanted
to find out and adjust things, I guess I could dig in there deep, but I don't really need to.
Sean Tibor: [00:00:01] All you need to do is look at any sort of matplotlib error to see how many
dozens if not hundreds of functions are being called to render your chart to know that there's a
lot of complexity there that you don't have to deal with thanks to the people who have been
developing that library for years
Kelly Paredes: [00:00:10] So we're just talking. There's actually a process when I started
researching about abstraction because I didn't really know this terminology. We don't use the
word abstraction specifically in education, I guess when you go into coding you would dip more
into that word, but we do often talk about computational thinking and analytical thinking and
the whole idea that this process of breaking down and understanding complex parts to a
problem.
It's something that we constantly teach PK to 12 in the school system. And so when I was
listening to the podcast I was kind of feeling comfortable with the conversation going, wow, we
do that. We do that in PK. We talked about little levels of breaking down the problems and the
actual steps of how to do that.
So abstraction is something that can be explicitly taught. And it's just going into something
simple. Things like reducing that unnecessary detail. It's just letting the kids again know that we
don't need to have everything showing that they should be able to identify. So if you specifically
teach that at certain moments and highlight the words that this is part of Python and this is
part of computer science. It's part of programming. It's something that they can start to look for.
Sean Tibor: [00:00:06] When I teach this in Middle School, the place where most typically comes
in is actually when we start to talk about functions and why you would use functions to
modularize your code. One of the big reasons is for reusability, but the other is for abstraction
and I explain it to the students as the transaction of buying an ice cream cone.
When I buy an ice cream cone, I tell the person that I want to buy it from: I want this size. I want
this flavor. I want it in a cone. Or I want it in a cup or whatever it is as my order. Those are the
things that they need to know in order to fulfill my order and then here's the money that it costs
for that ice cream cone. I don't really care what they do behind the scenes what complexity that
is in order to make the ice cream cone.
Maybe they're milking the cows in the back and freezing the milk and separating the cream and
all those things behind the scenes. I don't really care. What I really care about is can you make
an ice cream cone for me? Bringing it to a real world example where it's a transaction makes it
easier for students to be able to see this.
So we design some of those functions. In fact, that's where we brought in James Charles the
YouTube makeup celebrity as an example. You can do this. This is worked so far with pretty
much anything we've done this with Bob Ross also. Where you can take pretty much any series
of instructions and break it down into smaller components and then roll that back up into more
abstract concepts.
So we go through that exercise and they have the students watch the video and write down
things that they think would be functions that that the person on screen is doing and then we
talk about: "Okay, well what goes into that function? Why did you choose that level of detail?
Versus being more detailed or less detailed in that case"
Kelly Paredes: [00:00:29] That's a big skill of computational thinking that process of
decomposition and that's something that I know in the lower levels they do a lot. That
decomposition that designing and then that programming aspect and you can find it in all the
simple tools that they use at the lower levels even within Scratch just giving them a challenge
and having the students figure out how to break that challenge up and and code in scratch or
design that program in Scratch and and then you can relate that to abstraction.
Analytical Thinking [00:00:01]
So that leads us into our next topic. Something that I'm more comfortable with is how analytical
thinking and that process of analyzing and anticipating some results is something we use a lot in
order to teach abstraction without actually going into it too much and it's that process of
whether we're in computer science or we're writing an essay in English or if we're trying to solve
an experiment in science.
We need to teach the kids how to do this analytical thinking and what's nice about that is just
having them to draw upon these other experiences and what they know and that knowledge
and skills in order to solve a problem.
Sean Tibor: [00:00:31] Analytical thinking is a critical part of computer science. It's something
that we have to manage especially given how much data we're working with and there's a
common synthesis or a common correlation between data and analytical thinking. I have to
have data in order to be able to do my analysis.
But one of the things we want to start with is even, how do you gather data? What kind of data
is important how you make observations? How do you sample things? What kind of data is
important? And we start that in our computer science courses almost with a testing philosophy.
So as you're writing your code or as you're creating it, we ask the students whenever they run
into difficulty or whenever It's not doing what they expect we do this concept of, what was the
outcome you're expecting? And then we asked them, what was what did you actually observe
and what's the difference between the two? Why do you think that is happening? That's the
fundamentals of analytical thinking. What did you expect?
What did you observe? And now what what are you seeing? It's a scientific approach. It's a
analytical approach. And it lets us open up conversations with the students regarding how they
gather data, how they're analyzing that data, and how they're mapping or creating hypotheses
of what could be happening with their code.
Kelly Paredes: [00:00:18] Yes, you know analytical thinkers. They can see the data they can see
multiple perspectives. As well, which is really important. They can conceptualize. Today, we're
doing an activity in science and we were trying to have them apply biomechanics and the study
of the body and how that works inside a house and being able to transfer that knowledge of
what they're they're seeing from their body into what they might design in a home is really
analytical thought for them. That they have to process it. They have to organize, they have to
classify the information and then make a decision based on what they have. One of the things
that I like a lot about analytical thinking is it's tied directly with information fluency. It's a
significant part being able to read what is on the screen around the paper and take out and
organize the information in order to process it to use it and I do that a lot in the classroom.
Give them somethng to read, give them something to do. Give them a project to make and I
want them to sort through the inormation.
Sean Tibor: [00:00:00] So if we approach this in a stepwise fashion, so step-by-step. Step 0 is
having something to analyze. This portion is getting them to observe and pay attention to the
details and see what's in front of them. For example, during this measurement today that we're
doing with the science classes. We're measuring biomechanical force as people were jumping
off of a small platform onto the floor and we're measuring how many Gs they had when they
impacted the floor and seeing the difference between the two when they landed straight legged
versus crouched to land softly.
And we had data right in front of them that showed the g-forces. But then we also had to make
the connection. We ask the question what other senses can you use beyond the sensor data
that we're here seeing here what other subjective measures can you use to be able to evaluate
the force that's happening.
What we wanted them to do is make the jump to I can use my ears because someone who's
landing straight leg hits the ground with a lot harder thud than someone who is landing soft and
literally they win software. There's not as much noise and then make that connection. Why do
you think that's happening?
What's that? Why is that what you expect is that something different? What's the difference
between the two so we start with that step 0, which is what data can you measure how can you
make observations? How can you collect samples and get them to think differently? Not just
about what they can use to measure and track with sensor data.
But also what can they observe with their own sensors and then maybe feed that back into
some sort of quantized approach to be able to measure it in a discrete fashion.
So they heard the sound and they were able to use data that was not just what was being
measured but also what they could observe with their own senses.
Kelly Paredes: [00:00:06]After they did all that they took it a step further and we're looking at
the attenuation through the body and trying to do it through the sense as well. Not only hearing
they were also talking about what they felt. So it was another way of collecting data and what
was really great about this activity is afterwards.
They recorded this information not only in slow-mo footage but also in written work and they go
back to the class and then they start to talk about their observations again.
Sean Tibor: [00:00:28] So that's like step one. So step 0 was collecting the data Step One is
deriving meaning from the data. Can we see Trends?
Can we classify our data? Can we make inferences? From what we've seen can we look at this to
sort organize find a way to get to that higher level meaning? From the data that we've collected
then step two is how do we transfer those observations and insights like that higher-level
meaning into broader Concepts that can be applied more generally than just the specific case
that we found here.
So that's our step three, which is now this synthesis into a broader concept of understanding.
Kelly Paredes: [00:00:05] And it's cool because I go into a connection. I'm looking at the joints
and then looking at houses and going into drawing and designing their own possible solutions.
Sean Tibor: [00:00:00] So we've kind of laddered up from this primitive base data that we
collected. Jumping off of a platform or balancing on a bosu ball one of those balancing things
and the data that we've collected through those observations up to some basic principles about
how you can attenuate energy from a moving structure.
And now we take that concept and we apply that in a deductive fashion down to the parts of
the earthquake proof houses. So how do you take that concept and use it to design an
earthquake-proof house?
Kelly Paredes: [00:00:03] During that decomposition phase they actually go through another
level where they start to converge and then we go back out again. And we do a converging
activity activity. So after this activity, then they come back into the classroom and they're going
to make a building a small building with Play-Doh and sticks and they're going to put it into
another form of an earthquake.
And again, this isn't going to be their final product. This isn't what they're going to present. But
they're just trying to get in more ways to analyze the data that they've already collected.
Sean Tibor: [00:00:09] And so when we pair that together. When we take that analytical
thinking approach and the abstraction approach that we talked about earlier when we pair
those together, that's where we get computational thinking.
There's an additional step to this that I would also include which is the iterative nature of
computational thinking that it's almost like an engineering design process. You're constantly
collecting data using that to implement something testing it getting more data and using that to
refine your approach.
So computational thinking can be very iterative as well as we go through this especially when
you're looking for patterns if I look for a pattern have I found the right pattern are there other
patterns that could work here if I apply this pattern does it work in all the cases that I have in
the cases where it doesn't work?
Can I broaden my pattern about broaden my definition of my model in order to account for that
that new use case also, so this gives us the ability to tap into many other computational thinking
skills that are maybe more Atomic right there smaller pieces or smaller parts of computational
thinking of raw, but generally fit into these two big buckets of abstraction and analytical
thinking.
Kelly Paredes: [00:00:23]When I was listening to the podcast with talk python to me. It was that
whole conversation of breaking problems into smaller bits. We actually just broke the problem
of abstraction into smaller bits using computational thinking and it's every project. I think any
project that we come across whether it's teaching a curriculum whether it's driving a car or
whatever we come across building a new.
Product that our boss gives us it's always about breaking it down either whether we're breaking
it down the actual concept or for breaking it down into how we're going to teach it. So it's that
process of going through this computational thinking each and every time.
Sean Tibor: [00:00:12] There are so many benefits to this. This is such a fundamental skill that
everyone should learn it shouldn't be the only skill that we employ there's many other types of
thinking and other approaches. But it should be something that everyone should have available
to them as a way to solve problems as a way to make things happen as a way to get things done.
So when we look at this process, it's something that we've introduced explicitly over the last
four or five years at our school. It's something that we're teaching at all different grade levels
and we have to find ways to teach it at the appropriate level for the students to be able to build
upon it and grow and develop that skill over time.
So the goal is that by the time. Say a kindergartener entering our Pre-K student coming in
someone who's in the earliest stages of their education graduate from our school in 12 or 13
years that they've got this very finely honed skill for being able to , abstract things, conduct
thorough analysis to be able to decompose problems recognize patterns.
Teaching Abstraction [00:00:00]
Kelly Paredes: [00:00:00] I want to shift gears a little bit and talk about the specifics of how we
actually teach some of these abstraction techniques. Because it is sort of abstract when you're
talking about it on a podcast and as I was listening and thinking about the things that we do
each and every day, it was kind of nice to see and we do them every other day every other day.
Okay. Sorry, Monday Wednesday, Friday, Tuesday and Thursdays for my off days. One of the
things that we both do is this use modified create kind of thing. We thrive on the ability to give
some students some book or give them a project or have them look up a specific activity. And
this is our I think in my I will say it for my classroom.
It's one of my one ways that I get through a lot of Concepts quickly. It's that approach to
teaching where. They're pre-prepared programs. I want them to figure out what's going on.
Right the entire code. Tell me what that program is doing, play around with it. And I want them
to go back in there and see where they can modify see what they can change inside that
program.
Even if it's just changing a color or change in a prompt. I want them to go back in there and
modify it and then from that I like to have what I called a mashup. I give them another project
and I asked them to match those two projects together to create something new and so that use
modified creators is one of the ways that I like to use to in order to teach abstraction.
Sean Tibor: [00:00:28] it gives the students quite a few different opportunities to apply some of
these skills. If you're just using someone else's code. You don't need to know how it works
necessarily you're able to be just a user of that code in a very abstract way.
It just does what I needed to do. I don't care how it does it. Just let it go. You may not learn
much about what's happening behind the scenes. You just know that it does what you needed
to do. And I think that was one thing that was on the podcast as well was the ability to know
when you can just let something run without having to know it in detail.
That's a skill to be able to make that decision. When they have to mash two things together, or
they have to modify someone else's code to do what they want. I found this thing that was
close to what I want. But I need to make it do this other thing instead that requires a different
level of understanding and getting a level deeper.
So you're going beyond that first layer of abstraction and then the next one and you're able to
then apply it to this new use case. You may not understand how everything works but you're
able to Tinker with it modify it enough to make it do what you want. And then that third layer is
where you create something new.
There's nothing else out there that does what I want. So I'm going to create it myself and I need
to know it from the bottom all the way to the topic every piece of code that goes into it every
library that I call. I don't necessarily need to know all those details, but I might be working in a
much less abstract way in a very complex detailed way and then I'm also designing the interface
for my consumers or my users of the project that I'm making.
Kelly Paredes: [00:00:10] Yeah, and then another one that we like to do a lot is that problem
design code. I like doing this one, especially in the early days. I will teach a maybe a specific line
or a couple lines of code and then I'll give them a problem.
One of the problems I gave them was to convert. 24-hour time into 12 hour time and they had
seen a couple of the ways to do something similar and they had to design that problem and
code it. It's just that idea of giving them a specific problem even said it to me at the very
beginning when I when I needed to start coding here's a problem get a problem and try to find
how you're gonna solve that and I think that works really well with helping them with
abstraction.
Sean Tibor: [00:00:12] For the first introduction, this is a really great way if you give them the.
Then they go out and solve it but they're not necessarily has invested into that problem because
it was given to them by the end of the course what we're seeking is for them to go find their
own problem to solve and that's when we start to get things like sixth-grader setting up a
Django server or eighth graders writing 600 lines of interactive fiction code because now that's
the problem that they want to solve and is a deep dive into that.
Kelly Paredes: [00:00:01] Exactly. Another activity that I like to do or and I know you do this as
well are the annotations or the adding the notes and comments.
Sean Tibor: [00:00:12] So annotations, this is one of the activities that I really like and this is one
that you showed me how he that has worked really well and the idea behind this is that you give
students either a snippet of code or a full program nothing too huge and something they may
have seen before but they are expected to write comments to describe what the code is doing
at any stage.
This is the literacy side of it being code literate to be able to read code and understand what it's
doing. So how did you come up with this idea? Because I think it's a really great way of getting
students to read and understand what's happening.
Kelly Paredes: [00:00:02] it started with python is another language for me.
So whenever I was starting to learn Spanish, it was just like learning vocabulary and always
that's the way my brain worked was. I would see a Spanish sentence and I would translate it and
almost like these are the need to know sentences. I needed to survive when I was living in Peru.
So I translated them and I had a little book and then when we started learning python, I showed
you my cheat sheet book and all the comments that I made in there. That idea of using the
comments and translating literally translating every sentence into something that.
You personally understand not necessarily exact pythonic vocabulary, but some of that you
understand is just a good way to help your brain break down that function or that command line
and I think as we get further into more python the lines get longer so you have to be able to say
what it's really showing.
Sean Tibor: [00:00:02] It works great. I have seen a lot of our students really progressed from
doing that when they have to think about what it's doing and describe it and this works well as a
partner activity to because they can discuss it what I think it means this. I mean you means that
is not necessarily I could quiz.
It's more along the lines of an assessment of knowledge. Do you understand what this is doing?
And if you don't understand it, then we come back and regroup with it together to talk about it
and kids are shouting out answers. They get really into it when they know the answer.
Kelly Paredes: [00:00:27] And it's kind of like that metacognitive side comes into it so they have
their cheat sheets as well where they write down the vocabulary. The question I always ask
them when they say do I need to write this out and I say, do you know what that is? And I
always answer that with a question. So yeah, so the analytical thinking understanding what's
going on and using the comments and notes sections and annotations.
Another thing that we do. We do this breaking down the problem and this is something that
they talked about in talk python to me and it was that idea of the cognitive skills writing out
exactly what you need to do in order to solve the problem and I've seen you do that a lot.
When you do your 20% time, you have the kids come up and you sketch out the problem on the
Whiteboard and you do a flowchart, but you make them go and talk to you and speak out what
it is that they really want to achieve.
Sean Tibor: [00:00:03] There's two ways you can approach this. So you may be tempted to think
through it in a linear fashion.
I start at the beginning and I go to the end. This is a great opportunity to use some recursive
thinking so the idea of writing it from beginning to end, but maybe those beginning to end is just
five steps. You start with one thing that I want to do like I want to wash my car.
But the five steps might be get the car wet soap it down scrub it rinse it dry it right. Those are
the five steps, but then you can break down each of those steps further into its components.
Like if I'm going to what the car down the I'm going to wet the front of the car down, right?
And then I'm going to do that part of it, wet the side of the car so you have the opportunity to
kind of unpack each of those boxes of activities and that way of thinking through it recursively
and getting down to the base parts helps them literally break down the problem into its smaller
components until they get to a level of detail that they're comfortable with that.
That's something that can be reapplied or that they don't need to go any further.
Kelly Paredes: [00:00:07] One of the next things that is going to be a great way of teaching
abstraction, which I have not used and I really want to try next quarter. It goes in line with this
whole idea of information literacy and being able to take information out of what you have read
and it's from a website called Teaching London Computing and there are a bunch of articles
about abstraction or about the idea of abstraction and I like how they they have.
These articles laid out. One of the articles that they have is a simple two page PDF that says how
do computers become so clever and it walks through the process of Designing a tic-tac-toe game
and the idea of what would you program?
That computer to do in order to play Tic-tac-toe and I think that's a really interesting way of
talking about abstraction that I have not done and I kind of want to try it.
Sean Tibor: [00:00:25] it does kind of combine these two areas together where you're looking at
the information literacy and thinking about the process of abstraction and finding examples out
there in the world.
So I want to try that too. I haven't had an opportunity. The next one that we have on our list is
to take a specific program and so give them the source code and have them run it and see what
is happening. Tell us what is happening. So they look at the code. They run it they have to
describe what's happening based on what they're seeing in the code and in the micro bit or in
the repple to see what's being out.
Kelly Paredes: [00:00:11] that's one that is similar to through the use modified create but it's
just that one step and these are good things for those five minute challenges that I like to do
those little quick little activities. The one that I like the most and it's always the one I do within
the first two weeks of class is give them a nested Loop and then I will have it flash an image on
the micro bit within the nested Loop and it helps them to figure out.
How many times that Loop will pass through and I don't tell them anything. I just asked him.
Why is that X showing how many times is it showing and then they have to deduce why that's
happening. And then from there we have the discussion about what's a nested Loop and what's
happening within that process.
So I feel like maybe that's one of the biggest ones where I talk about the abstraction is they
need to know what's going on inside of that Loop and be able to explain it.
Sean Tibor: [00:00:34] Turtle works really well for this too. So I used her. With this process and
we go into how does Turtle draw shapes and how do you make functions that can draw shapes?
And how do we turn that into more generalized abstract functions that can be used to draw
more shapes and just a square. So we go through a progression when we do that, but I often
start by giving them some codes and with your what does this do?
Kelly Paredes: [00:00:22] So how algorithm shape our world that's another one on the list. I saw
a couple of Articles and it was kind of at the start of the aii one of the kids to have a discussion
about do they really have a choice in the choices that they make online and we started and I
found this article about how algorithms paper our world and as I was thinking about our podcast
this week, I thought well, that's a pretty good.
Abstraction example right there is we the kids don't really need to know what's happening
behind the algorithms. They just need to understand that when they go onto Netflix when they
go onto YouTube when they go anywhere that has some data being collected on them ads or
other suggestions of videos to watch to pop up and I don't really expect them to understand the
whole process that's going on, but I want them to realize that it does affect them and affects
their choices online.
The last example that I have on our list is pattern detection and matching. Again for me I think of
it in terms of a foreign language if I can show the kids or the students how multiple functions are
used in different situations.
And then I also tell them to make sure you save all your code or name it properly , imagine that
naming files properly, but name their code properly, then they'll be able to. Find a specific
program that they've used in the past and realize that that can be used in another scenario that
I may give them.
I like that a lot. We do that with user inputs and functions when I teach those two topics and it's
just it's a nice way to let them know that patterns exist and that if you use and you were able to
understand the patterns that happen with encoding it comes a little bit easier.
Sean Tibor: [00:00:29] I had a moment this quarter where I realized that the kids were getting a
little too good at recognizing patterns. So I'd ask them to create functions for me and they were
writing their functions as though they were being used by a human sitting at the terminal rather
than a function that could be used in another program.
And so they had picked up on this pattern of asking the user for input doing some processing on
that information and then providing the user with output again. They had fallen into this pattern
recognition trap where they thought that that was the solution to all of the Python problems.
We had to solve so I will use it as an opportunity to explain to them this idea of recognizing
patterns and maybe pattern overuse where you fall into the dangerous trap of using the same
pattern to solve every problem even when it's not appropriate.
Kelly Paredes: [00:00:07] that's a great skill. Well, those are some of the examples that I
thought of when we were talking about this topic as obviously I if we take it and deep dive and
more into what we do within our curriculum. We could probably find a lot more connections.
Do you have anything else on that on Sean? Do you have anything you can think of them put
you on the spot on a Wednesday afternoon? You know, honestly, the biggest thing with this is
to recognize that this is a foundational skill development exercise that you can't expect
students to come in knowing these things.
There's a lot of work that goes into that adopting these approaches on their part. They have to
work at it. They have to think about it is not always something that comes naturally for students.
So, you know apply large doses of. Lots of reinforcement. Provide opportunities for feedback
where you can but give them the chance to learn this.
This is something that many adults don't really understand. Well either an aren't capable of
thinking this way out of the box immediately. So be patient with them and if this is new to you
also just trying to practice and role model the behaviors I find myself. Always seeking ways to try
to demonstrate this Behavior to my students in a way that they can that's accessible to them
and that they can get. I'm always looking for new ways to teach things.
Your Emails [00:00:04]
we have a listener email today Jason Kibby a teacher In Pennsylvania Summers, just a great list
of questions across a wide range of topics. We're going to be dipping into his email probably
over the next few episodes, but one that really jumped out to me was a question about
cheating.
Jason asks is cheating a concerned has it happened. It's one thing to consult stackoverflow and
another to copy and paste a classmate's code. And I agree. This is definitely something that's
been a concern for us. How do we. Identify what is cheating and what isn't one of the things we
just talked about is the ability to reapply code and Concepts from other places understand how
it works the way that we've navigated this in our classroom has been that it's all about
attribution.
We structure our class in such a way that there are very few tests and quizzes where it's closed
book closed notes closed internet where you can't search for answers we. Try to make it so that
students have to consult as many resources as possible to be able to answer the question. But
we Define cheating as when a student represent someone else's code.
Someone else's content as their own without proper attribution and there are some times
where we tell them you can't work with a partner when we're doing a challenge in class or
working on a project or something. We will tell them you have to you know, work independently
or work with the partner that you've been assigned or.
So this gives the students the opportunity to have a resource. They can still go do all their own
research, but we make it very clear to them. If you're going to present this code you need to be
able to Source it I got it from this place or I brought it in from here. If they present it as their
own code that this is something they wrote from scratch and it's clearly from another student or
a book or something like that that that's where we consider it cheating and we'll refer them for
for disciplinary action
Kelly Paredes: [00:01:04] and I always like to use the terminology for what it is. I like to use
open source and remind the kids and that there is a lot of information that's open source.
There's a GitHub their communities a python Community is all about sharing and I think that's
one of the great things that I like to tell them. I showed them a couple of the.
The open source programs for example the quick draw in Google when they with the AI and
machine learning has everything open source, and how projects have been modified and
recreated from this code. I like to encourage that they use open source, but again, You cannot
set there and try to tell us that you've coded this program when you can clearly tell that's not
their style.
It's it's something I say that is not the style that you you know how to code I can I can
understand that that's probably another student style of coding because I've seen his work
before and I think setting that stage and letting them know that it is an open source Community
when the code is provided.
But you have to give them credit you have to let people know that this was not your work. You
may have modified it added it. And what is it in when you do a replica when you use Fork it?
Yeah, and that's okay, but you need to give credit where credit is due right.
Sean Tibor: [00:00:17] The nice thing about being in , a Middle School academic environment is
that we haven't yet run into any issues with licensing requirements or anything like that.
So. We don't necessarily touch on open source licenses and the varieties of different licenses
that are out there for using source code because for the most part our students aren't trying to
sell their work or profit from a commercially they're here purely for the learning and the
education of it.
So for the most part open source licenses haven't been a concern yet. We focus more on the
proper attribution and giving credit where it's due. And to me the bigger issue is when a
student attempts to pass off. Someone else's work as their own that's when we have concerns
about honor code violations and things like that that we will refer for discipline.
Kelly Paredes: [00:00:05] I guess the best way to avoid having the cheating. Happen is to either
a let them do a partner up be give them a challenge that has various outcomes. Or C force them
to use someone else's code and have them change it. So, you know what the starting point? Yes
sound. That would be my solution for this.
Sean Tibor: [00:00:31] The reason why I've seen students attempt to cheat or stretch it is
because of anxiety. It's a fear of not being able to do it and some sort of pressure that they're
feeling to. And so what we try to do is remove as much of that pressure to perform as possible
and refocus it into this idea of self-imposed desire to succeed to want to get it right.
Kelly Paredes: [00:00:00] Yeah. That's a great question. Thank you Jason. Thanks, so. I think that
does it for this week. We've had some great questions. We've had a lot of really interesting
discussion about computational thinking what does that really mean? Why do we focus on it?
How do we solve problems? As always? It's a pleasure to talk with you Kelly.
I know we spend a lot of time together every day in our jobs, but it is always something I look
forward to to sitting down and recording a podcast session with you because it just is refreshing
and invigorating to talk about. These topics in depth and in detail and learn some new things
from each other.
Kelly Paredes: [00:00:35] And in Spanish, you just say iguala meant a I know I equally agree.
it's amazing that we can still we were going to have a short podcast and look at us. We're still
talking to all right. Well as usual, this is Sean, this is Kelly signing off.
Transcript source: Provided by creator in RSS feed: download file