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.