Vox

Leitura de 16 min

Using Bloom’s Taxonomy to Learn More Intentionally

Summary

In this episode of Developer Tea, host Jonathan Cottrell introduces listeners to Bloom’s Taxonomy, a framework originally developed in 1956 by Benjamin Bloom to help educators design lesson plans and evaluate student learning. The taxonomy outlines a hierarchy of cognitive skills, from basic recall to complex creation, which can be used to structure and assess one’s own learning process.

Cottrell explains the original 1956 taxonomy (knowledge, comprehension, application, analysis, synthesis, evaluation) and its 2001 revision (remember, understand, apply, analyze, evaluate, create). He describes each level, emphasizing that as one moves up the hierarchy, they gain more agency with the subject matter—progressing from simply remembering facts to understanding concepts, applying knowledge, analyzing relationships, evaluating arguments, and ultimately creating something novel.

The host then provides a practical example of how a Ruby developer could use Bloom’s Taxonomy to learn JavaScript. He walks through each level: starting with remembering syntax rules, understanding how those rules work together, applying knowledge through quizzes or simple algorithms, analyzing by comparing JavaScript to Ruby, evaluating by forming opinions about the language’s design and use cases, and finally creating by building an actual application.

Cottrell concludes by noting that learning isn’t linear and that developers can revisit the taxonomy multiple times with the same subject through spiral learning. He encourages listeners to use frameworks like Bloom’s Taxonomy to become more intentional and effective learners, ultimately improving their skills as developers.

Recommendations

Podcasts

  • Developer Tea episode on Spiral Learning — Referenced as a previous episode that discusses the concept of going through learning cycles multiple times with the same subject, relating to revisiting Bloom’s Taxonomy.

Websites

  • Learn X in Y Minutes — Recommended as an excellent website for getting exposure to a new programming language, providing a quick overview of syntax and basic concepts.

Topic Timeline

  • 00:00:00 — Introduction to evaluating learning — Jonathan Cottrell introduces the episode’s topic: how to figure out if you’ve actually learned something you set out to learn. He explains that the show’s goal is to help developers connect to their career purpose and do better work. The episode will cover both evaluating learning and using the discussed material to shape the learning process itself.
  • 00:01:25 — History and explanation of Bloom’s Taxonomy — Cottrell provides a history lesson on Bloom’s Taxonomy, created by Benjamin Bloom in 1956 to help K-12 educators. He outlines the original taxonomy (knowledge, comprehension, application, analysis, synthesis, evaluation) and the 2001 revision (remember, understand, apply, analyze, evaluate, create). He describes the pyramid structure and explains that as you understand more about a subject, you gain more agency with it.
  • 00:04:35 — Sponsor break and transition to practical application — After a sponsor message from Linode, Cottrell transitions back to discussing how listeners can use Bloom’s Taxonomy to evaluate and design their own learning programs. He mentions that the taxonomy was created to help teachers devise lesson plans and evaluation methods, and recommends looking at teaching materials to learn more about how we learn.
  • 00:07:48 — Practical example: Learning JavaScript as a Ruby developer — Cottrell walks through a practical scenario of using Bloom’s Taxonomy to learn JavaScript as a Ruby developer. He explains each level: remember (looking at syntax rules), understand (seeing how rules work together), apply (answering quiz questions, writing simple code), analyze (comparing JavaScript to Ruby, differentiating features), evaluate (forming opinions about language design, critiquing), and create (building an application, solving a problem).
  • 00:12:24 — Conclusion and importance of revisiting fundamentals — Cottrell concludes by noting that Bloom’s Taxonomy is just one perspective on learning and that developers can go through the taxonomy multiple times with the same subject (spiral learning). He emphasizes the importance of revisiting fundamentals and using frameworks from psychology, education, and neuroscience to become more effective learners and developers.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-03-12T09:00:00Z
  • Duration: 00:14:55

References

Podcast Info

Transcript

[00:00:00] How would you go about figuring out if you’ve actually learned something that you’ve set out

[00:00:10] to learn? That’s what we’re talking about in today’s episode of Developer Tea. My name is

[00:00:15] Jonathan Cottrell and my goal on this show is to help you become a better developer, to help driven

[00:00:19] developers connect to their career purpose so that they can do better work and have a positive

