which is an example of decomposition in computational problem solving

• School Guide
• Class 11 Syllabus
• Class 11 Revision Notes
• Maths Notes Class 11
• Physics Notes Class 11
• Chemistry Notes Class 11
• Biology Notes Class 11
• NCERT Solutions Class 11 Maths
• RD Sharma Solutions Class 11
• Math Formulas Class 11

What is Decomposition Computational Thinking?

• Idea of Efficiency in Computational Thinking
• What are Lateral and Linear Thinking in Ideation?
• Ideation in Design Thinking
• Decomposition In DBMS
• Functions Decomposition in Software Engineering
• What Is Role of Decomposer in Ecosystem?
• Decomposition Reaction
• What is design thinking in product management ?
• What is Computational Physics?
• Computational Graphs in Deep Learning
• What is Problem Decomposition?
• What is Theory of Design Thinking?
• What is Autonomic Computing?
• What is Fragmentation in Operating System?
• Introduction of Theory of Computation
• What is Secure Multiparty Computation?
• Computer Vision - Introduction
• What is the Importance of Mathematics in Computer Science?
• Introduction to Computation Complex Theory
• Cloud Deployment Models
• Impact of Technology on Society
• Business Studies
• Expressions in Python
• Journal Entries
• Boolean Algebra
• Python Tokens and Character Sets
• Trigonometry Table | Trigonometric Ratios and Formulas
• Difference between Domestic Business and International Business
• Cyber Forensics

Computational thinking is a way of thinking logically and solving problems in an organized manner. It is the process of approaching a problem in a structured way and creating & expressing an answer for such a problem that can be easily carried out by a system or machine. This is not only for programmers rather it is applicable in different areas of fields. Having the knowledge of computational thinking, various quantitative and data-related problems can be solved and it will also give you a foundation for solving real-world problems. Computational thinking differs from person to person and let’s say a person thinking about using an algorithm then different persons will think of algorithms in different ways like, a scientist may think of it as an experimental procedure, a computer scientist might understand it as a study of algorithms and its applications, etc. The core concepts of computational thinking include modeling, abstraction, decomposition, algorithmic thinking, logical thinking, etc. An example of computational thinking can be a prediction of weather or climate that can be done only with the help of computer models for a long period of time, etc. In this article, we will learn about decomposition in computational thinking.

Decomposition

Decomposition can be defined as the process of solving a complex problem and breaking it into more sub-problems that can be solved easily. Solving a complex problem may get difficult sometimes but finding the solution for every sub-problem will be simple after which the sub-problems can be put together for finding the full solution to the original problem. It is a divide-and-conquer technique, something seen in various places outside computing. It is important to note that it won’t give you a complete plan of action, rather it provides a starting point for formulating one like for example, a problem may be decomposed with its sub-tasks but it doesn’t show you the order in which you can tackle them. For easier understanding of decomposition:

• Identify the elements or parts of a complex problem
• Divides a task into various subtasks(sequentially)

Importance of Decomposition 

• It helps in solving complex problems easily.
• The decomposed sub-tasks can be carried or solved by different persons or a group of persons (if one is not having enough knowledge about the full problem).
• When the problem is divided into sub-tasks each sub-task can be examined in detail.

The best example for decomposition in computer science is Recursion. In recursion, we use it to simplify a problem and break the larger problem into sub-parts and then solve each of the subparts. Some of the real-life common examples that are used in your daily lives of decomposition are given below:

• If you want to make a new game using computer programming then, for making the game, you will write different functions for different actions in the game and then those functions will act as the subprograms or sub-tasks, after which these sub-tasks will be put together to form a full game.
• In sports, sometimes teams break the opposition team up into weaker teams otherwise they will unite into a stronger whole.
• When you want to clean your house, you make a to-do list for doing your tasks.
• When making a Science project, there we need to do various things like background research, experimentation, writing a dissertation, and submitting it, etc. So, that will also be a great example of decomposition.
• A person learns a new language and how to form a sentence using a new foreign language by breaking it down into subparts like subject, verb, and object, etc.
• Another example can be a mathematics problem, Like the following number 256.37 can be written as 2*10 2 +5*10 1 +6*10 0 +3*10 -1 +7*10 -2

A good example of decomposition in computer science can be the merge sort algorithm. In this algorithm, we divide the array into two parts, call itself for the two parts, and then merge the two sorted parts into one. The below algorithm of the merge sort shows that the array is recursively divided into 2 parts till its size becomes 1. Once it becomes 1, the merge process is carried out, and the array is merged completely.

MergeSort(arr[], l,  r) If r > l 1. Finding mid point and dividing arr into 2 halves               middle m = l + (r – l) / 2 2. Call mergeSort for first half:                 Call mergeSort(arr, l, m) 3. Call mergeSort for second half:             Call mergeSort(arr, m + 1, r) 4. Merging 2 and 3 halves in one:             Call merge(arr, l, m, r)

Please Login to comment...

Similar reads.

• School Learning
• School Programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

How To Break a Problem Down: A Guide for Using Decomposition in Computational Thinking

April 07, 2023

Thinking like a programmer means thinking like a computer. If you want to think like a programmer, you’ll want to learn computational thinking. There are four stages of computational thinking:

Decomposition

Pattern recognition

Abstraction

Design (AKA pattern forming)

This article outlines how to break a problem down with the first stage: decomposition.

How to break a problem down

It is foolish to answer a question that you do not understand. It is sad to work for an end that you do not desire. -George Polya

Did this ever happen to you?

You pick up a problem, jump right in and start coding a solution, only to find yourself rolling it back to account for something you didn’t think about at the outset.

This happens when we don’t define our problem before we start solving it. Before we break a problem down, we need to understand it. The first step in understanding the problem is to define both the starting point, or current state, and the end point, or goal.

In How to Solve It , George Polya provides some advice on how to understand the problem:

Restate the problem in your own words : Restating the problem in your own words can also inadvertently reveal the solution. This is also a good habit to be in when working with others to ensure nothing gets lost in translation.

Illustrate the problem with pictures and diagrams : This is especially useful if you are working on a problem with user flow or trying to make sense of spaghetti code. If the problem is spanning multiple modules or microservices, a quick sketch becomes a map that provides a global perspective on the problem and, as above, may inadvertently reveal a solution. There’s a reason Solutions Architects do this for clients… 🤔

Identify the principal parts of the problem: the data, the goal, and any unknowns : Get clear on the input and the output of the problem as well as anything that might jam you up. Of course, there are always unknown unknowns, and there’s nothing to be done until we encounter them.

Polya also provides a set of questions we can ask ourselves to work towards a better understanding of a given problem:

Where should I start? : Start with the problem statement, obvi!

What can I do? : Visualize the problem as a whole (draw that picture!), then isolate the principal parts.

What can I gain by doing so? : Identify the details that are revealed through visualizing the problem and isolating the principal parts.

Sounds like good life advice, too!

Lastly, and not necessarily possible to answer at the outset, Polya counsels us to ask ourselves the following question:

• Is a solution possible?

Using decomposition in computational thinking

Now that we understand the problem we are solving, let’s decompose it!

What is decomposition?

Just like rotting organic substances, decomposition is the process of breaking a problem down into smaller parts.

