About the Computer Science Standards

The Kodable K-5 standards are a roadmap for developing the whole student through computer science. Our goal is to reach ALL students and see computer science become part of a complete elementary education.

Standards Team

Brianna Gray

Brianna Gray - Kodable Head of Curriculum

Brianna taught Kindergarten for two years before joining Teach for America and continuing her teaching career. Brianna progressed from teaching to her current position at Kodable where she writes the Kodable curriculum and supports teachers, schools, and districts in teaching Computer Science. Brianna is passionate about education and opportunity for all children and her goal is that all students will have equal opportunity, tools, and support to learn Computer Science.

Rachel Brainerd

Rachel Brainerd - Teach for America Senior Managing Director of Institute

Rachel leads a staff to train and support ~250 novice teachers during their first weeks in the classroom. Partnering with several school districts to design and execute a rigorous summer school program for students, Rachel is focused on the intersections between teacher support and student learning. In her spare time, Rachel can be found hiking or playing her violin with an orchestra in Oakland, CA.

Jay Borenstein

Jay Borenstein - Stanford University Computer Science Professor

Jay teaches Computer Science at Stanford University with a focus on Virtual Reality, Software Engineering and Entrepreneurship. Jay founded Integration Appliance in 2000 and served as the CEO through 2007. Jay also runs the “Education Modernization” (EdMod) group at Facebook. EdMod initiatives include Facebook inspirED, TechStart, VR Camp and Facebook Open Academy. Jay is also a Director at 6Seconds - The Emotional Intelligence Network. Jay studied both as an undergraduate and graduate student at Stanford University.

Brian Adams

Brian Adams - Informational Technology Teacher

Brian teaches at a K-3 elementary school in Colonial School District (PA). In his 22-year career, he has taught second grade as well as Technology to K-3 students. In Technology, Brian’s students are developing a foundation of basic programming skills and concepts, working with robotics, and creating and designing using the engineering design process.

Grant Smith

Grant Smith - CSTA K-8 Task Force and Standards Review Committee

Grant trains K-8 teachers in computer science content and pedagogy. He also serves on the CSTA K-8 Task Force and Standards Review Committee. He is a former coding teacher and district administrator. Grant is also concurrently working on earning a doctorate from the Johns Hopkins University School of Education.

Computer Science Strands

Critical Thinking Programming and Communication Programming Impact Social Emotional Learning Everyday Connections Programming and Me

How to Read the Standards

Single Grade

Multiple Grades

Kindergarten Computer Science Standards

Identify code as language people use to control machines.

1st Grade Computer Science Standards

Identify algorithms to complete a task and apply logic statements.

2nd Grade Computer Science Standards

Write, describe, apply and debug multiple coding concepts.

3rd Grade Computer Science Standards

Write, describe, and apply algorithms using multiple coding concepts.

4th Grade Computer Science Standards

Read and modify scripts to change what happens on the screen.

5th Grade Computer Science Standards

Read, modify, and write scripts that change what happens on the screen.