[00:00:25] impact on the people they have influence over. That’s the goal of the show. We’re going to get

[00:00:30] straight into today’s topic, evaluating whether you’ve learned something. And beyond evaluating

[00:00:36] whether you’ve learned something, you can actually use the same material that we’re covering today

[00:00:43] can be used to shape your learning process as well. So we’re going to talk about all of that

[00:00:48] in today’s episode. But first, I want you to take a moment and think about how you learn.

[00:00:55] Now, there’s some old kind of typical stories about how people learn differently, how I’m a

[00:01:02] visual learner and another person may be a tactile learner where they feel like they need to actually

[00:01:07] do something with the material that they’re learning. And overall, there’s a lot of opinions

[00:01:12] and there’s a lot of difference between each of us in the way that we learn. But there’s a few

[00:01:18] things that stay the same between all of us as well. But in today’s episode, I want to give you

[00:01:23] kind of a history lesson.

[00:01:25] It’s a little bit of a different type of episode for Developer Tea. But I want to give you the

[00:01:29] history of something called the Bloom taxonomy, Bloom’s taxonomy. In 1956, a man named Benjamin

[00:01:39] Bloom actually created this taxonomy. And it was pointed at kind of creating a better way of

[00:01:46] educating. Specifically, kind of K through 12 teachers were the goal audience for this.

[00:01:55] So the original taxonomy from 1956, it started with knowledge and then comprehension and then

[00:02:04] application, analysis, synthesis, and evaluation. And you can imagine these parts of the taxonomy in

[00:02:14] a pyramid structure. And you can go and view this online very easily if you just Google Bloom’s

[00:02:21] taxonomy. There was a revision to this taxonomy. And it was a revision to the Bloom’s taxonomy.

[00:02:25] And this one came out in 2001. And this is the revised version. Remember, understand, apply,

[00:02:33] analyze, evaluate, and finally, create. And there’s some subparts to this taxonomy that you can see if

[00:02:42] you go online. But I want to kind of talk about this from a high-level perspective for today’s

[00:02:47] episode. The idea of this taxonomy is that as you understand more about a subject, you begin to

[00:02:55] have more agency with that subject. You begin to be able to go from just having rote knowledge,

[00:03:02] remembering something, to understanding it, right? So how do you evaluate if you can understand

[00:03:09] something? Well, you can classify it. You can describe it to someone else. You can have a

[00:03:13] discussion about it. These are all things that are part of the built taxonomy that Bloom created.

[00:03:20] The next kind of piece of proving that you understand something is

[00:03:24] by actually taking it and applying it. This is to implement or solve something using this

[00:03:31] information to demonstrate, interpret, operate, schedule, sketch. These are all ways of showing

[00:03:37] that you can apply some information. The next step up with the latter is to analyze, right?

[00:03:44] And by the way, these kind of remind me of Maslow’s hierarchy of needs. As you move up the hierarchy,

[00:03:51] things become more complex. And maybe the hierarchy of needs is more complex.

[00:03:54] A little bit more sophisticated in terms of the way they apply to us. So analyzing,

[00:04:00] you can differentiate, you can organize, you can relate. The next step up is evaluate, right? So

[00:04:06] you can argue or defend, you can judge, you can support, you can critique. And then the final

[00:04:13] step is creation, right? Using that information to design, to construct, to develop, to formulate,

[00:04:23] to author.

[00:04:24] Again, these are all words that are coming straight out of the taxonomy, various parts of

[00:04:30] the taxonomy that Bloom created. So why is this important? We’re going to take a quick sponsor

[00:04:35] break and then we’re going to come back and talk about how you can use Bloom’s taxonomy

[00:04:39] to kind of evaluate and design your own learning program, right? So we’ll take you through each

[00:04:47] of the steps in that taxonomy and apply it to a more practical problem. Today’s episode is sponsored

[00:04:54] by Linode. Linode was launched in 2003 by a bunch of people who love solving problems. Not only do

[00:05:02] they love solving problems, but they also love programming. They’re a bunch of developers like

[00:05:08] you or like me. And it’s been their philosophy since the beginning to share their creation with

[00:05:15] others. And this is what I love about Linode is that it’s a bunch of developers who have