Speaking of rotting organic substances, how would you eat a watermelon?

Unless it was very small or your mouth was very big, you would need to cut, or divide, it into bite-size pieces, then eat those pieces one at a time.

The same is true for any programming problem.

A common strategy in decomposition is to ask the following question:

What is the smallest problem I can solve?

If, for example, you are writing a sorting algorithm. The smallest problem to be solved is an array or list containing two elements, like this:

You can then begin building a solution to this problem, which is very likely a conditional statement combined with a swap.

After solving the smallest problem, you can then ask yourself a variation of the previous question:

What is the next smallest problem I can solve?

Continuing with our sorting exampele, it may be something like this:

You build on your previous solution by wrapping it in a loop to iterate over the elements in the array.

Does this approach look familiar?

If so, that’s because it’s similar to a very important concept in algorithm design…

Divide and conquer

Divide and conquer algorithms recursively break down a problem into smaller problems to be solved and then recombined into a solution.

Not every problem requires a divide and conquer solution, but we want our approach to problem solving to be similar in that we continually break a problem down, or decompose it, into its smallest components.

Here’s a real-world scenario: build a web application.

That’s a significant undertaking and, whether you were tackling this alone or with a team, you would want to divvy up the work. How would you do that?

First, divide the application in half: front end and back end.

Then, for each branch of this tree, there are a series of questions to be answered: what frameworks, libraries, and architectural patterns will you be using. Those decisions will determine how to divide the front end into components and the back end into modules.

Metacognition

We are now five headers deep!

It’s time to get meta!

This process of applying divide and conquer strategy to our own thinking is called metacognition .

According to Barbara Oakley in Learn Like a Pro , metacognition is like “an extra brain outside your main one” that “think about how you are thinking.” Oakley continues:

This extra brain pauses to consider how you should best approach problems and what strategies you should use.

How do we use and strengthen our extra brain?

By asking questions.

Oakley provides a four step model for being a metacognitive learner:

Understand the task

Set goals and plan.

Monitor and adjust.

Where have we seen this or something like it before?

It’s similar to the four step model outlined by George Polya in How to Solve It :

Understand the problem

Develop a plan

Execute the plan

Evaluate the results

We’ll bring things full-circle with this metacognitive quote from Polya on the process of decomposition:

You examine an object that touches your interest or challenges your curiosity: a house you intend to rent, an important but cryptic telegram, any object whose purpose and origin you puzzle, or any problem you intend to solve. You have an impression of the object as a whole, but this impression, possibly, is not definite enough. A detail strikes you, and you focus your attention upon it. Then, you concentrate upon another detail; then again, upon another. Various combinations of details may present themselves and after a while you again consider the object as a whole but you see it now differently. You decompose the whole into its parts, and you recombine the parts into a more or less different whole.

How to break a problem down with decomposition

Decomposition is the first stage of computational thinking. When we decompose a problem, we break it down into smaller problems. The process of decomposition often reveals patterns that point to the solution. We’ll look at pattern recognition in the next article. Stay tuned!

Understanding Computer Science Decomposition: A Comprehensive Guide

Computer science decomposition is a fundamental concept that plays a crucial role in software development, problem-solving, and algorithm design. It involves breaking down complex problems or tasks into smaller, more manageable components, allowing for easier understanding and efficient implementation. In this blog article, we will delve deep into the world of computer science decomposition, exploring its various techniques, benefits, and applications.

In the first section, we will explore the basics of computer science decomposition, providing you with a clear understanding of its definition and importance. We will discuss how decomposition allows developers to tackle complex problems by dividing them into smaller sub-problems, making the overall task more manageable.

Table of Contents

Understanding the Basics of Computer Science Decomposition

Computer science decomposition is a problem-solving technique that involves breaking down complex problems into smaller, more manageable sub-problems. By dividing a problem into smaller components, developers can focus on solving each part individually, leading to a more efficient and structured approach. Decomposition allows for a systematic analysis of the problem and helps in creating reusable and modular code.

The Importance of Decomposition in Problem-Solving

Decomposition is crucial in problem-solving as it simplifies complex tasks and makes them more approachable. When faced with a complicated problem, breaking it down into smaller sub-problems allows developers to identify patterns, dependencies, and relationships between different components. This enables them to design and implement efficient solutions for each sub-problem, ultimately leading to an effective overall solution.

Divide and Conquer: The Key Principle of Decomposition

The divide and conquer technique lies at the heart of computer science decomposition. By breaking down a problem into smaller parts, developers can conquer each part individually before combining them to solve the entire problem. This approach not only simplifies the problem-solving process but also improves code readability, reusability, and maintainability.

The Role of Decomposition in Software Development

In software development, decomposition plays a crucial role in creating modular and reusable code. By breaking down a larger software project into smaller modules or functions, developers can work on different parts simultaneously, improving productivity and collaboration. Modular code allows for easier maintenance and debugging, as changes or fixes can be applied to specific modules without affecting the entire system.

Top-Down Decomposition: Breaking Down Problems from the Top

Top-down decomposition is a popular technique used in computer science. It involves breaking down a problem or task from a high-level perspective, starting with the main problem and gradually dividing it into smaller sub-problems. This approach allows developers to focus on the overall structure and logic of the problem before diving into the details.

Breaking Down the Problem into Sub-Problems

When applying top-down decomposition, the main problem is divided into sub-problems based on their logical relationship. Each sub-problem represents a smaller part of the overall problem and can be solved independently. By decomposing the problem in a hierarchical manner, developers can easily navigate through the complexity and design efficient solutions for each sub-problem.

Advantages of Top-Down Decomposition

Top-down decomposition offers several advantages in problem-solving and software development. Firstly, it provides a high-level overview of the problem, allowing developers to understand the problem space and identify the essential components. This approach also facilitates a modular and organized code structure, as each sub-problem can be implemented as a separate function or module. Additionally, top-down decomposition promotes code reusability, as the solutions to sub-problems can be applied to similar problems in the future.

Example: Top-Down Decomposition in Web Development

Let’s consider a web development project where the main goal is to create an e-commerce website. Applying top-down decomposition, the main problem can be broken down into sub-problems such as user authentication, product listing, shopping cart management, and payment processing. Each sub-problem can be further decomposed into smaller tasks, providing a clear roadmap for development.

Bottom-Up Decomposition: Building from the Ground Up

Bottom-up decomposition is another powerful technique that focuses on starting with the smallest components and gradually building up to solve complex problems. Unlike top-down decomposition, it emphasizes the importance of understanding and solving the individual building blocks before tackling the bigger picture.

Starting with the Smallest Components

When applying bottom-up decomposition, developers begin by identifying and solving the smallest components or elements of a problem. Once the individual elements are understood and solved, they are combined to build larger components, eventually solving the complete problem. This approach allows for a more granular understanding of the problem and ensures that each component is correctly implemented.

Advantages of Bottom-Up Decomposition

Bottom-up decomposition offers several advantages, especially in scenarios where the problem is not well-defined or the requirements are constantly changing. By focusing on the individual components, developers can gain a deep understanding of their functionality and behavior, leading to more accurate and robust solutions. Additionally, bottom-up decomposition promotes code reusability, as the smaller components can be reused in different contexts or scenarios.