Computational Thinking and Programming Concepts
CT.K.1 Use numbers and symbols to represent data (e.g., thumbs up/down for yes/no, color by number, arrows for direction).
CT.K.2 Identify and describe elements in a pattern.
CT.K.3 Decompose a model or task into smaller elements.
CT.K.4 Identify and describe an error (bug) when it is occurring (e.g., “The arrow should be pointing to the right here, not up.).
CT.K.5 Select and test the appropriate solution to fix a bug when given multiple options.
CT.1.1A Use numbers or other symbols to make a model representing a set of data.
CT.1.1B Define code as a language for computers and recognize there is more than one computer language.
CT.1.2A Decompose a problem into the variety of possible smaller problems, identifying patterns.
CT.1.2B Describe characteristics of the problems in order to understand outcomes and restraints.
CT.1.3 Create and arrange sequences of steps to reach a desired outcome. Use appropriate vocabulary (e.g., algorithm) to describe these steps.
CT.1.4 Identify and describe an error when it is occurring (e.g., “The arrow should point up on the green tile, not down.”) within a larger script, involving additional programming elements such as conditions and loops.
CT.1.5 Select and test the appropriate solution to solve a bug when given multiple options, with more complicated code structures.
CT.2.1 Identify characteristics of code (length, characters, integers, different types).
CT.2.2 Determine the best sequence based on a series of outcome restraints. Justify the choice.
CT.2.3 Arrange a sequence of code in multiple ways to reach a single outcome. Choose the most efficient and provide rationale.
CT.2.4 Predict the outcome of specific scripts, considering errors that may occur.
CT.2.5A Automate solutions by using elements in code that increase efficiency, save time, and decrease the likelihood of bugs.
CT.2.5B Test and refine automated solutions to determine maximum efficiency.
CT.3.1 Demonstrate an understanding that code follows specific organization patterns. Accurately describe the way a complete set of data is organized (e.g., lists, grouping, types of data).
CT.3.2A Identify and apply different programming elements to solve a problem (variables, conditions, loops, functions).
CT.3.2B Decompose a real world problem into sub problems/smaller steps.
CT.3.2C Decipher between problems that can and cannot be solved computationally.
CT.3.3 Modify values within a script to change an isolated part of the outcome.
CT.3.4 Identify and explain the source of a bug using the vocabulary of variables and sequences.
CT.3.5 Identify opportunities within a program that can be manipulated to make something happen (e.g., When I click, this happens)
CT.3.6A Classify different types of data used by a computer or program.
CT.3.6B Sort groups of data into relevant and irrelevant based on specific criteria.
CT.3.7A Identify, use, and modify information within a program.
CT.3.7B Identify, apply, and explain rationale for the type of data, when it used, and where it is used within a program.
CT.3.7C Identify and use tools to store and access data.
CT.4.1 Identify syntax rules, grouping, naming, and other levels of organization. Justify personal rationale.
CT.4.2 Identify a problem that can be solved computationally and formulate one possible multi-step solution.
CT.4.3 Identify and describe the variables and values of given set of data.
CT.4.4 Apply skills to accurately fix bugs that exist within a script.
CT.4.5 Automate data organization and replicate results.
CT.4.6 Translate information into code using different types of variables and justify rationale for this choice.
CT.5.1A Organize code following syntax rules, grouping, naming, and other levels of organization.
CT.5.1B Organize code with increasing detail and justify personal rationale.
CT.5.1C Follow rules that specify how code should be organized with consistency.
CT.5.2 Identify a problem that can be solved computationally and formulate multi-step solutions, selecting the best possible and explaining why.
CT.5.3 Modify and revise variable values within a set of data to reach a desired outcome.
CT.5.4 Identify and use tools that find and fix bugs within a script.
CT.5.5A Modify data to change a specific outcome.
CT.5.5B Compare and contrast the characteristics of similar objects.
CT.5.5C Describe the relationship between efficiency and programming language paradigms.
CT.5.6 Use variables to sort and store information.
CT.A.15 Justify decisions by demonstrating an understanding of “if, then” statements. Students should be completing this at all grade levels, increasing complexity each year.
CT.B.K2 Model processes and systems that satisfy “if, then” statements. Students should be completing this at all grade levels, increasing complexity each year.
CT.C.45 Automate solutions by manipulating repeatable events within a program.
CT.C.35 Define, identify, and apply variables within a program, including.
  • Using integers to run a loop
  • Using variables to create shortcuts
  • Using variables to carry out complex processes
  • Reusing variables throughout a program.
