17 Universal Design for Learning in Computer Science Education

Chapter Overview

This chapter applies the Universal Design for Learning (UDL) framework introduced in Chapter 16 specifically to computer science education (CS Ed) contexts. It provides examples of how the different components of the UDL framework can inform CS lessons. It also offers resources to plan CS lessons that leverage the UDL framework.

Chapter Objectives

After reading this chapter, I can:

• Explain how the UDL framework applies to K-12 CS Ed.
• Apply the three instructional approaches aligned with the three UDL principles (multiple means of engagement, representation, and action/expression) to K-12 CS Ed.

Key Terms:

assistive technologies; culturally sustaining pedagogies; Frayer model; Universal Design for Learning (UDL)

Hana’s Story

In Chapter 16, we met Hana,^[1] an elementary teacher who teaches CS as an elective. In seeking to learn more about implementing the UDL in her CS classroom, Hana spoke with a colleague, Jessica, who had made some successful changes. Jessica shared some of the things she did in her CS classroom to incorporate UDL principles for her students:

Hana was inspired by seeing Jessica’s examples. She decided to go back to the UDL framework and map Jessica’s strategies onto the framework then build on her earlier changes to intentionally develop lesson plans that made space for multiple means of engagement, representation, and action and expression.

Revisiting the UDL Framework

Chapter 16 introduced the Universal Design for Learning, or UDL, framework (Center for Applied Science Technology [CAST], 2024). UDL is an instructional planning and teaching approach based on research about how people learn (CAST, 2018). It seeks to meet all students’ needs by removing barriers from learning environments, curricula, and instructional approaches. Recall that the UDL guidelines emphasize three principles: designing for learning through (1) multiple means of engagement; (2) multiple means of representation; and (3) multiple means of action and expression.^[2]

This chapter considers how UDL can be applied directly to CS Ed in ways that eliminate barriers for learning. For some learners, barriers to CS include a lack of accessible tools or materials or a lack of pedagogical approaches that specifically address their strengths or areas of challenge. For instance, some students may struggle with programming assignments that are not scaffolded and start with a “blank coding canvas.” This kind of assignment design can leave learners without contexts or clues to begin an activity. Learners might benefit from learning coding through multimodal approaches that include scaffolding to complete multistep problems.

Providing multiple entry points is one way to anticipate barriers to participation that draw on UDL principles (Barrett & Israel, 2023). Offering different options to engage with an activity allows students to choose how they participate. It also offers them different ways of expressing their understanding. Activity 1 gives you an opportunity to experience what this looks like. In this guided exploration activity, you can choose between various versions of a Scratch program that teaches about weather.^[3] All of the versions of the program have the same aim, but there are different entry points for you to examine and modify the code. Take 5-10 minutes to explore the options.

The three approaches presented in Activity 1 illustrate how to give students multiple entry points into CS through explicit code-remixing, fixing buggy code, and a Parsons Problem or exploded code (Barrett & Israel, 2023). There are also other entry points and ways to engage students with both the content (weather and precipitation) and the code. These are illustrated in Figure 1.

Figure 1
Scratch Weather (Precipitation) Simulation with Multiple Entry Points

Entry Point	Scratch sample code
Full worked example https://scratch.mit.edu/projects/755743929
Adding a clone https://scratch.mit.edu/projects/755733329
Intro demo is not complete (i.e., 32℉ degrees is incorrect) https://scratch.mit.edu/projects/755700720
Corrected “or” logic version https://scratch.mit.edu/projects/755740047
Exploded code https://scratch.mit.edu/projects/755767176

Using or combining these approaches creates opportunities for discussions with students. CS teachers might ask students questions like:

• How can you improve the existing code?
• What enhancements can you make to the project?

These questions provide ample opportunities to engage with content and computing. Some enhancements may require a few steps, while others may be more complex. For instance, in the above Scratch projects, it is always precipitating. Another version includes a new feature to stop the precipitation: pressing the “s” key will bring out the sun.^[4] Other possible enhancements include adding movement for the cloud, collecting accumulated snow at the bottom of the stage, or even adding a rainbow for a few seconds after the arrival of the sun. Each change allows students to think deeply about the science concepts related to precipitation and the code needed to create the enhancement. Finding different entry and exploration points that speak to the needs and skills of learners is one important way to meet multiple UDL guidelines at once.