Example: Bottom-Up Decomposition in Machine Learning

Consider a machine learning project where the goal is to build an image recognition model. Applying bottom-up decomposition, developers start by understanding and implementing basic concepts such as feature extraction or classification algorithms. Once these individual components are working correctly, they are combined to build a complete image recognition system. This approach ensures that each component is thoroughly tested and optimized before integration.

Modularization: The Power of Reusable Components

Modularization is essential in computer science decomposition, as it allows for the creation of reusable and interchangeable components. By dividing a problem into modules, developers can encapsulate functionality, promote code reuse, and improve the overall maintainability of the system.

Creating Modular Code

Modular code consists of independent and self-contained units of functionality, known as modules. Each module focuses on a specific task or feature and can be developed and tested separately. Modular code promotes code organization and reduces complexity by breaking down the problem into smaller, manageable parts.

Advantages of Modularization

Modularization offers several advantages in software development. Firstly, it enhances code reusability, as modules can be easily reused in different projects or scenarios. This saves development time and effort, as developers can leverage existing modules instead of reinventing the wheel. Additionally, modular code improves maintainability, as changes or updates can be applied to specific modules without affecting the entire system. This reduces the risk of introducing bugs or errors during the modification process.

Example: Modularization in Game Development

In game development, modularization is crucial for creating complex and scalable games. Each game component, such as player movement, enemy AI, or level design, can be developed as a separate module. These modules can then be combined to build different types of games or reused in future projects. Modularization allows game developers to efficiently manage and maintain game code, leading to more robust and extensible games.

The Role of Abstraction in Decomposition

Abstraction is a vital concept that goes hand in hand with computer science decomposition. It allows developers to focus on the essential details while hiding unnecessary complexities. Abstraction provides a high-level view of the problem, facilitating effective decomposition and solution design.

Understanding Abstraction in Decomposition

In the context of computer science decomposition, abstraction involves identifying and representing the essential aspects of a problem while ignoring irrelevant details. By abstracting away unnecessary complexities, developers can focus on the core components and relationships within the problem, making the decomposition process more manageable.

Benefits of Abstraction in Decomposition

Abstraction offers several benefits in decomposition. Firstly, it simplifies the problem-solving process by removing unnecessary distractions and details. This allows developers to focus on the key elements and their interactions, leading to more efficient and effective solutions. Abstraction also improves code readability and maintainability, as the essential components are clearly defined and separated from the implementation details.

Example: Abstraction in Database Design

Consider a database design project where the goal is to create a system for managing employee information. When applying abstraction, developers focus on the essential entities such as employees, departments, and projects, while abstracting away the implementation details of the database management system. This high-level view enables efficient decomposition of the problem into sub-problems related to data modeling, query optimization, and security.

Applying Computer Science Decomposition in Real-World Scenarios

In this section, we will showcase how computer science decomposition is applied in various real-world scenarios. We will examine its utilization in software development, algorithm design, and problem-solving, providing you with valuable insights into its practical applications.

Decomposition in Software Development

Software development heavily relies on decomposition to manage complexity and improve productivity. By breaking down a large software project into smaller modules or functions, developers can work on different parts simultaneously, leading to faster development cycles and better code organization. Decomposition also allows for easier debugging and maintenance, as changes or fixes can be applied to specific modules without affecting the entire system.

Decomposition in Algorithm Design

In algorithm design, decomposition is essential for solving complex problems efficiently. By decomposing a problem into smaller sub-problems, algorithm designerscan focus on solving each sub-problem individually, using appropriate algorithms or strategies. Once the sub-problems are solved, they can be combined to form the solution for the overall problem. Decomposition in algorithm design improves efficiency, as it allows for the reuse of existing algorithms or the development of specialized algorithms for specific sub-problems.

Decomposition in Problem-Solving

Decomposition is a valuable technique in problem-solving, as it enables a systematic approach to complex problems. By breaking down a problem into smaller sub-problems, problem solvers can analyze each component separately, identify patterns or dependencies, and design effective solutions. Decomposition helps in managing cognitive load and provides a structured framework for problem-solving, leading to improved efficiency and accuracy.

Benefits of Computer Science Decomposition

Computer science decomposition offers numerous benefits that enhance development processes and problem-solving capabilities. Let’s explore some of the key advantages:

Improved Understandability

Decomposition simplifies complex problems by breaking them down into smaller, more manageable components. This makes it easier for developers and problem solvers to understand the problem space and identify the relationships between different components. By focusing on one sub-problem at a time, individuals can gain a deeper understanding of each component, leading to a comprehensive understanding of the overall problem.

Enhanced Problem-Solving Efficiency

Decomposition enables a systematic approach to problem-solving. By dividing a complex problem into smaller, more manageable sub-problems, individuals can tackle each component independently. This allows for focused problem-solving, where the attention is directed towards solving one specific sub-problem at a time. As a result, problem solvers can optimize their strategies and algorithms for each sub-problem, leading to more efficient and accurate solutions.

Promotion of Code Reusability

Decomposition encourages the creation of modular code, where individual components can be reused in different contexts or scenarios. By designing reusable modules or functions, developers can save time and effort by leveraging existing solutions. This not only improves productivity but also enhances code quality, as the reused components have already been thoroughly tested and optimized.

Improved Code Readability and Maintenance

Modular code resulting from decomposition is easier to read, understand, and maintain. Each module or function focuses on a specific task, making the code more readable and self-explanatory. Changes or updates can be applied to specific modules without affecting the entire system, reducing the risk of introducing bugs or errors. The modular structure also promotes collaboration, as different team members can work on separate modules concurrently.

Challenges and Limitations of Computer Science Decomposition

While computer science decomposition is a powerful technique, it also comes with its challenges and limitations. Let’s explore some common obstacles and strategies to overcome them:

Identifying Appropriate Decomposition Points

One challenge in decomposition is determining the optimal points at which to break down a problem. If the decomposition is too fine-grained, it may result in an excessive number of sub-problems, leading to unnecessary complexity. On the other hand, if the decomposition is too coarse, the sub-problems may not be manageable or solvable independently. Striking the right balance requires experience, domain knowledge, and a thorough understanding of the problem at hand.

Managing Dependencies and Interactions

When decomposing a problem, it is essential to consider the dependencies and interactions between different components. Sub-problems may rely on each other or share common resources, making it challenging to solve them independently. Properly managing these dependencies is crucial to ensure that the solutions for each sub-problem can be combined successfully to form the overall solution. Careful planning, design, and communication are necessary to address these challenges effectively.

Overcoming Integration Complexities

Once the individual sub-problems are solved, integrating them to form the complete solution can introduce additional complexities. Integration may require careful coordination, data sharing, or synchronization between the different components. Testing and verifying the integration can be time-consuming and challenging, as errors or inconsistencies may arise due to the combination of individual solutions. Thorough testing, documentation, and communication among team members are crucial to overcome these integration complexities.

Future Trends and Advancements in Computer Science Decomposition

As technology continues to evolve, new trends and advancements are emerging in computer science decomposition. Let’s explore some of the exciting developments that are shaping the field:

Machine Learning-Driven Decomposition