CT.D.35 Take actionable steps to satisfy “if, then” statements within a program, taking into account observations, events, and the relationships between objects and systems.
Programming and Me
PM.K.1 Cultivate habits in using technology in safe and correct ways.
PM.K.2 Demonstrate an understanding of their role in making machines function.
PM.K.3A Articulate the task they are asking the computer to do.
PM.K.3B Describe the instructions they have been giving by articulating the steps.
PM.1.1 Demonstrate an understanding of using secure measures on networks and the internet (e.g., passwords, personal devices).
PM.1.2 Articulate the relationship between the programmer and the computer, the user and the computer, the role of instructions in these relationships.
PM.1.3 Follow and give a set of instructions in order to complete a task.
PM.2.1A Compare and contrast measures of security to determine level of safety (e.g., password strength).
PM.2.1B Create secure measures for a personal computer or network that meet a level of high security.
PM.2.2 Explain what will happen when a computer is given instruction. Demonstrate an understanding that computers follow directions given by programmers.
PM.2.3 Compare and contrast sets of instructions (loop or no loop, function or no function) to determine the efficiency of obtaining the desired outcome (e.g., which will get me there faster? Which will save me time?)
PM.3.1 Identify alternative measures of security for data, such as offline backups and virus software.
PM.3.2A Describe differences between what a programmer sees and what the user sees within a program.
PM.3.2B Describe the process of input and output using examples.
PM.3.3 Accurately plan and design a set of instructions that will reach a desired outcome.
PM.4.1 Define ownership and demonstrate an ability uphold copyright, fair use, and proper citations.
PM.4.2A Explain the connection between variables and output of a program.
PM.4.2B Modify the output of a program by adjusting the input.
PM.4.3 Assign components of a project to multiple people, collectively implementing a set of instructions to reach a desired outcome.
PM.5.1 Explain the role confidentiality has in online security.
PM.5.2 Effect the output of a program by changing values.
PM.A.K5 Demonstrate an understanding of using hardware and software in appropriate ways (eg., choosing the right tools, using the right vocabulary when describing hardware and software, etc.)
Programming Impact
PI.K.1 Identify problems that technology has solved in history and tools that were used to solve them.
PI.3.1A Create realistic technological solutions for real-world problems.
PI.3.1B Describe the usability of technological solutions for different groups of people.
PI.3.2 Describe the positive and negative impacts programming has on the relationship between multiple parties or objects.
PI.3.3 Describe the impact one person can have on another through programming and networks (e.g., cyber bullying).
PI.4.1 Compare and contrast technological solutions for real-world problems based on the needs and desires of specific users (e.g., would this work for a mom? For someone who can't walk?)
PI.4.2 Compare and contrast interactions and analyze the impact on others’ emotions.
PI.5.1 Incorporate expressed ideas and needs from users to revise and modify technological solutions for real-world problems.
PI.5.2 Apply constructive approaches to resolving conflicts through programs and networks.
PI.A.12 Identify and describe problems that technology has solved in current events.
PI.B.K5 Identify programming pioneers and understand their impact on the field.
PI.C.12 Describe the work that people do within the field of computer science and identify specific jobs related to programming today.
PI.D.12 Demonstrate an understanding of the role that programming can play in the environment, health, and people around the world.
PI.B.35 Describe the work of people 0-25 years of age and the role they play in computer programming.
PI.C.45 Demonstrate an understanding that working collaboratively is essential to developing technological solutions that meet the needs of all users.
Everyday Connections
EC.K.1 Demonstrate an understanding of why technology matters.
EC.K.2 Demonstrate an understanding of routines and articulate the steps within daily routines (such as washing hands, tying shoes, routines within the school day).
EC.K.3 Recognize programs as routines and connect daily routines to programming.
EC.1.1 Identify and describe places in the school day or daily tasks where technology may provide a possible aid.
EC.1.2 Demonstrate an understanding of the role instructions play within school day routines and within computer programming.
EC.1.3 Compose, decompose, and sequence:
  • a) Elements of the instructional day into routines and a set of instructions.
  • b) Elements in repeatable tasks (e.g., making a peanut butter and jelly sandwich, washing your hands).