Throughout the remainder of the chapter, we’ll explore in greater detail how each of the three principles of UDL applies to CS Ed (Israel et al., 2017). While we consider each one separately, in reality, they often overlap. And, as was mentioned in Chapter 16, you may find that you are already implementing strategies in your classroom that align with the principles we examine here.

Designing for Multiple Means of Engagement

The principle of designing for multiple means of engagement involves considering how to remove barriers to participation. One of these barriers might include getting started with an activity, as Activity 1 illustrated. Other barriers can include seeing the activity as irrelevant or uninteresting, losing motivation to complete the activity, or getting frustrated and giving up on completing the activity. We can remove these and other barriers by designing learning experiences and environments that welcome students’ interests and identities, help them manage emotions, and support them to persist and give sustained effort to a learning task.

In this section, we’ll consider how designing for multiple means of engagement in the CS classroom can include (1) welcoming interests and identities; (2) helping students sustain effort and persistence; and (3) developing students’ emotional capacity.

Welcoming Interests and Identities

A key part of engaging students in CS learning is capturing their interest in learning opportunities. One important way to accomplish this is by giving students choice. A major tenet of UDL is to build learner agency so that learners become purposeful, strategic, and action-oriented (CAST, 2024). If you look back at Activity 1, you’ll see that you were provided with choices. You decided how you wanted to approach the activity by looking at the options and choosing the version you wanted to explore. The same holds true for our students. We can make choices clear and explicit for learners, especially at the start of a new project. Offering students choice increases engagement because it provides students with agency, empowering them to take action and direct their own learning.

Another important way to capture students’ interest is to let them tailor their CS learning to be relevant to their lives. For example, when students are learning about fractional parts along a number line, they can be given a choice in how to demonstrate their understanding of the concept. One option would be to animate a math story problem in Scratch. In the figure below, for example, the student animated a story where a monkey moved across a number line on a magic carpet. Students could select sprites that were interesting to them to make CS fun and personally relevant.

Figure 2
A Student’s Personal Scratch Project

Other chapters in this book (e.g., chapters 2, 4, and 12–14) also consider how to make CS relevant to students’ lives and backgrounds as part of culturally sustaining pedagogies. These approaches go beyond capturing students’ daily hobbies and preferences, taking up students’ cultures and backgrounds as resources for learning. Ms. Kors’ assignment in chapters 12 through 14 is one example. Students’ identities can also be incorporated into CS in a variety of other ways. For instance, a CS project might ask students to create a story about a family holiday tradition. One student might share about Easter, another about Kwanzaa, and a third about Ramadan, with each student sharing cultural practices that are meaningful to them and their families and communities. When students have autonomy to add personal relevance to their work, they are more likely to want to engage with that work.

Other strategies to recruit students’ interest include providing scaffolds that minimize common “pitfalls” related to both the content and computing skills students need. Teachers can structure activities that allow for students to work on projects at different paces and for different amounts of time and provide students with options to increase or decrease sensory stimulation (e.g., listening to music or using noise cancelling headphones). These strategies engage students in CS learning through tools that support them toward success and allow them to tailor their learning to meet their individual needs and interests.

Sustaining Effort and Persistence

Students are often motivated to participate in CS because it is fun! Yet once students begin to code, they will inevitably create something that does not work as they expected. When code doesn’t work according to plan, it can make CS learning difficult and frustrating. Engaging students in CS requires them to maintain their interest and persist in learning activities, even when it is difficult.

One way to help sustain students’ effort and persistence is by providing them with positive learning objectives that make students aware of what they have already accomplished. These learning objectives or goals are restated as “I can” statements that make goals concrete and explicit for learners (Israel & Lash, 2020). The goals can address both content and computing aspects of a task. Examples from the Action Fractions Polygon Partners lesson include the following (Learning Trajectories for Everyday Computing [LTEC], n.d.)^[5]:

• I can identify attributes of polygons.
• I can use math language to write instructions (pseudocode) that a friend can follow to create a polygon.
• I can give and receive feedback to improve directions to animate a polygon in Scratch.

Teachers can encourage students to gauge their own understanding of “I can” statements and provide us with feedback in a variety of ways. For example, at the beginning of the lesson, students can evaluate how they feel about the statement: I can use math language to write pseudocode that a friend can follow to create a polygon. Students can physically show a thumbs up, down, or to the middle; press a green, red, or yellow button; or point to a corresponding symbol (see Figure 3). At the end of the lesson, teachers can check in again. Students’ responses may change to indicate growth in understanding.