Machine learning algorithms are increasingly being used to automate or assist in the decomposition process. These algorithms analyze large datasets, identify patterns, and suggest potential decomposition points or strategies. By leveraging machine learning techniques, developers and problem solvers can gain insights and recommendations to guide their decomposition efforts, improving efficiency and accuracy.

Integrating Domain-Specific Knowledge

Domain-specific knowledge plays a crucial role in effective decomposition. As the field of computer science expands to various industries and domains, integrating specific knowledge into the decomposition process becomes essential. This includes understanding the unique characteristics, constraints, and requirements of a particular domain and incorporating them into the problem-solving approach. By leveraging domain-specific knowledge, decomposition can be tailored to address the specific challenges and opportunities of different fields.

Exploring New Problem-Solving Paradigms

Advancements in computer science are leading to the exploration of new problem-solving paradigms, such as quantum computing, bio-inspired algorithms, or swarm intelligence. These paradigms offer alternative approaches to decomposition and problem-solving, opening up new possibilities for tackling complex problems. By embracing these emerging paradigms, developers and problem solvers can expand their toolkit and explore innovative solutions.

In conclusion, computer science decomposition is an invaluable tool for software developers, problem solvers, and algorithm designers. By breaking down complex problems into manageable components, decomposition enhances efficiency, readability, reusability, and maintainability of code. Understanding the various techniques, benefits, challenges, and future trends associated with computer science decomposition equips individuals with the knowledge and skills to apply this powerful concept effectively in their own projects.

Billy L. Wood

Related post, rent computer monitors: a comprehensive guide to finding the perfect solution.

March 28, 2024

Freshman Computer Science Internships: A Comprehensive Guide to Kickstart Your Career

The Beauty of Green Computer Background: Enhancing Your Digital Experience

Computer repair in lincoln, ne: a comprehensive guide, a+ computer repair: the ultimate guide to solving your computer issues, the ultimate guide to finding the perfect purple computer chair.

March 27, 2024

Internet Essentials Com Computer: A Comprehensive Guide to Connectivity and Accessibility

Leave a comment cancel reply.

You must be logged in to post a comment.

Lyme Computer Systems: Revolutionizing the World of Technology

Computer Repair Services in Madison: Expert Solutions for Your Device Woes

Exploring the Nostalgic Charm of Old Computer GIFs

Computer Building Jobs: A Comprehensive Guide to Launch Your Career in Tech

The Significance of the Lock + Computer Emoji: A Comprehensive Guide

Popular Post

The Complete Guide to Arise Computer Requirements: Everything You Need to Know

Exploring the Evolution and Charm of 90s Computer Monitors: A Nostalgic Journey

The Evolution of 90s Computer Desks: A Nostalgic Journey

Prank Your Friends with the Hilarious Broken Computer Screen Prank

The Ultimate Guide to Outdoor Computer Monitors: Enhance Your Outdoor Computing Experience

Master the Art of Computer Keyboard Drawing: A Comprehensive Guide

[email protected]

Quick Links

Privacy policy

Q2 Decomposition

Direct link to this video

Introduction

Decomposition is the first stage of computational thinking. You may have heard the word in reference to something dying or rotting. When something decomposes it does break down into something different.

In the case of computational thinking, decomposition is breaking a complex problem into smaller chunks. The problem can be as small as learning to tie your shoes or as large as constructing a new car that drives itself!

In this Quest, you are going to learn how to break a complex problem into smaller chunks.

I Can Statement

• take a complex problem and break it into smaller chunks

Key Vocabulary

Compare : To put things together to see how they are the same.

Complex problem : Questions or issues that cannot be answered through simple logical procedures. 

Contrast: The difference between things.

Decomposition : To break down a complex problem or system into smaller, more manageable parts.

Play the  Vocabulary Game  below to practice the  Key Vocabulary . 

Vocabulary Game

You can change the Quiz mode to Match, Test, Learn, Flash Cards, Spell using the selection list at the bottom right of the activity that says " Choose a Study Mode."  Direct Link

1. Watch as a class the video Computational Thinking: Decomposition . You will watch the first 6:25 of the video. 

2. As you can see in the video, there are complex problems that you are solving every day. 

3. With a partner you are going to do decompose and break down the tasks it will take to make homemade slime. (e.g., what is needed, what has to be purchased, costs, who is going to make it, etc.) You are not creating steps at this point on how to make it . You are looking at the big picture and what is needed to break it down into tasks. 

• Your teacher may assign a different complex problem.

4. Use this Slime Decomposition Assignment Document  to complete the assignment. You are going to break down the tasks into chunks so that someone reading it will know what is needed to solve the complex problem.     Here's an example about Building a Birdhouse

5. Once you have completed this assignment, as a class you will share out how you broke down the complex problem assigned to you and your partner. 

• If the teacher assigns the whole class the same problem, compare and contrast as a group the decomposition. 

6. Now using the Computational Thinking Document that you made a copy of in Quest One, break down your own complex problem into chunks. 

Completing This Quest

To complete this Quest turn in your decomposition activity to your teacher (via Google Drive, OneDrive, etc.). Then complete the steps for your complex problem and share with your teacher when it is completed. 

Check off this Quest on the 21t4s roadmap  

I have completed this Quest and I am ready to learn about Quest 3

21.Q2 Teacher Guide

Competencies & Standards

MITECS    Michigan Integrated Technology Competencies for Students, and

ISTE Standards for Students

5. Computational Thinker c. Students break problems into component parts, extract key information, and develop descriptive models to understand complex systems or facilitate problem-solving

6. Creative Communicator d. Publish or present content that customizes the message and medium for their intended audiences

Websites and Documents

Videos from Outside Sources

• Computational Thinking: Decomposition YouTube

21t4s Videos

• Decomposition Intro Video

21t4s Documents & Quizzes

• Computational Thinking Planning Document
• Slime Decomposition Assignment
• Vocabulary Quizlet

Print this page

Computational Thinking by Karl Beecher

Get full access to Computational Thinking and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

3 PROBLEM-SOLVING AND DECOMPOSITION

• Explain how to apply a systematic approach to problem-solving.

• Discuss how to create a problem definition.

• Introduce strategies and considerations for the devising of solutions.

• Explain decomposition as a problem-solving strategy.

• Show the benefits of generalising from patterns in problems as well as techniques for creating them.

WHERE TO START

You have your problem. You’re ready to start analysing it and coming up with a solution. But not just any solution; one that is specifically formed so that a computer could carry it out. You begin to look at the problem. A question dawns on you.

Where on earth do you start?

It’s all very well saying ‘come up with a solution’. Real-world problems ...

Get Computational Thinking now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

Digital teaching and learning equipped with PD

The one about decomposition in computational thinking.

• Share on Twitter
• Share on LinkedIn
• Share on Facebook
• Send to Pinterest
• Share via Facebook

The power of computational thinking starts with decomposition, which is the process of breaking down complex problems into smaller, more manageable parts. With decomposition, problems that seem overwhelming at first become much more manageable.

“If you can’t solve a problem, then there is an easier problem you can solve: find it.” George Pólya

Problems we encounter both in the course of student learning and throughout our daily lives are ultimately comprised of smaller problems we can more easily address. This process of breaking down problems enables us to analyze the different aspects of them, ground our thinking, and guide ourselves to an end point.