EC.1.4 Describe methods for organizing information and materials.
EC.2.1 Create algorithms to represent and replace routines and procedures within the classroom (e.g., the sequence of the phrase “Criss-Cross Applesauce”). Explain the relationship between sequence and functions with routines and procedures.
EC.2.2 Compose, decompose, and sequence elements in tasks that have repeatable elements (e.g., making 10 peanut butter and jelly sandwiches).
EC.2.3 Compare and contrast methods for organizing information and materials in a classroom and on a computer.
EC.3.1 Describe the characteristics of storage for different materials on a computer (i.e., files may be different sizes.)
EC.4.1 Sort methods of organization based on the type of data one wants to store.
EC.5.1 Accurately store, retrieve, and read files of various types. Describe the process and personal preference using appropriate vocabulary.
Programming and Communication
PC.K.1 Express personal opinion related to problem-solving.
PC.K.2 Retell the steps followed to complete a task.
PC.1.1 Describe and justify choices within a task, sequence, or algorithm.
PC.1.2 Attribute ideas to the proper owner.
PC.2.1 Explain communication as it relates to programming: people to machine, machine to machine.
PC.2.2 Listen and think critically about someone else’s solution to the same problem.
PC.3.1 Communicate steps and desired outcome using multiple methods to document (oral, written, representational).
PC.3.2 Translate others' ideas into programming commands to reach a desired outcomes.
PC.4.1 Explain real life interactions that happen in order to reach an outcome or solve a problem.
PC.4.2 Expand and build on others' ideas to create more efficient programming commands. Correctly attribute elements of ideas to owners.
PC.5.1 Identify and create commands that can be given to a computer to cause future interactions (e.g., timers, setting up events, define classes, etc.)
PC.A.15 Engage in collaborative conversations about programming topics with increasing complexity.
PC.B.15 Express personal preferences related to technology and programming.
PC.C.12 Demonstrate an understanding that computers use a different type of language than humans.
PC.D.25 Engage in academic discourse related to programming concepts using proper vocabulary: algorithm, sequence, logic statements, problems, solutions, commands, etc.
Social Emotional Learning
SEL.K.1 Identify personal and peers’ likes and dislikes, needs and wants, strengths and skills.
SEL.K.2 Identify and explain differences in two approaches with successful solutions (e.g., “I solved it this way and (name) did it this way, but we both solved the problem.”).
SEL.K.3 Discuss and demonstrate positive characteristics of successful programmers including resilience, attention to detail, and passion for learning.
SEL.K.4 Cultivate a helping mentality: giving help and asking for help when appropriate.
SEL.K.5 Describe an experience with failure and what you learned from it (e.g., “When it didn’t work, I realized I forgot a command. Next time I will remember to double check my solution.”).
SEL.1.1 Describe similarities and differences in people, skills, approaches, and ideas that can have an impact on programming.
SEL.1.2 Describe a problem solved by a peer with a different approach. Articulate what you learned from this (e.g., there isn’t only one answer, my way isn’t the only way, people do things differently, I don’t have to be right, I can learn from others, etc.)
SEL.1.3 Name traits that you share with successful programmers (e.g., I work hard, I don’t give up, I help others, I am confident, I am focused, I want to learn, etc.). Give examples.
SEL.1.4 Cultivate a helping mentality: giving help and asking for help when appropriate. Articulate how helping and needing/getting help feels.
SEL.1.5 Describe a time you failed at something, name feelings associated with failure, and express what you learned from it.
SEL.2.1 Engage in conversation about the impact different people, skills, ideas, and learning styles contribute to programming.
SEL.2.2 Demonstrate flexibility around problem solving (e.g., there is more than one way, things can change, I can change my mind, etc.)
SEL.2.3 Identify personal traits that make you a successful problem-solver and programmer (e.g., I don’t give up, I’m curious, I’m creative, I’m focused, I set goals, etc.)
SEL.2.4 Demonstrate the importance of helping through teaching, working together, sharing, and asking questions.
SEL.2.5 Describe personal skills and interests that one wants to develop, including skills and interests that have grown (e.g., I can subtract now, I know my doubles, I can read more words, etc.).
SEL.3.1 Demonstrate an ability to collaborate through creation and revision (objects and solutions).
SEL.3.2 Generate alternative solutions and evaluate the impact for a range of programming and real world scenarios.
SEL.3.3 Set and monitor progress on achieving a short-term personal goal. *Also repeated when thinking about personal areas for growth
SEL.3.4 Identify and perform roles that contribute to the school community.
SEL.3.5 Set and monitor progress on achieving a short-term personal goal.
SEL.4.1 Demonstrate an ability to solve conflict and come to a solution.
SEL.4.2 Seek input from others in order to solve a problem or move the work forward.
SEL.4.3 Set and monitor progress on achieving a short-term personal goal with increasing complexity and evidence of planning. *Also repeated when thinking about personal areas for growth
SEL.4.4 Evaluate one’s participation in the class or school community to address an identified need.
SEL.4.5 Set and monitor progress on achieving a short-term personal goal with increasing complexity and evidence of planning.
SEL.5.1 Provide and incorporate feedback on products and ideas within programming scenarios.
SEL.5.2 Incorporate multiple perspectives and needs to create a solution. Explain how the solution adequately addresses those perspectives and needs.
SEL.5.3 Analyze why one did or did not achieve a goal, using knowledge about ones skills and strengths. *Also repeated when thinking about personal areas for growth
SEL.5.4 Identify how personality traits (honesty, respect, fairness) enable a group to make decisions and work together to solve a problem, or contribute to a helping mentality.
SEL.5.5 Analyze why one did or did not achieve a goal, using knowledge about one’s skills and strengths.

Learn more than code

Written by an elementary school teacher, the Kodable curriculum focuses on excellent instruction with group and independent practice activities that build creativity, communication, and collaboration.

Creating a Culture of Learning at FSUSD