Figure 3
Student Self-Evaluation for “I Can” Statements

Other strategies to sustain students’ effort and persistence in CS include explicitly discussing the role of perseverance and problem solving in CS and celebrating students’ efforts to persevere and problem solve in the classroom. Teachers can provide additional supports and extension activities to maintain students’ engagement. Activity 1 at the beginning of the chapter provides an example of an extension activity as Option 4. Collaboration is also a key way to sustain effort and persistence. Teachers can design activities that use pair programming and group work, giving students clearly defined roles as part of the task. Teaching students how to give and receive feedback on each other’s work and building in opportunities to share ideas with peers sustains engagement through collective learning.

Emotional Capacity

Supporting student engagement also requires supporting self-regulation throughout learning activities. Coding inherently involves things not working according to plan. Helping students learn how to deal with frustration and debug their code is crucial to keeping them engaged.

One approach for teaching debugging as a skill is to use strategies like the Debugging Detective (Universal Design for Learning for Computer Science [UDL4CS], 2021; Figure 4)^[6]. This activity includes questions like, “What did I want my code to do?” and “What happened when I ran my code?” followed by a series of yes/no questions that cue students to think about their code. As they do, they can analyze what went wrong and find potential new avenues to try to fix it.

Figure 4
Debugging Detective

Teachers can also help students with self-regulation by facilitating personal coping skills and strategies. Acknowledging difficulty and frustration as a reality is important. Strategies for dealing with frustration can be taught as part of social-emotional learning (see Chapter 9). Other supports that teachers can design into their learning experiences to support self-regulation include setting clear expectations for the learning task, having students collaborate with others, teaching students to ask for help, and using assessment rubrics that evaluate both content and process. Breaking up coding with opportunities to reflect on the process through activities like turn-and-talks, written questions, and self- or peer assessment can also sustain engagement.

Designing for Multiple Means of Representation

The principle of designing for multiple means of representation involves removing barriers for students in terms of how information is presented and how students take it in. There is no single way that information can or should be represented that is optimal for all students. We can remove barriers to representation by providing information in multiple ways (e.g., visual, auditory, physical models), giving students control to adjust how they receive information, and scaffolding students’ understanding of information.

In this section, we’ll consider how designing for multiple means of representation in the CS classroom can include providing students with options for (1) perception, (2) language and symbols, and (3) building knowledge.

Perception

Giving students options to perceive information is a key part of providing them with multiple means of representation. Supporting perception involves offering students information in multiple modalities, offering them information in formats that they can adjust, and offering them information that incorporates a variety of perspectives (CAST, 2024).

Given that students process information in multiple modalities, we can go beyond using only auditory or visual information. Instead, we can include alternatives and multiple ways to access content. This might include offering students written instructions and videos of how to complete a CS activity and allowing them to model code through unplugged physical representations and manipulatives before coding on a device. Offering students choices around how they perceive information might also mean using tools that allow students to adjust formatting to more easily perceive the information, such as changing the text size on instructions, adjusting volume on videos, adding closed-captions, and reading alternative text for any images. These moves can help enable all learners access information.

We can also provide students with worked examples of code (Skudder & Luxton-Reilley, 2014; Muldner et al., 2022). By worked examples, we mean scripts that use relevant and instructive variable names and include comments or documentation that might scaffold or explain what particular segments of code are meant to do. Showing students worked examples of code can model good literate programming practice (Knuth, 1984; see Chapter 13) and be an important way to support students’ perception. Worked examples illustrate not just the outcome of a code, but the process of creating the code by showing how programs decompose larger problems into smaller ones. Students can then use those code chunks to solve new problems that are similar to those they are attempting (Margulieux et al., 2013). This approach provides a multimodal way of presenting information. Many CS curricula and tools include worked examples. When worked examples are not available, we can create our own or have students create tutorials for each other (Figure 5; Israel & Ray, 2024).

Figure 5
Sample Worked Examples for a Scratch Project

The strategies above support students’ sensory perception, but it is also important for learners to recognize and perceive themselves and others in CS. A final consideration for incorporating perception involves providing students with information that authentically represents diverse perspectives and identities (CAST, 2024). Incorporating examples of computer scientists who represent a range of backgrounds is one way to do this. (See Chapters 1 and 2 for some examples.)

Language and Symbols