Examples of Decomposition in Everyday Life

Decomposition is something we inherently do in our daily lives, even if we don’t realize it.

If you hosted a holiday dinner, you used decomposition to select the menu, enlist support from others in the kitchen, task people with what to bring, determine the process by which to cook the different elements, and set the time for the event.

If you went to the grocery store for said holiday dinner you used decomposition to build your grocery list, guide the direction you took as you meandered the aisles, the route you followed to and from the store, and the vehicle in which you drove.

If you’ve implemented a new program or initiative at your school, you used decomposition to build your strategic plan, which included the program’s vision, strategy for gaining buy-in, annual goals, and everything else involved.

Examples of Decomposition in Curriculum

Indeed, decomposition is a powerful tool that guides how we approach projects and tasks regularly. And it is also something employed in student learning. Here are some examples for accentuating these in curriculum.

English Language Arts: Students analyze themes in a text by first answering: Who is the protagonist and antagonist? Where is the setting? What is the conflict? What is the resolution?

Mathematics: Students find the area of different shapes by decomposing them into triangles.

Science : Students research the different organs in order to understand how the human body digests food.

Social Studies: Students explore a different culture by studying the traditions, history, and norms that comprise it.

Languages: Students learn about sentence structure in a foreign language by breaking it down into different parts like subject, verb, and object.

Arts: Students work to build the set for a play by reviewing the scenes to determine their setting and prop needs.

Examples of Decomposition in Computer Science

Then, from a computer science and coding perspective, decomposition can come into play when students are programming a new game. For example, students need to consider the characters, setting, and plot, as well as consider how different actions will take place, how it will be deployed, and so much more.

It’s hopefully clear that decomposition is deeply ingrained in how we function daily and address problems both big and small. The concept already exists with students, but students need to learn how to recognize this process as it happens and leverage it when they feel overwhelmed in the case of a problem, task, or project. Decomposition teaches students embrace ambiguity and equips them with the confidence to learn new things.

What's Next? Check out our articles on pattern recognition , abstraction , and algorithmic thinking .

Related Articles

The One About Abstraction in Computational Thinking

Abstraction occurs through filtering out the extraneous information to identify what’s most important. Learn how this concept can be integrated in student learning.

The One About Pattern Recognition in Computational Thinking

As it sounds, pattern recognition is all about recognizing patterns. Learn how this concept can be integrated in student learning.

The One About Algorithmic Thinking in Computational Thinking

Algorithmic thinking is the process for developing processes and formulas (an algorithm). Learn how this concept can be integrated in student learning.

Presented by

© Copyright 2023 equip by Learning.com

Cookie Settings

End of page. Back to Top

• Become a Member
• Artificial Intelligence
• Computational Thinking
• Digital Citizenship
• Edtech Selection
• Global Collaborations
• STEAM in Education
• Teacher Preparation
• ISTE Certification
• School Partners
• Career Development
• ISTELive 24
• 2024 ASCD Annual Conference
• Solutions Summit
• Leadership Exchange
• 2024 ASCD Leadership Summit
• Edtech Product Database
• Solutions Network
• Sponsorship & Advertising
• Sponsorship & Advertising
• Learning Library

Understanding Problems With Computational Thinking: Decomposition

• Computer Science & Computational Thinking

Even though computational thinking is a skill that can be incorporated into all school subject areas, it can be a head-scratcher for teachers of language arts, social studies or other content areas outside math and science.

To illustrate how to integrate CT into a nontraditional subject, I set out to create a hypothetical Spanish lesson that would incorporate computational thinking to get a better idea of what teachers face. 

In my lesson, students need to solve the following problem: How can we identify and classify poems? On the surface, this seems simple, but when you think about it, there are layers to it. Computational problems often involve many components similar to this one. To better understand all the layers, we use a CT component called decomposition .

In the context of CT, decomposition is unpacking problems to better understand how to solve them . In other words, you’re decomposing a problem into smaller portions so that you can better understand the problem.

Unpacking this poetry question doesn’t result in a solution, but rather leads to other questions that will help solve it: What kinds of poems? What is to be identified? How can we find those identifiable things? Can these be used to classify poems? 

All these types of questions help us peel back those layers. Asking and answering these questions is decomposition.

In this article, I’m going to share my experience creating this Spanish-CT lesson with decomposition in mind. I’ll also provide some suggestions for thinking about decomposition in your own CT problems.

Step 1: Ask questions about your CT problem.

I wanted my students to identify the characteristics of a poem and use those elements to create an algorithm. The first question I considered was what data would be analyzed. More specifically, what aspect of the poems would students need to identify. 

I, the teacher, knew what to look for: rhymes, syllables, lines, etc, but would the students know? How could I ensure they felt prepared to look for these elements in the poems? How could I guide them without spoiling the answers? 

My answer to this was brainstorming. I assumed that my hypothetical high school students would have encountered poetry in a previous course, so I decided to tap into that prior knowledge. 

To get the ball rolling, I would ask students what makes a poem a poem. After encouraging them to come up with as many ideas as they could on their own, they’d share with a partner, and eventually, we’d discuss as a class. Their collective answers would become an anchor chart. My path to creating this system of brainstorming and partner discussion was the result of asking myself questions about the computational problem.

Step 2: Zoom out 

Sometimes we think we’re decomposing a problem when we’re actually jumping ahead to solving it instead. This isn’t what decomposition is for.

Knowing the steps to a process is not the same as decomposition. Think about it in terms of brushing your teeth. Decomposing the question — How do I brush my teeth? — looks something like this: Get a toothbrush, apply toothpaste, brush the front and back sides of teeth, spit the excess toothpaste out, rinse, done. These are the parts of brushing your teeth.

While the steps to teeth-brushing have indeed been explained, do I better understand the problem or did I simply solve it? What are the next steps I need to take? None? Well, then the problem hasn’t been decomposed, but solved. 

Decomposing a computational problem leads to a better understanding of where to go next. Arriving at a solution right away usually is a sign that your computational problem needs to be re-examined. You need to zoom out a bit.

In this example, how to brush your teeth is too narrow. But focusing on the question, How should I clean my teeth? leads to more interesting questions. What counts as cleaning teeth? Is it something only I can do? Can I get help from others? What are some tools I can use? These are the types of questions that lead to a better understanding. Notice that none of them answer the initial question but expand our inquiry options.

If decomposing your computational problem results in a solution, it’s time to zoom out! Don’t beat yourself up if this happens. That’s natural in the CT process . Sometimes we get a good idea, but just need to adjust it a bit! Oftentimes, the answer is to think of a broader question.

Step 3: Think about transitions

In my lesson, brainstorming the characteristics of poems provides hints of what to look for when analyzing the poems. 

As I thought more on this, I realized that brainstorming might not be enough. Learning through experience is the whole reason I decided to create this lesson and that’s what students need.

To accomplish this, I would play a recording of a specific style of poem that I want students to analyze. Students would listen to it and fill in the missing words they hear. The words I removed would determine the rhyme scheme of the poem. That way, I'm not-so-subtly guiding them to analyze rhyming.

