Stuck in Your Coding Journey? Try Leveraging Bloom’s Taxonomy

When it comes to learning to code, I find that folks, including myself, tend to get stuck at one point or another. For me, challenges came up when I was learning data structures and algorithms. After all, a lot of concepts in computer science are counterintuitive, and many times those concepts are taught from a theoretical point of view. As a result, it’s hard to make sense of them.

Fortunately, learning is something that has been studied extensively in various fields from education to neuroscience. All of this research has led to amazing innovations in the way we teach material as educators, but what about if you want to teach yourself? Well, today I’m going to introduce you to an awesome tool that educators use when they’re designing their courses: Bloom’s Taxonomy. Hopefully by the end of this article, you’ll have a feel for new ways in which you can structure your own learning. With that said, let’s get into it!

Table of Contents

What Is Bloom’s Taxonomy?

In short, Bloom’s taxonomy—or at least the cognitive aspect of it—is a way of categorizing different types of cognitive processes. These processes are more or less organized in a hierarchy around the amount of cognitive effort needed to accomplish a particular task. For example, the lowest domain in this hierarchy is “Remember” which is the ability to recall facts. Meanwhile, the highest domain is “Create” which is the ability to produce original work. The following list shows all of the cognitive processes in Bloom’s taxonomy in order of lowest to highest thinking skill:

• Remember
• Understand
• Apply
• Analyze
• Evaluate
• Create

Bloom’s taxonomy is particularly useful for educators because it allows us to create learning objectives for our courses. For instance, we can imagine that we’re designing a Python course for beginners. In a beginner course, we probably have some expectations around what we want our students to learn. In other words, I might argue that students should be able to write control flow statements like loops and conditionals. On the other hand, you might argue that students should be able to define various programming terms like “algorithm” and “testing.” Eventually, we’ll end up with a list of learning outcomes, but how do we know when we’re done? Even better, how do we know our learning outcomes are good (whatever that means)?

Unfortunately, this process of generating learning outcomes is messy and filled with opinions that may or may not be based in empirical evidence. That’s why it’s often helpful to lean on a framework like Bloom’s taxonomy, so we can think about learning in terms of cognitive processes rather than content knowledge. Sure, it’s important that students can write loops and whatnot, but what does that really mean in terms of the development related to Python?

As a result, we might take a peek at Bloom’s taxonomy and try to write a learning objective for each of the cognitive processes. For example, the definition learning objective falls under remembering while the control flow objective falls under applying. Already, we can see a gap. What sort of understanding objectives should we create? I’ll leave that up to you to think about.

Why Use Bloom’s Taxonomy When Learning to Code?

If educators can use Bloom’s taxonomy to create learning objectives for courses, what is stopping us from using it to write our own learning objectives? If we can, we’ll be well on our way to getting unstuck.

See, Bloom’s taxonomy isn’t just useful for helping us clarify what we want to learn. It also helps us design our own learning activities. For example, if we write a learning objective for ourselves around defining programming terms, then we can easily come up with activities that will aid in the process of memorization. In fact, many folks have put together a list of verbs that can be used with each of the cognitive processes—often for writing learning objectives but equally as helpful for brainstorming activities. Here’s an example list for the “Remember” process:

• Outline
• Quote
• Define
• Duplicate
• Match

A common old-school practice for memorizing terms and their definitions would be to copy them down repeatedly. Though, it may be a little faster to test yourself using flashcards. Regardless, the goal is to align the objective with whatever activity you come up with. In other words, is it really helping you achieve your goal? What you’ll find is that whatever tasks you’re currently doing are likely not in alignment, which causes you to get stuck.

Here’s another example! Let’s say we want to be able to understand loops in code. That seems like a fairly reasonable objective. What kind of activities might we do to train this skill? Well, we might start by commenting code that contains loops. If we can describe what that loop is doing at a high level, surely we understand it. Similarly, we might try tracing through the loop with different inputs. If we can figure out how the loop behaves under different conditions, we probably understand it. Even activities like modifying the loop and predicting the behavior could be good exercises for testing our understanding of loops.

In short, using Bloom’s taxonomy is an excellent strategy for helping us brainstorm activities we can do to advance our learning.

How Do I Write My Own Learning Objectives?

Now truthfully, writing our own learning objectives is always going to be harder than when an educator does it. After all, how do we know what we don’t know? That said, surely we have an overarching goal in mind. For example, maybe we want to learn Python ourselves. That seems like a great place to start!

From there, we’ll probably want to start low on the cognitive process domain. Before we write any code, we should probably learn some Python lingo. For example, here are some questions we might have that could point to some learning objectives:

• What is Python?
• What is a programming language?
• What is an IDE?
• How did Python come about?
• Who uses Python?

Overall, these questions get at some of the big picture concepts. As a result, we might write the following objective: we should be able to describe a rough history and use of the Python programming language.

As we concur some of the context around the programming language, we can start thinking about other useful memorization objectives. For example, what terms in Python should we learn? After that, we’ll want to start talking about deeper understanding. For instance, can we summarize the behavior of a code snippet? Then, we might want to talk about actually writing our own code.

In short, this strategy can help us organize our learning journey. We’re not going to be able to just jump into the deep end with writing code. We need to have a fundamentally deeper understanding of it and writing learning objectives can make that more clear.

How Do I Know When I’ve Accomplished a Learning Objective?

If you followed the steps up to this point, you already should have a plan to help you learn in a more meaningful way. However, one of the challenges of self-directed learning is knowing when you actually know something. For instance, it’s very easy to be lulled into a false sense of security around a topic. You can only be truly sure you know something when you’ve had a chance to assess your learning.

In an academic setting, assessment is the norm. In fact, I’d argue too much focus is placed on assessment. In my experience, most educators rely on assessment to do the teaching. For example, why not have a high stakes exam that forces students to cram knowledge into their heads on their own time?

That’s not to say that assessment is bad. In fact, it’s incredibly important. Otherwise, how would we know what we know? Unfortunately, it’s not always obvious how we would assess ourselves. Surely, the brain assessing itself is a bit of a conflict of interest, right?

That said, there are some self-assessments you might try for some of the cognitive processes:

• Remember: flash cards, matching, etc.
• Understanding: prediction of program behavior
• Apply: code and test (e.g., Hackerrank)

As for the higher cognitive domains, self-assessment is a bit trickier. I welcome you to share some of your own techniques!

Get to Learning!

The purpose of the article today was to introduce yet another way you can go about constructing your own learning. In particular, you probably found this article because you are currently stuck somewhere in your coding journey. Hopefully, I’ve shared some ways to help you out of that hole. If not, best of luck in your journey!

With that said, that’s all I have for now. If you’d like to learn more about teaching and learning programming, check out the following:

• Lessons Learned From Two Years of College Teaching
• A Look at a Typical Computer Science Lecture
• 11 Python Practice Problems for Beginners

Also, I love talking about Python, and I’m not the only one. Here are some resources that can be found on Amazon (#ad):

• Effective Python: 90 Specific Ways to Write Better Python
• Python Tricks: A Buffet of Awesome Python Features
• Python Programming: An Introduction to Computer Science

Otherwise, thanks for hanging out! See you next time.