CS includes many new concepts, some of which are abstract and could become barriers for learners. As with many disciplines, expertise means becoming familiar not only with the concepts but also with how to use professional ways of representing those concepts (Kozma et al., 2009). Providing students with multiple means of representation includes supporting them to learn and use the language and symbols related to CS and coding. Teachers can explicitly teach and review computing vocabulary including concepts like code, animations, algorithms, loops, and so on (see Figure 6; Israel & Ray, 2024). Teachers should also teach and review content-specific vocabulary. For instance, in the Scratch example at the beginning of the chapter, a teacher might focus on vocabulary terms like “precipitation,” “atmosphere,” and “temperature.” Teachers can support students to use content and computing terms by representing language and symbols in a variety of ways. This might include anchor charts or reference sheets with images of code blocks or common syntax posted in the classroom (see Figure 7, photo credit: Todd Lash).

Figure 6
Representations of Computing Vocabulary

Figure 7
Representations of Computing Symbols

One unique challenge in CS is that students may already have an understanding of a term in one context that takes on a different meaning in CS. For example, the term “variable” is one that students may be familiar with from their math courses. However, a variable in CS and the process of assigning its values in relation to an equal symbol might feel very different from students’ experiences with variables in math (Schanzer, 2017). Rewiring a new neural pathway for something already familiar can be challenging. It is important to consider how to introduce or remap concepts for learners.

In considering how to teach concepts like this, teachers might consider questions like:

• What existing knowledge do students already have about the concept?
• Is that knowledge accurate for the CS context?
• Can I build on their existing knowledge?
• Do I need to modify or expand it for the CS context?

A Frayer model is one way to introduce new concepts or familiar concepts in a new context. This model places the concept at the center of the map then explores the concept across four quadrants — a definition, facts and/or characteristics, examples, and non-examples. Figure 8 shows a Frayer model about precipitation. This content-related model could be used to frame a lesson for students who are learning to code by using Scratch to build out the weather concept presented in the examples in Activity 1.

Figure 8
Precipitation Frayer Model

Frayer models can also be used for CS concepts. In Activity 1, loops are required to keep precipitation falling, so Figure 9 shows a model for the CS concept of loops used in relation to the science concept of precipitation.

Figure 9
Loops Frayer Model

Offering students multiple ways to build their understanding of language and symbols and relate the language to CS concepts supports accessibility, comprehensibility, and clarity and is key to ensuring shared understanding for all learners (CAST, 2024).

Building Knowledge

It is not enough to simply present information in multiple ways. We must also build students’ knowledge about that information. One important way to do this is by drawing on students’ background knowledge, or what they already know about the topic in terms of content and relevant computing concepts. To uncover students’ background knowledge, teachers can ask guiding questions. For Activity 1, questions might include:

• What are the conditions for snow?
• How do we simulate a snowflake falling from the sky in our program?
• What do we need to do with the snowflake to make it fall over and over again?

Teachers can also ask questions and invite students to ask questions throughout learning activities. These comprehension checkpoints show what students are understanding and what barriers might still exist to comprehension. They can also guide teachers to scaffold the next steps to expand students’ learning. Additional concepts that could be explored based on Activity 1 might include:

• Accumulation of rain vs. accumulation of snow
• Conditions for a rainbow
• Representing hail or sleet by dividing the stage into zones of varying temperatures
• Introducing the water cycle

Other ways to build students’ knowledge include providing graphic organizers to help students “translate” programs into pseudocode and using relevant analogies between coding concepts and other content areas. CS teacher Melissa had one of her students do this themselves when they connected CS terms to literacy examples (see Chapter 1). The student compared a sprite in Scratch to a character in a story and the Scratch stage to the story’s setting. These parallels made CS concepts more accessible and concrete, supporting all learners’ comprehension.

Designing for Multiple Means of Action and Expression

The principle of designing for multiple means of action and expression focuses on how students learn. It involves removing barriers related to how students will interact with each other and with the content, how they will plan to learn, and how they will show what they’ve learned. We can think of this principle as representing the choice and voice that students get in how to express their learning.

In this section, we’ll consider how designing for multiple means of action and expression in the CS classroom can include providing students with options for (1) interaction, (2) expression and communication, and (3) strategy development.

Interaction

Interaction describes how students engage with both learning materials and the learning space. CS teachers need to consider barriers that students might face when moving around the classroom (e.g., seating arrangements, narrow aisles), engaging with unplugged learning materials (e.g., whiteboards, physical manipulatives), and engaging with technology (e.g., keyboards, track pads, screens, software, online programs). Removing these barriers ensures that all students can engage in CS learning experiences.