When done, we’d go over the answers, and I’d initiate a discussion to get them to have a lightbulb moment by making the connection between ideas from the anchor chart and the rhyming words.

This activity would reinforce the ideas we brainstormed and provide some practice in analyzing. It also allows them to view the poem through the lens of their brainstormed ideas — their decompositions. 

Decomposition is the creation of the blueprint for the CT process. Decomposition is also what determines if your computational problem is one worth pursuing. If not, it’s probably time to zoom out!  

​​ Nick Pinder is a project manager of computational thinking and higher education projects at ISTE. Nick is interested in the promotion of computational thinking and its intersection with language instruction specifically and the humanities in general.

• artificial intelligence

Why is Decomposition Required in Computational Thinking

by Lcom Team | Sep 6, 2022 | Blogs

Share this article!

Computational thinking has become important to teaching problem solving in education because it empowers students with processes to develop strategic solutions to complex problems, essentially “leveling up” their skills, or creating algorithms that can make future processes more effective. This enables students to take on more complex challenges and prepare for real-world applications.

Decomposition in Computational Thinking

While the process of computational thinking is multifaceted, there is one key to computational thinking that is essential for success: decomposition. Decomposition is the process of breaking a complex task or problem into smaller, more manageable pieces. From this decomposition, students can eliminate unnecessary information, identify patterns and begin the process of identifying which parts of the problem are most important, how to solve or complete each step, and how those parts can be put together for a clear and unified step-by-step solution.

Why is the Decomposition Technique Required in Computational Thinking?

The technique of decomposition is required in computational thinking because it breaks complex tasks into subtasks while developing a sequentially-based understanding of the problem. This allows unnecessary information to be discarded, patterns to be identified, relevant information to be extracted and the process of step-by-step resolution to be defined for a more effective problem-solving process.

By definition, computational thinking is the process of tackling complex problems and finding a clear, step-by-step solution that can be replicated. Decomposition, therefore, is essential to this process as it includes breaking a task into several sub-tasks, helping to align the task to a step-by-step solution.

Another reason decomposition in computational thinking is important is because it allows each subtask to be examined more closely. This not only helps to categorize information as essential or non-essential, but also empowers the problem-solver with a better ability to analyze each specific part of the task or challenge to more effectively develop a reasonable solution.

Examples of Decomposition in Computational Thinking

Below are some real-world examples of utilizing decomposition in computational thinking:

• You have to clean your house. Instead of facing the task as a whole, you practice decomposition by breaking the task into a to-do list with multiple subtasks.
• To build shelves for a storage space, you practice decomposition by measuring the space, creating a blueprint or plan to determine the size of the shelves and the materials you need to accomplish the task. Next, you purchase the supplies and cut the lumber to size, then install one wall of shelves at a time.
• In science, to prove or disprove a hypothesis, you practice decomposition by creating subtasks including background research, observation, generating a hypothesis, determining which variables to test, performing experiments and drawing a conclusion.

Final Thoughts

• Digital Citizenship in Students: Examples and Practice Exercises

by Lcom Team | Apr 23, 2024

Digital citizenship is a crucial concept in today's digital age, particularly for students who are growing up in a world where technology and the internet play integral roles in their daily lives and education. This article explores the concept of digital citizenship,...

• Understanding Proclamation 2024 and the TA-TEKS

by mdespain | Apr 16, 2024

Understanding Proclamation 2024 and the TA-TEKS  In 2024, Texas introduced Proclamation 2024 to begin the process of adopting new instructional materials that would align with the  Technology Applications Texas Essential Knowledge and Skills (TA-TEKS) standards that...

• Guide to Teaching Algorithms in Computer Programming for K-12 Students

by Lcom Team | Apr 9, 2024

Algorithms are the heart of computer programming, providing the step-by-step instructions that computers follow to perform tasks and solve problems. Understanding algorithms and their implementation in programming is crucial not just for software developers but also...

• Planning Digital Literacy Assessment: A Simplified Approach

by Lcom Team | Apr 4, 2024

As educators know, assessments are critical to the learning process. They provide beneficial self-checks to students, informative results to teachers and comprehensive data to administrators. So, when teachers implement digital literacy curriculum, assessments are an...

• Technology Skills to Teach Gen Z for Future Success

by Nicasia Anzalone Caires | Apr 2, 2024

Gen Z and Gen Alpha will enter a workforce that looks very different than the one their parents and grandparents experienced. Educators know it’s important to consider what skills their students will need to succeed now and in the future, but with the rapid rate that...

Digital Skills for North Carolina Students

by Lcom Team | Mar 28, 2024

In our district, like most others, the use of digital learning tools has catapulted since the pandemic. With students online more than ever, it’s essential that they know how to stay safe on the internet, protect their privacy and understand their digital footprint....

Why Teaching Kids to Code Supports Community Development

by Lcom Team | Mar 26, 2024

Teaching kids to code undoubtedly prepares them for the future of work. But what does this mean for the communities that helped them become career ready? With booming tech sectors, jobs in computer science are concentrated in major cities in the United States, which...

Enhancing Digital Citizenship by Understanding Confirmation Bias

by Lcom Team | Mar 19, 2024

Teaching confirmation bias as part of the digital literacy curriculum in schools is essential in today's information-saturated world. Confirmation bias, the tendency to search for, interpret, favor and recall information in a way that confirms one's preexisting...

Understanding Computational Thinking for More Effective Learning

by Lcom Team | Mar 12, 2024

The idea of bringing computational thinking into all areas of education is becoming increasingly important. Even though computational thinking has its roots in computer science (specifically, computer programming), this way of solving problems can help students in...

Teaching Computer Programming Principles Without a Computer

by Lcom Team | Mar 6, 2024

Teaching coding concepts off-computer, often referred to as "unplugged" coding activities, plays a crucial role in building a foundational understanding of programming for students. This approach helps demystify the often abstract concepts of coding, making them more...

Digital Literacy in 2024: 7 Important Computer Skills for Future-Ready Students

by Lcom Team | Feb 29, 2024

In 2024, the technological landscape continues to evolve faster than ever. Innovations in artificial intelligence, cloud computing and cybersecurity are reshaping the way we live, work and interact. These changes continue to mark a future where digital literacy is not...

Bridging Success: Crafting Your Professional Development Plan

by Jess Hall | Feb 27, 2024

It may seem premature to think about Back-to-School 2024 when we’re only in February. But at Learning.com, we’re always planning ahead. We’ve been preparing for the new Technology Applications TEKS (TA-TEKS) for the last couple of years, and we’re looking forward to...

Learning.com Team

Staff Writers

Founded in 1999, Learning.com provides educators with solutions to prepare their students with critical digital skills. Our web-based curriculum for grades K-12 engages students as they learn keyboarding, online safety, applied productivity tools, computational thinking, coding and more.

Further Reading

Understanding Proclamation 2024 and the TA-TEKS  In 2024, Texas introduced Proclamation 2024 to begin the process of adopting new instructional...

Algorithms are the heart of computer programming, providing the step-by-step instructions that computers follow to perform tasks and solve problems....

As educators know, assessments are critical to the learning process. They provide beneficial self-checks to students, informative results to...

Quick Links

• Request More Info
• Cookie Settings

Recent news & Articles