[00:05:20] solved some problems for themselves and they’ve turned around and they’ve decided

[00:05:24] to share this with other developers. With Linode, you can get a server up and running in just a few

[00:05:29] seconds. You pick a plan, pick a distribution and pick a location. And essentially you’re off to

[00:05:35] the races after that. Linode has SSD storage, a 40 gigabit internal network, and everything runs

[00:05:42] on Intel E5 processors. These are the fastest processors in the cloud market. Linode is also

[00:05:48] going to offer you $20 worth of credit. Head over to spec.fm slash Linode and you

[00:05:54] can choose the code developer T 2018. That’s developer T 2018, all one word. And you’ll get

[00:06:00] $20 worth of credit. Again, head over to spec.fm slash Linode. Thank you again to Linode for

[00:06:06] sponsoring today’s episode. And by the way, Linode plans start at just $5 a month and they have

[00:06:12] super high end plans as well. So pretty much everything is covered on Linode. Go and check

[00:06:18] it out, spec.fm slash Linode. So we’re talking about Bloom’s taxonomy.

[00:06:24] Today, Bloom’s taxonomy. This taxonomy again was created to help people who are in the classroom

[00:06:31] setting to devise a lesson plan, to devise evaluation plans, to understand, have I actually

[00:06:41] gotten this subject? Do I really understand what’s going on with this subject? And as a side note,

[00:06:47] I really recommend if you haven’t done anything like this before, go and look at some of the

[00:06:54] teaching materials that are available. Some of the research on teaching and the research

[00:07:00] is also on learning just kind of by extension. What you’ll learn is there’s a lot about this

[00:07:08] subject that we know, but there’s also a lot that is still yet to be discovered because we’re still

[00:07:14] learning about how we learn as humans. So this is one way that you can approach kind of crafting a

[00:07:22] more intentional way of learning about how we learn as humans. So this is one way that you can

[00:07:24] engage a new subject in order to learn it. So let’s go back through the taxonomy and then we’ll

[00:07:32] apply it to a more practical scenario so we can see how we may be able to design a learning plan.

[00:07:39] Remember, understand, apply, analyze, evaluate, and create. Okay, so let’s say that I’m a Ruby

[00:07:48] developer and I want to learn JavaScript. I know a little bit about it because I’ve done a lot of

[00:07:54] a few websites here and there. I’ve used jQuery maybe, but I want to learn JavaScript. So how

[00:07:59] might I use Bloom’s taxonomy along the way? Well, first, I’m going to go and look at some other

[00:08:07] people’s code, right? This is going to expose me to JavaScript so that I actually have a little bit

[00:08:14] to start remembering, right? The next piece that I might cover is looking at some kind of syntax

[00:08:23] and remembering.

[00:08:24] Certain things about JavaScript. So I might start with the learn X and Y minutes. If you haven’t

[00:08:31] seen this, certainly go and Google it. It’s an excellent website for getting just a little bit

[00:08:36] of exposure to a language, a new programming language. But I might go and look at some of

[00:08:42] the rules around the syntax for JavaScript, only trying to remember them, right? Not trying to

[00:08:50] necessarily use them, not trying to write anything with them yet.

[00:08:54] But only to remember them. And then we’ll step up the ladder one step and try to understand

[00:09:00] how those syntax rules work together. So I remember the rules, but I’m not really sure

[00:09:07] why the rules exist. I’m trying to understand how they work together. So figuring out, you know,

[00:09:14] how can I look at some code and understand, generally speaking, what’s going on? How might

[00:09:21] I be able to describe that syntax? So I’m going to go and look at some of the rules around the

[00:09:24] object or that’s an array. Now I want to take it up to the next level of understanding, to

[00:09:29] application. During application, I might answer some quiz questions about JavaScript. Maybe I’ll

[00:09:37] write a little piece of code that performs a simple algorithm, right? This isn’t something

[00:09:43] that I’m creating for myself. Remember, that’s going to be the last step in Bloom’s taxonomy.

[00:09:49] But instead, this is just applying the knowledge that I have.

[00:09:54] To be able to answer some kind of questions. This is basically the moment that synthesis

[00:09:59] has begun, right? So we’ve moved beyond only understanding and only remembering. These are