Some ways to facilitate interaction as a way of providing access to how students learn CS include selecting coding apps and websites that offer keyboard shortcuts in addition to dragging and dropping with a mouse and providing students with assistive technologies like larger or smaller mice or touch-screen devices. Teachers can also offer their own code as templates for students or lead unplugged CS activities that help students engage with coding ideas by physically representing relationships between abstract computing concepts.

Teachers can involve students in designing and programming projects that provide multiple means of action and expression through interaction and access. For example, the Scratch weather example from the beginning of the chapter intentionally lacked user instruction. Students could make recommendations about how to communicate to users how best to engage with the project. Some alternatives to make the project more user-friendly might include having students:

• Create an audio file that plays to tell users where to click at the start of the game.
• Create a message to be displayed at the start of the simulation.
• Create a message to be displayed after a certain length of time.
• Halt all action and focus the user input as the center of attention.

Another way to facilitate interaction is by teaching CS in ways that support collaboration (Lash et al., n.d.). Teachers may need to explicitly teach and model collaboration as a learning goal in and of itself. This process might involve arranging the classroom to facilitate collaboration through seating arrangements and anchor charts with sentence stems and prompts that help students unpack a problem with their peers. Resources like the Collaborative Discussion Framework (Lash & Park, 2015) may be useful. Teachers might also experiment with different models of collaborations (e.g., partners, small groups, using a timer, offering more or less structured collaboration models) to find what best meets the needs of all students.

Expression and Communication

Expression and communication focus on how students are able to share what they know, have learned, and are learning. Offering choices for how students communicate, scaffolding the process of creating products that represent learning, and honoring the many different ways that students communicate are important considerations for this guideline.

CS teachers can provide students with options for expression and communication by letting students show what they know through unplugged activities and different kinds of computing software and materials. Some of these possibilities might include supporting students to express themselves through pseudocode, physical manipulatives, flowcharts, and comments in code or to use block-based programming interfaces like Alice, code.org, and Scratch.^[7] Supporting expression through code can include providing students with options that include starter code they can remix and/or having students create physical manipulatives of commands, blocks, or lines of code. Teachers can also support expression and communication throughout the learning process by offering sentence starters or checklists to help students collaborate, give feedback, and explain their work. Giving students opportunities to practice computing skills and content through projects that build on prior lessons also supports them in showing what they know.

One key way to design for multiple means of action and expression is to give students choice in how they express and communicate what they know. This might look like giving students options for how they show evidence of completing an assignment. For example, instead of creating a model in Scratch, students might create a storyboard or an illustration of a model. Even when students use Scratch, they could have choice in how they represent aspects of their model. They might use existing sprites, search for sprites online, or draw or paint their sprites by hand. These options allow students to express their learning and communicate it to others.

Strategy Development

Strategy development involves helping students “develop the capacity to act skillfully and purposefully” (CAST, 2024, n.p.). This includes teaching students to manage short-term responses to learning and to set, plan, and monitor progress toward long-term goals.

There are many strategies that teachers can offer to support strategy development as part of learning to code. Some of these include guiding students to set goals for long-term projects, which can be supported by providing students with graphic organizers that facilitate planning, goal-setting, and debugging. Figure 10 is an example of a checklist that students could use to ensure that their project has all required components and aligns with the assessment rubric (Jeong et al., 2017). Teachers might also use planned checkpoints during lessons that verify students’ understanding of computing skills and academic content and their progress toward learning goals. Teachers can provide students with examples of completed products and embed prompts throughout a project or lesson that invite students to stop and plan, test, or debug. Providing explicit instruction on skills like asking for help, providing feedback, and problem solving can help students express themselves throughout the coding process. Teachers can also demonstrate debugging strategies for students using think-alouds. Finally, having students record their progress over time can allow them to recognize their learning and growth.

Figure 10
Project Completion Checklist excerpted from Jeong et al., 2017^[8]

As has been mentioned, debugging is an especially important skill for students to develop as they learn CS. Debugging requires self-regulation related to emotional capacity and developing strategies and executive functioning. The metacognitive strategies that are required to debug and are developed through debugging reinforce the importance of strategy development.