Read the new OECD publication on supporting teachers to use digital tools for developing and assessing 21st century competences.

• Applications
• Karel the Turtle
• Betty's Brain
• Game Creator by Cand.li
• Competences
• PILA for Research

Competency framework

Conceptual framework of the PILA Computational Problem Solving module

What is computational problem solving.

‘Computational problem solving’  is the iterative process of developing  computational solutions to problems. Computational solutions are expressed as logical sequences of steps (i.e. algorithms), where each step is precisely defined so that it can be expressed in a form that can be executed by a computer. Much of the process of computational problem solving is thus oriented towards finding ways to use the power of computers to design new solutions or execute existing solutions more efficiently.

Using computation to solve problems requires the ability to think in a certain way, which is often referred to as ‘computational thinking’. The term originally referred to the capacity to formulate problems as a defined set of inputs (or rules) producing a defined set of outputs. Today, computational thinking has been expanded to include thinking with many levels of abstractions (e.g. reducing complexity by removing unnecessary information), simplifying problems by decomposing them into parts and identifying repeated patterns, and examining how well a solution scales across problems.

Why is computational problem solving important and useful?

Computers and the technologies they enable play an increasingly central role in jobs and everyday life. Being able to use computers to solve problems is thus an important competence for students to develop in order to thrive in today’s digital world. Even people who do not plan a career in computing can benefit from developing computational problem solving skills because these skills enhance how people understand and solve a wide range of problems beyond computer science.

This skillset can be connected to multiple domains of education, and particularly to subjects like science, technology, engineering or mathematics (STEM) and the social sciences. Computing has revolutionised the practices of science, and the ability to use computational tools to carry out scientific inquiry is quickly becoming a required skillset in the modern scientific landscape. As a consequence, teachers who are tasked with preparing students for careers in these fields must understand how this competence develops and can be nurtured. At school, developing computational problem solving skills should be an interdisciplinary activity that involves creating media and other digital artefacts to design, execute, and communicate solutions, as well as to learn about the social and natural world through the exploration, development and use of computational models.

Is computational problem solving the same as knowing a programming language?

A programming language is an artificial language used to write instructions (i.e. code) that can be executed by a computer. However, writing computer code requires many skills beyond knowing the syntax of a specific programming language. Effective programmers must be able to apply the general practices and concepts involved in computational thinking and problem solving. For example, programmers have to understand the problem at hand, explore how it can be simplified, and identify how it relates to other problems they have already solved. Thus, computational problem solving is a skillset that can be employed in different human endeavours, including programming. When employed in the context of programming, computational problem solving ensures that programmers can use their knowledge of a programming language to solve problems effectively and efficiently. 

Students can develop computational problem solving skills without the use of a technical programming language (e.g. JavaScript, Python). In the PILA module, the focus is not on whether students can read or use a certain programming language, but rather on how well students can use computational problem solving skills and practices to solve problems (i.e. to “think” like a computer scientist).

How is computational problem solving assessed in PILA?

Computational problem solving is assessed in PILA by asking students to work through dynamic problems in open-ended digital environments where they have to interpret, design, or debug computer programs (i.e. sequences of code in a visual format). PILA provides ‘learning assessments’, which are assessment experiences that include resources and structured support (i.e. scaffolds) for learning. During these experiences, students iteratively develop programs using various forms of support, such as tutorials, automated feedback, hints and worked examples. The assessments are cumulative, asking students to use what they practiced in earlier tasks when completing successive, more complex tasks.

To ensure that the PILA module focuses on foundational computational problem solving skills and that the material is accessible to all secondary school students no matter their knowledge of programming languages, the module includes an assessment application, ‘Karel World’, that employs an accessible block-based visual programming language. Block-based environments prevent syntax errors while still retaining the concepts and practices that are foundational to programming. These environments work well to introduce novices to programming and help develop their computational problem solving skills, and can be used to generate a wide spectrum of problems from very easy to very hard.

What is assessed in the PILA module on computational problem solving?

Computational problem solving skills.

The module assesses the following set of complementary problem solving skills, which are distinct yet are often used together in order to create effective and efficient solutions to complex problems:

• Decompose problems

Decomposition is the act of breaking down a problem goal into a set of smaller, more manageable sub-goals that can be addressed individually. The sub-goals can be further broken down into more fine-grained sub-goals to reach the granularity necessary for solving the entire problem.

• Recognise and address patterns

Pattern recognition refers to the ability to identify elements that repeat within a problem and can thus be solved through the same operations. Adressing repeating patterns means instructing a computer to iterate given operations until the desired result is achieved. This requires identifying the repeating instructions and defining the conditions governing the duration of the repetition.

• Generalise solutions

Generalisation is the thinking process that results in identifying similarities or common differences across problems to define problem categories. Generalising solution results in producing programs that work across similar problems through the use of ‘abstractions’, such as blocks of organised, reusable sequence(s) of instructions.

• Systematically test and debug

Solving a complex computational problem is an adaptive process that follows iterative cycles of ideation, testing, debugging, and further development. Computational problem solving involves systematically evaluating the state of one’s own work, identifying when and how a given operation requires fixing, and implementing the needed corrections.

Programming concepts

In order to apply these skills to the programming tasks presented in the module, students have to master the below set of programming concepts. These concepts can be isolated but are more often used in concert to solve computational problems:

• Sequences

Sequences are lists of step-by-step instructions that are carried out consecutively and specify the behavior or action that should be produced. In Karel World, for example, students learn to build a sequence of block commands to instruct a turtle to move around the world, avoiding barriers (e.g. walls) and performing certain actions (e.g. pick up or place stones).

• Conditionals

Conditional statements allow a specific set of commands to be carried out only if certain criteria are met. For example, in Karel World, the turtle can be instructed to pick up stones ‘if stones are present’.

To create more concise and efficient instructions, loops can communicate an action or set of actions that are repeated under a certain condition. The repeat command indicates that a given action (i.e. place stone) should be repeated through a real value (i.e. 9 times). A loop could also include a set of commands that repeat as long as a Boolean condition is true, such as ‘while stones are present’.

• Functions

Creating a function helps organise a program by abstracting longer, more complex pieces of code into one single step. By removing repetitive areas of code and assigning higher-level steps, functions make it easier to understand and reason about the various steps of the program, as well as facilitate its use by others. A simple example in Karel World is the function that instructs the turtle to ‘turn around’, which consists of turning left twice.

How is student performance evaluated in the PILA module?

Student performance in the module is evaluated through rubrics. The rubrics are structured in levels, that succinctly describe how students progress in their mastery of the computational problem solving skills and associated concepts. The levels in the rubric (see Table 1) are defined by the complexity of the problems that are presented to the students (simple, relatively complex or complex) and by the behaviours students are expected to exhibit while solving the problem (e.g., using functions, conducting tests). Each problem in the module is mapped to one or more skills (the rows in the rubric) and classified according to its complexity (the columns in the rubric). Solving a problem in the module and performing a set of expected programming operations thus provide evidence that supports the claims about the student presented in the rubric. The more problems at a given cell of the rubric the student solves, the more conclusive is the evidence that the student has reached the level corresponding to that cell. 

Please note: the rubric is updated as feedback is received from teachers on the clarity and usefulness of the descriptions.