[00:10:06] things that happen only in our heads. And now we’ve moved into a little bit more analysis phase,

[00:10:12] right? And in fact, the next step up this taxonomy is analysis, analyze. So what can we do in this

[00:10:21] step? Well, we may take some Ruby code.

[00:10:24] That does a similar kind of algorithmic process. And we might write the equivalent JavaScript code.

[00:10:32] Or maybe we look at the primitives in Ruby and compare them to the primitives in JavaScript.

[00:10:39] The fundamental types that both of those languages have. Or maybe we look at a piece of Ruby,

[00:10:46] like popular Ruby code that has been well documented or a lot of people use it. And then

[00:10:53] we look at the same thing. And then we look at the same thing. And then we look at the same thing.

[00:10:54] In JavaScript. And we analyze, we differentiate. Remember, that’s the key word for analysis for

[00:11:01] that part of the taxonomy. We can differentiate, we can relate things, we can compare them,

[00:11:06] we can distinguish them from each other, right? The next step up the taxonomy,

[00:11:11] and this is the second to last step, but it’s the evaluation stage, right? At this point,

[00:11:16] we might be forming opinions about JavaScript. We may form an opinion about the design,

[00:11:24] the design of the language, or maybe the syntax of the language. Or we might start thinking about,

[00:11:29] you know, what is JavaScript going to be good for? What will it do better than Ruby? Or what will it

[00:11:35] do worse than Ruby? These are things that I’m evaluating. I’m creating my own critique. I’m

[00:11:42] creating my own arguments, my own defenses for this newfound knowledge. And then finally,

[00:11:50] we get to the creation phase, right? This is,

[00:11:54] the kind of the end point of Bloom’s taxonomy. And this is to create something novel,

[00:12:00] or at least somewhat novel, with your newfound knowledge. So this would actually be, you know,

[00:12:07] writing your own application, maybe launching something with JavaScript, maybe solving a

[00:12:12] problem that you have with it. And ultimately, at this point, you’ve stepped through all of those,

[00:12:17] those points in the taxonomy. Now, this is only one perspective of how learning,

[00:12:24] works. And the reality is, you know, if you go back and listen to an episode that we called

[00:12:29] Spiral Learning, you could go through this same taxonomy multiple times with a given subject,

[00:12:37] right? You could go back to the bottom of this pyramid and start back at remembering and

[00:12:43] refreshing the way that you think about a given subject or refreshing your knowledge on that

[00:12:49] subject and iterating on that knowledge. There’s nothing to stop you from,

[00:12:54] going back through that process, relearning fundamental things. You know, if you’ve been

[00:12:59] a programmer for very long, then you can probably attest to this fact that when you go back and look

[00:13:05] at fundamentals that you haven’t looked at in a long time, usually there’s some kind of epiphany

[00:13:10] that results. So it’s very important that we understand the way that our minds work, and we

[00:13:15] continue to seek more understanding about how learning works. We can use these frameworks,

[00:13:23] these taxonomies, the work that has been done by psychologists and educators and neuroscientists

[00:13:28] and economists and all of these various kind of research positions. We can use this information

[00:13:36] to become more effective at the learning process and ultimately become more effective as developers.

[00:13:43] Thank you so much for listening to today’s episode of Developer Tea. Once again, a huge thank you to

[00:13:49] Linode. We wouldn’t be able to do what we do without our sponsors.

[00:13:52] And Linode is helping you do what you do as a developer. Head over to spec.fm slash Linode,

[00:13:59] and you’ll get $20 worth of credit for using the code DEVELOPERTEA2018 at checkout. That’s all one

[00:14:04] word, spec.fm slash Linode. Thank you so much for listening. And I do want to take a moment and thank

[00:14:11] those of you who have taken the time to go and leave a review in iTunes and subscribe specifically

[00:14:18] in iTunes. This is so important because iTunes is a place where you can get the most out of your

[00:14:22] content. And iTunes kind of acts as the central hub for most of the podcast applications that you

[00:14:28] see, you know, the mobile applications. The way these applications choose what to show you

[00:14:34] is mostly through iTunes. So this is the best way you can help other developers just like you

[00:14:41] find the show. Thank you so much for listening to today’s episode. And until next time, enjoy your tea.

[00:14:52] Bye.

Visão de gráfico