top of page
Search
  • Writer's pictureBy Alexander Batenhorst

How Bloom's Taxonomy Can Help You Learn Software Development

SDK • Scaffolding


If you are a software developer or aspiring to become one, you might have heard of Bloom’s taxonomy. It is a framework that classifies different levels of cognitive skills, from lower-order to higher-order thinking. Bloom’s taxonomy can help you improve your learning process and achieve your goals more effectively.


Bloom's Taxonomy Consists of Six Levels:


Each level requires a different type of mental activity and builds on the previous ones. Here is a brief overview of what each level entails:

  • Remember: this is the basic level of learning, where you can recall facts and information. For example, you can remember the syntax and keywords of a programming language, or the names of common data structures and algorithms.

  • Understand: this is the level where you can explain the meaning and purpose of what you learned. For example, you can understand how a loop works, or what a function does.

  • Apply: this is the level where you can use what you learned in new situations or contexts. For example, you can apply a sorting algorithm to sort a list of numbers, or use a loop to iterate over an array

  • Analyze: this is the level where you can break down what you learned into smaller parts and examine how they relate to each other. For example, you can analyze the structure and logic of a program, or the advantages and disadvantages of different data structures.

  • Evaluate: this is the level where you can judge the quality and effectiveness of what you learned based on criteria and standards. For example, you can evaluate the performance and efficiency of a program, or the suitability and reliability of a data structure.

  • Create: this is the highest level of learning, where you can synthesize what you learned into something new and original. For example, you can create a new program that solves a problem, or a new data structure that meets your needs.

How Can You Use Bloom's Taxonomy to Learn Software Development?


Here are some tips:

  • Start with the lower levels and work your way up. Don’t try to jump to the higher levels without mastering the basics first. For example, before you create your own program, make sure you understand the syntax and logic of the programming language you are using.

  • Use different resources and methods to learn at each level. For example, you can use books, videos, tutorials, online courses, blogs, podcasts, etc. to learn new concepts and facts. You can use exercises, quizzes, projects, etc. to practice applying and analyzing what you learned. You can use feedback, reviews, tests, etc. to evaluate your work and improve it. You can use tools, frameworks, libraries, etc. to create your own products and solutions.

  • Challenge yourself to move up the levels as you progress. Don’t settle for just remembering or understanding what you learned. Try to apply it in different ways, analyze it from different perspectives, evaluate it against different criteria, and create something new out of it—create.

The learning path of software development and Bloom’s taxonomy is not a rigid or linear model. You can move back and forth between the levels as needed. You can also combine different levels in your learning activities. The software you build doesn’t always have to solve a problem.


Start Building Software Programs


Some good layering examples where you can build high quality software but at a lower level in blooms include things you might enjoy like:

  • a “hello world” program

  • Addition and subtraction of numbers (integers, iteration, etc.)

  • a CRUD program (create, read, update, and delete)

  • a loyalty points program for a supermarket (member names, addresses, id’s, etc.)

  • a Blu-ray collection organizer (titles, year, format, etc.)

You can start with a simple program and work your way up in complexity. For example, you can create a program that applies an algorithm while analyzing its performance. And then when you are ready, build one of your favorite programs. Perhaps something like for a media collection or ATM model banking program. These examples could use the CRUD operations, and you could start easy with the "read" portion working your way to "delete." "read," for example is the part of the software that prints the data on the console—akin to a "Hello world" program. By building lower-level high quality software, you can participate in basic concepts of software development. This allows you to move up the Bloom’s pyramid of knowledge.


The whole idea of using Blooms is to get your hands wet with some basic software development fundamentals. The key to Bloom’s taxonomy is stacking knowledge in order to not to overwhelm the learner. Building small higher quality software is the proverbial laying of the cement foundation of knowledge. The best advice I was given by senior level developers and programs (bootcamps) I’ve participated in are to build software you love. So I built a media collection piece of software to organize my personal collection of physical discs—using CRUD starting with "read."


The higher you move up the Blooms, the more you are able to “evaluate” and “judge.” All of which are only accomplished once you achieve a higher level of understanding—Blooms. And by starting with “remember,” which is the memorization piece, you can begin your software development learning journey. These are all key fundamentals of the learning process every brain goes through that I learned during my undergraduate program as a former educator. The same can be applied toward software development.


Bloom’s taxonomy is a useful tool that can help you structure your learning process and enhance your cognitive skills as a software developer. By using it wisely, you can become a more effective and efficient learner. And more importantly, without overwhelming the learner. Blooms is comprised of six layers starting from “remember,” the lowest level to the highest level of “create.”


In a future blog post, I will demonstrate the first three lower levels of Blooms. I will provide an in-dept example of how we can gain knowledge by using an SDK approaching bottom levels of Bloom's.

References:

  • Reha, M. K. (2019, September 20). How to teach software development using Bloom’s taxonomy. Grand Canyon University. https://www.gcu.edu/blog/engineering-technology/how-teach-software-development-using-blooms-taxonomy

  • Armstrong, P. (2010). Bloom’s taxonomy. Vanderbilt University Center for Teaching. https://cft.vanderbilt.edu/guides-sub-pages/blooms-taxonomy/

  • Goel, S. (2010, July 29). Bloom’s taxonomy wrt software development education. https://goelsan.wordpress.com/2010/07/29/blooms-taxonomy-wrt-software-development-education/

  • Silva, J., Plakidas, K., & Eckhardt, J. (2015). Bloom’s taxonomy in software engineering education: A systematic mapping study. In 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering (Vol. 2, pp. 609-612). IEEE.

  • Khan, S., & Khan, R. A. (2018). A systematic review of the use of Bloom’s taxonomy in computer science education. In Proceedings of the Future Technologies Conference (FTC) 2018 (pp. 1156-1171). Springer.

0 comments

Recent Posts

See All
bottom of page