One explicit debugging strategy is referred to as the “reuse strategy” by Ko and colleagues (2019). This strategy involves helping students identify the behavior they want to implement in their program and then find and use code created elsewhere to help them achieve their goals. The reuse strategy provides feedback to students about their goals, what they are trying to code, and what pieces of code they may already have seen that could help them achieve their goal. For example, in the multiple iterations of the weather simulation from Activity 1, the working models of code support the downward movement of sprites, disappearing and reappearing, user interaction through clicking on a sprite, creating clones to create multiple sprites, or using a sprite (i.e., the sun) to act as a trigger to stop all movement. Students could reuse these working models to create new actions in their own programs. Supporting students to develop strategies to manage challenges, solve problems, and identify solutions are key aspects of CS learning.

Using the UDL Framework as a Resource in CS Ed

As mentioned earlier, the goal of the UDL framework is to anticipate barriers to learning and design learning experiences that reduce or eliminate as many barriers as possible. While it will not be possible to fully eliminate all barriers for every student, anticipating and removing barriers helps your learners have the best learning experience possible and should always be a part of our goals as CS educators.

The UDL framework can guide your efforts to identify and brainstorm possibilities. Remember to begin by designing measurable goals and outcomes for computing and content. Plan ahead of time how you will assess your learners’ progress and achievements. Consider creating an assessment plan that addresses barriers that students may encounter, such as providing multiple entry points to a project or choices that allow learners to take ownership of their learning. Allow students to express their learning in meaningful ways. Finally, spend time reflecting. Honest, supportive reflection helps teachers grow and enables us to create the best possible environments for our students to succeed.

Now that you have read this chapter, consider the strategies that Jessica shared with Hana at the beginning. Where do you see different aspects of UDL informing Jessica’s instructional approach?

Revisiting Hana’s Story

Hana was excited to make connections between UDL and her CS curriculum. Hana began implementing these changes to strengthen her instruction. Every day, she started and ended her lessons with “I can” statements to help students monitor their own learning. She hung anchor charts around her room with reminders of key CS terms for students to reference. She also gave students options for how they shared their final projects, letting them represent their work through a combination of code, drawing, diagrams, math problems, and writing.

Over time, Hana noticed that all of her students felt more successful in CS, including her students with IEPs. Other teachers had claimed that CS would be too hard for those students, but Hana watched as they excelled in her class and gained confidence. Hana recognized how the UDL framework guided her to design CS learning experiences that eliminated barriers to learning and benefited all of her students.

Reflection Questions:

1. Which strategies and designs described in this chapter have you either seen done or used yourself? Which most resonated with you as ones you would like to try?
2. The UDL framework is used across all content areas. Based on what you read in this chapter, how does UDL specifically support learners within the unique context of CS Ed?

Takeaways for Practice:

• Choose a CS activity that you have used or would like to use with students. Redesign it to offer students multiple entry points to get started with the activity and/or multiple options to show what they have learned and demonstrate completion of the activity.
• Reflect on your CS Ed context and identify 2-3 barriers in the learning environment that students face. Which design principles in this chapter can help you address those barriers and remove them for learners?

Glossary

Term	Definition
assistive technologies	Technology that helps people with disabilities perform tasks more easily or safely so that they can live, move, participate, and contribute in society more fully. Assistive technologies may include devices (e.g., walkers, prosthetics), materials (e.g., curricular aids), services (e.g., technical assistance), or software (e.g., screen readers).
culturally sustaining pedagogies	Ways and approaches to teaching that value and center students’ cultural identities, practices, and ways of knowing as resources for learning rather than excluding or eradicating students’ cultures from the classroom (see Ladson-Billings, 2021; Paris & Alim, 2017).
Frayer model	A graphic organizer that helps students learn new vocabulary words and understand their meanings. The model places the vocabulary word/concept at the center of the map then explores the term across four quadrants: a definition, facts and/or characteristics, examples, and non-examples to clarify what the concept is not.
literate programming	An understanding of code as a form of expression that is part of a social conversation because computer code (programs) is meant to be read and understood by people and not just computers (Knuth, 1984).
Universal Design for Learning (UDL)	An instructional planning and teaching approach that seeks to meet the needs of all learners by reducing barriers to learning. The three principles of UDL include providing learners with (1) multiple means of engagement, (2) multiple means of representation, and (3) multiple means of action and engagement (CAST, 2024).

References