Table 1 . Rubric for computational problem solving skills

Learning management skills

The performance of students on the PILA module depends not just on their mastery of computational problem solving skills and concepts, but also on their capacity to effectively manage their work in the digital learning environment. The complex tasks included in the module invite students to monitor, adapt and reflect on their understanding and progress. The assessment will capture data on students’ ability to regulate these aspects of their own work and will communicate to teachers the extent to which their students can:

• Use resources

PILA tasks provide resources such as worked examples that students can refer to as they build their own solution. Students use resources effectively when they recognise that they have a knowledge gap or need help after repeated failures and proceed to accessing a learning resource.

• Adapt to feedback

As students work through a PILA assessment, they receive different types of automated feedback (e.g.: ‘not there yet’, ‘error: front is blocked’, ‘try using fewer blocks’). Students who can successfully adapt are able to perform actions that are consistent with the feedback, for example inserting a repetition block in their program after the feedback ‘try using fewer blocks’.

• Evaluate own performance

In the assessment experiences designed by experts in PILA, the final task is a complex, open challenge. Upon completion of this task, students are asked to evaluate their own performance and this self-assessment is compared with their actual performance on the task.

• Stay engaged

The assessment will also collect information on the extent to which students are engaged throughout the assessment experience. Evidence on engagement is collected through questions that are included in a survey at the end of the assessment, and through information on students’ use of time and number of attempts.  

Learn about computational problem solving-related learning trajectories:

• Rich, K. M., Strickland, C., Binkowski, T. A., Moran, C., & Franklin, D. (2017). K-8 Learning Trajectories Derived from Research Literature: Sequence, Repetition, Conditionals. Proceedings of the 2017 ACM Conference on International Computing Education Research, 182–190.
• Rich, K. M., Strickland, C., Binkowski, T. A., & Franklin, D. (2019). A K-8 Debugging Learning Trajectory Derived from Research Literature. Proceedings of the 50th ACM Technical Symposium on Computer Science Education, 745–751. https://doi.org/10.1145/3287324.3287396
• Rich, K. M., Binkowski, T. A., Strickland, C., & Franklin, D. (2018). Decomposition: A K-8 Computational Thinking Learning Trajectory. Proceedings of the 2018 ACM Conference on International Computing Education Research  - ICER ’18, 124–132. https://doi.org/10.1145/3230977.3230979

Learn about the connection between computational thinking and STEM education:

• Weintrop, D., Beheshti, E., Horn, M., Orton, K., Jona, K., Trouille, L., & Wilensky, U. (2015). Defining Computational Thinking for Mathematics and Science Classrooms. Journal of Science Education and Technology, 25(1), 127–147. doi:10.1007/s10956-015-9581-5

Learn how students apply computational problem solving to Scratch:

• Brennan, K., & Resnick, M. (2012). Using artifact-based interviews to study the development of computational thinking in interactive media design. Paper presented at annual American Educational Research Association meeting, Vancouver, BC, Canada.

Associated Content

Take a step further

© Organisation for Economic Co-operation and Development

• Skip to Nav
• Skip to Main
• Skip to Footer

Four computational thinking strategies for building problem-solving skills across the curriculum

Please try again

Two decades into the 21st century, educators are still tackling the question of how to help young people prepare for a rapidly evolving work landscape . Industry leaders have long called for more emphasis on skills such as critical thinking , communication and problem-solving , though the definitions and methods for teaching all of these can vary widely. At the International Society for Technology in Education conference in July, a number of education leaders and teachers discussed a framework that can help build students’ problem-solving skills in any subject: computational thinking.

Much of the research and discussion on computational thinking in the last twenty years has focused on computer science contexts . Harvard’s Karen Brennan , for example, has led studies and developed resources on computational thinking with Scratch . But several advocates argued that these skills are not just applicable to coding and should be integrated across the curriculum. They outlined four strategies that make up the computational thinking process:

Decomposition - breaking a complex problem into smaller parts or questions

Pattern recognition - identifying trends, differences or similarities in data

Abstraction - removing unnecessary elements or data to focus on what’s useful in solving a problem

Algorithmic design - making steps and rules to solve problems

Most problems will require students to employ multiple strategies. Julie Evans , CEO of the education nonprofit Project Tomorrow, illustrated that point by asking attendees at one session to draw a cat in less than 30 seconds. No drawing looked exactly the same, but the participating educators had to quickly break their mental image of a cat into important parts, such as a tail and whiskers (decomposition). They discarded unnecessary data; for instance, a cat can be conveyed by drawing its head and body or just its face (abstraction). And they envisioned and executed steps to get from a blank page to a completed drawing (algorithmic design).

Bryan Cox, who works in the Georgia Department of Education to broaden computer science education, offered practical and pedagogical reasons for integration. Not all schools offer computer science and even at schools that do, not all students take those classes . For elementary school teachers, stand-alone computer science lessons can feel like one more thing to add to an already packed curriculum. “Integration is less disruptive,” Cox said. He also said integration mirrors how computational thinking occurs in the real world in fields like medicine, automotives, law and sports.

Over the past two years, Project Tomorrow trained 120 teachers in New York City elementary schools to integrate computational thinking into their classrooms. In one example from a second and third grade writing unit, students wrote a realistic fiction story and created a movie to bring the story to life. That may sound like a pretty typical language arts project, but the difference was in the approach, according to Project Tomorrow instructional coach David Gomez. Rather than being told how to write a realistic fiction story, students developed an algorithm for the process, with steps such as making up a pretend character, giving the character a name, imagining the setting and so on. In this example and others, Gomez said that algorithms help students acknowledge the steps they are following during a task and increase their awareness of their work processes.

Gomez works with teachers to help students recognize when they’re using other computational thinking strategies, too. One second grade teacher, for example, used a poster with sticky notes for students to reflect on which strategies they’d used in different subjects throughout the day.

Evans said she loves hearing kids identify the strategies in discussions with each other. She’s heard questions like “Did you try abstraction?” and “Why didn’t you do pattern recognition ?” from students chatting with classmates. “Those little tykes in second grade are already developing their problem-solving muscles, and they’ve got the vocabulary to have that be a sustainable skill for the future,” she said.

Crafting computational problems

Not every question or problem is a computational one. Carolyn Sykora, senior director of the ISTE Standards programs, shared three characteristics that teachers can use to identify a computational problem:

• It’s open-ended with multiple potential solutions. “How can we design a car to get from point A to point B?” is an example that meets this criteria, whereas “How does a self-driving car work?” is a knowledge-based question.
• It requires using or collecting data. Data doesn’t just mean numbers. It could, for example, be the lines in a poem or the notes in a musical composition.
• It includes an opportunity to create a procedure or algorithm. In some cases, such as an engineering challenge, it’s easy to identify where this opportunity will arise. But often that’s not so clear. “Sometimes you don’t understand where the algorithm design comes into play until you do your problem decomposition,” Sykora said.

Using these characteristics can help teachers rethink curriculum, rather than trying to add something new. “We have our tried and true lessons and the things that we want our kids to learn,” Sykora said. The next step is to look at those lessons and ask, “How can we take something that’s knowledge-based and turn it into a computational problem?”