Barrett, J., & Israel, M. (2023). Scaffolding block coding through multiple entry points. WiPSCE ‘23: Proceedings of the 18th WiPSCE Conference on Primary and Secondary Computing Education Research (pp. 1-2). https://doi.org/10.1145/3605468.3609756

Center for Applied Special Technology. (2018). UDL and the learning brain. https://www.cast.org/binaries/content/assets/common/publications/articles/cast-udlandthebrain-20220228-a11y.pdf

Center for Applied Special Technology. (2024). The UDL guidelines. https://udlguidelines.cast.org/

Israel, M., & Lash, T. (2020). From classroom lessons to exploratory learning progressions: Mathematics computational thinking. Interactive Learning Environments, 28(3), 362-382. https://doi.org/10.1080/10494820.2019.1674879

Israel, M., & Ray, S. (2024, April 6). UDL in CS education. [Professional development session]. Exploring Equity in Computer Science, New York City Public Schools, New York City, NY, USA.

Israel, M., Lash, T., & Ray, M. (2017). Universal Design for Learning within computer science education. Creative Technology Research Lab, University of Florida.

Jeong, G., Lash, T., & Israel, M. (2017). Helpful strategies for project planning during K-12 computer science instruction. Project TACTIC: Teaching All Computational Thinking Through Inclusion and Collaboration. Creative Technology Research Lab, University of Illinois. https://ctrl.education.illinois.edu/TACTICal/project-planning.html

Knuth, D. E. (1984). Literate programming. The Computer Journal, 27(2), 97-111.

Ko, A. J., LaToza, T. D., Hull, S., Ko, E. A., Kwok, W., Quichocho, J., Akkaraju, H., & Pandit, R. (2019). Teaching explicit programming strategies to adolescents. SIGCSE ‘19: Proceedings of the 50th ACM Technical Symposium on Computer Science Education (pp. 469-475). https://doi.org/10.1145/3287324.3287371

Kozma, R., Chin, E., Russell, J., & Marx, N. (2009). The roles of representations and tools in the chemistry laboratory and their implications for chemistry learning. Journal of the Learning Sciences, 9(2), 105-143. https://doi.org/10.1207/s15327809jls0902_1

Ladson-Billings, G. (2021). Culturally relevant pedagogy: Asking a different question. Teachers College Press.

Lash, T., & Park, M. (2015). The collaborative discussion framework. Campaign Unit 4 School District. https://ctrl.education.ufl.edu/wp-content/uploads/sites/5/2020/06/CTRL-CollabFramework.pdf

Lash, T., Jeong, G., Wherfel, Q., & Israel, M. (n.d.) Helpful strategies for peer collaboration during K-12 computer science instruction. Project TACTIC: Teaching All Computational Thinking Through Inclusion and Collaboration. Creative Technology Research Lab, University of Florida. https://ctrl.education.ufl.edu/wp-content/uploads/sites/5/2020/06/CTRL-TACTIC-PeerCollaboration.pdf

Learning Trajectories for Everyday Computing. (n.d.). 3rd grade lesson: Polygon partners. http://everydaycomputing.org/lessons/action-fractions/grade-3/polygon-partners

Margulieux, L. E., Catrambone, R., & Guzdial, M. (2013). Subgoal labeled worked examples improve K-12 teacher performance in computer programming training. Proceedings of the Annual Meeting of the Cognitive Science Society, 35, 978-983. https://escholarship.org/uc/item/170185bh

Muldner, K., Jennings, J., & Chiarelli, V. (2022). A review of worked examples in programming activities. ACM Transactions on Computing Education, 23(1), 1-35. https://doi.org/10.1145/3560266

Paris, D., & Alim, H. S. (2017). Culturally sustaining pedagogies: Teaching and learning for justice in a changing world. Teachers College Press.

Schanzer, E. (2017, Jan 9). Integrating computer science in math: The potential is great but so are the risks. AMS Blogs. https://blogs.ams.org/matheducation/2017/01/09/integrating-computer-science-in-math-the-potential-is-great-but-so-are-the-risks/

Skudder, B., & Luxton-Reilly, A. (2014). Worked examples in computer science. Proceedings of the Sixteenth Australasian Computing Education Conference (pp. 59-64). https://crpit.scem.westernsydney.edu.au/confpapers/CRPITV148Skudder.pdf

Universal Design for Learning for Computer Science (UDL4CS). (2021). Debugging detective. https://udl4cs.education.ufl.edu/resources/debugging-detective/