Using Scratch to Teach Computer Science in the Language Classroom
By Frederick Poole, Michigan State University
In the last five years, Computer Science for All (CS4All) initiatives have been spreading through K-12 institutions in the United States. Many of these initiatives are the result of substantial government funding that aims to explore approaches for both teaching youth computer science (CS) concepts and inspiring youth to explore CS as a potential career. Females and minorities have been notoriously underrepresented in the CS industry while every year large amounts of CS jobs go unfilled. One of the obstacles that these initiatives often face is a lack of instructional time in an already crowded curriculum at the K-12 level. In this article, I will discuss why integrating CS into the language curriculum is mutually beneficial for both CS and language education.
Why Computer Science?
When we talk about computer science education, for those outside of the CS field, there is often a misconception about what CS is and how it is taught. Like non-language teachers who believe that language instruction is simply teaching words or giving students grammar exercises, many people often associate CS education with teaching a particular coding script such as Python or C#, and some see CS education as only instructing learners how to create complex algorithms. However, with the recent push for developing curriculum for younger children, there has been a greater emphasis on teaching computational thinking concepts. These are concepts that are believed to represent many of the skills that computer scientists use on a daily basis. For example, decomposition is the process of breaking a problem down into smaller more manageable pieces, and abstraction involves identifying common patterns that can be reused in other parts of a program. By identifying computational thinking skills as the target of instruction (rather than teaching a specific CS language), we can increase the possibilities for what CS education looks like. Fortunately for younger learners, block-based programming environments allow for building programs visually, thus lowering the cognitive demand typically involved in programming while also fostering these critical skills.
How Does Computer Science Support Language Learning?
When bringing CS curriculum into K-12 classrooms the first challenge is identifying where to place it. Many initiatives have identified the library as a possible place for CS in the curriculum, while some researchers have begun exploring the integration of CS education with mathematics. In this article, I argue that CS education is a better fit for the language classroom. In terms of instructed second language acquisition, teaching computer science in the language classroom would be considered a form of content-based instruction. Similar to other content-based instruction (CBI) programs, the use of the target language will be more meaningful as students have the opportunity to apply their language skills to a 21st century skill. Further, through a CBI approach, like other communicative approaches, the focus is on meaning over form. Learners are focused on completing a task (creating a program) which allows for more authentic forms of language use.
In addition, there are affordances of teaching CS via the target language that are unique to CS compared to other content areas. For instance, by creating a program or software that can readily be shared and remixed on the web, students have an opportunity to create an artifact that can be used and shared with others. Conversely, students have the opportunity to remix and learn from other students’ projects. This culture of remixing is slightly different from sharing artifacts in other educational fields in that learners can pull apart designs, repurpose designs for custom use, and receive direct feedback on their own designs from a large and supportive community. Further, this potentially creates opportunities for not only talking about/showing off one’s creation, but it also may lead to additional conversations with those in online programming communities in the target language. Another benefit of this integrated approach comes from the coding process. The coding process involves an iterative approach in which a programmer adds code to a project, tests it out, and then adjusts the code as needed. This iterative process provides an authentic and meaningful way to provide repeated exposures to target language concepts. Additionally, in CS education there are many co-coding tasks that are often used to help emergent coders recognize problems in a code. These can include activities in which one coder reads the code to the other with hopes of identifying a ‘bug.’ It can also involve ‘navigator-driver’ activities in which the navigator dictates what the code should do, and the driver acts the code out in the most literal terms to illustrate how code makes a program work. All of these activities are not only beneficial for CS education, but they also provide language learners with meaningful and unique ways of applying their language skills.
Using Scratch to Teach Computer Science
Scratch is a programming environment that was created for young emergent coders. It uses a block-based user interface, to lower the entry-level threshold to coding. But more importantly there are tutorials for Scratch (you can find some of these below in Extra Resources) as well as a very active and helpful community that shares and comments on programs. By using this tool, learners can create simple animations, interactive fiction stories, and digital games. The Creative Computing Lab at the Harvard Graduate School of Education has created a full curriculum for this tool that has been used widely across several CS initiatives for young learners. Using portions of this curriculum I will provide an example of what a language and CS integrated lesson might look like.
Telling a Joke
In this lesson students will create a short animated joke with two animated characters, or sprites, each with their own programmed instructions. This lesson was designed with late-elementary (4-6th grade) dual language immersion students and thus it is assumed that much of this will be taught in the target language. Though it should be stressed that this should not be the first lesson involving Scratch, but rather this is a lesson that may appear after students have been slowly introduced to Scratch via more simple projects.
In this project students will be challenged with creating a back and forth dialogue between two sprites. From a programming perspective it is fairly easy to make sprites speak a text-based dialogue, but having them engage in back-and-forth conversation can be challenging. There are two primary ways to do this in Scratch, one that involves the programming concept of parallelism and the other involving events. Parallelism is the idea of two actions occurring simultaneously and requires that learners carefully time the sprite actions using a series of wait commands. Essentially both sprites will start executing their code at the same time (parallelism) and if the code is timed just right, the dialogue will appear in a back-and-forth manner. Events, on the other hand, allow learners to program the sprites to wait until an action is received to begin another action. In this way, they can program their sprites to speak a portion of a dialogue only once a triggering event has been initiated.
In Picture 1 below I have adapted a Scratch project template from the Harvard curriculum. The Coding Blocks area is where students find the blocks, or functional pieces, needed to code their program. The Scripting area is where blocks are added and assembled to make their programs. It is important to note that each sprite will have its own scripting area. Currently in this figure I am programming the Penguin and I am using the parallelism concept. When the Green Flag is pushed to start the program, the penguin will begin by saying ‘Hola’ and then will progress through the code waiting periodically between each statement.
In Picture 2 below I have the code that is being used for the monkey sprite. Notice that it also has a series of 2- and 3-second wait blocks. Many of these have to be timed just right so that this program runs smoothly. One of the useful ways to get students thinking about parallelism and events is to first show them how the program works. Then remove all of the wait blocks and play the program again. The sprites in the program will attempt to talk over each other making it impossible to follow.
Next you can ask students what went wrong and why. Likely students will mention the lack of wait blocks. At this point you can allow students to try adding wait blocks to fix the program. Through this process students will likely need to take an iterative approach in which they add 1-, 2-, and 3-second blocks and then test their program. This is a perfect time to talk about the debugging process which involves trying out a code, evaluating the effectiveness of a code, and then debugging the code. Once students have finished this process you can discuss how effective their codes are and if there is an easier way to code this program. This would then lead nicely into a discussion of Events.
In Scratch, Events are represented by broadcasting and receiving messages. So, instead of using a series of wait blocks, students would broadcast a message at the end of a dialogue and then program the other sprite to start a dialogue once a message has been received. Using Events requires more blocks, but involves less guesswork than the alternative of timing wait blocks. After students have converted their programs to use broadcasting blocks, a quick class discussion on the pros and cons of both of these approaches could follow.
Finally, after introducing these concepts to students, I would have them apply them by creating a new program in which they set their own background and sprites and add a joke of their own. By building on the joke theme of this lesson, students would then find authentic jokes into their target language and find sprites and a background to match the joke. A follow-up task would then involve students watching their classmates’ jokes and then voting on which joke they liked the best.
In this lesson there are many opportunities to draw attention to meaning and form. First, these lessons should begin with a teacher modeling the task and in doing so modeling the language needed to complete the task. You may have noticed that the user interface in the example above was all in Spanish. The Scratch user interface can be changed into over 60 different languages as well. Using language on the blocks can support the teacher as she models the language needed to code and discuss the program. Additionally, as I have shown in this lesson plan, creating activities around the programs that students make are also great ways to infuse language learning opportunities into this approach. Further, I would argue that most of the language learning should occur in these peripheral activities rather than through content creation (e.g. writing jokes). Another affordance of Scratch is that it easily allows students to share and remix their projects. Remixing is the act of saving another project into one’s own account and then adapting the code for their own purposes. This not only gives learners an opportunity for repeated exposure to the language in the program, but it also provides scaffolding for more difficult programs and motivation to complete projects as learners can share them with friends, family, and others in the Scratch Community. Thus, when designing activities around Scratch projects it would be ideal to take into account students’ ability to share and remix projects. Finally, with any new curriculum or approach there will be a learning curve. While at first glance this project may appear quite time consuming and potentially take away from other communicative activities in the classroom, once students have learned the basic vocabulary around Scratch and have become familiar with the tool, more opportunities for meaningful communication can emerge around the unique projects that learners can create. However, in addition to developing communicative competencies, learners will also be developing programming skills and potentially a vision for how their language skills can be used outside of the classroom.
Final Suggestions for Creating a Unit
In this article I set out to illustrate how one aspect of CS education might be brought into the language classroom. Research on CS in the K12 curriculum is experiencing a surge in interest but is relatively unexplored in language learning classrooms. For many teachers, the idea of bringing CS into their language classrooms may sound intimidating and time consuming. I hope that through this example I have provided a model that helps teachers envision CS in their classroom. I conclude this article with a few suggestions for those who are interested in applying this approach.
Start Simple.
When thinking through your Scratch unit, remember to start simple. Start off with creating a simple button that produces language, or a simple program that moves the sprite across the room. Then slowly and iteratively add to your project to increase complexity.
Be Iterative.
Being iterative here not only means building on your previous apps/software, but also giving students multiple opportunities to play/experience their own and their classmates’ apps.
Co-Coding Tasks!
Use co-coding tasks to not only improve the students’ apps, but to also create opportunities to use the language in meaningful ways. Co-coding tasks is not just working in pairs, but also includes having one student drive (hold the mouse) while the other navigates (tells the student what to do), or having one student break a code and the other fix it.
Show Off Your Project!
One of the benefits of creating Scratch projects is that they are easily shared. Allow your students an opportunity to teach their classmates about their app. Allow students to play with their classmates’ projects. Another affordance of this tool is to remix projects. Remixing is a culturally-appropriate activity in the CS world. Coders often borrow, share, and manipulate each other’s code to create new programs.
Create Something Personal.
While it is a good idea to provide a model or a template for a project, be sure to also encourage students to personalize their projects. Making it personal will increase the likelihood that learners invest in the project and put more effort into it.
Additional Project Ideas
- Create an interactive map of the target culture
- Create a maze to practice directions
- Create a simple dictionary/translator tool
- Create a choose-your-own adventure story
Extra Resources
1. A simple Step-by-step tutorial that introduces the Scratch user interface and teaches you how to make a simple balloon popping game.
https://www.create-learn.us/blog/scratch-tutorial-for-kids/
2. This is a Scratch tutorial made by the creators of Scratch and provides a video in the Scratch user interface to walk you through the different parts of Scratch and to ultimately build a short story. https://scratch.mit.edu/projects/553742046/editor
3. Here you can find a collection of short Scratch tutorial projects that were made by the community. This usually includes tutorials for specific things you might want to do in the Scratch. For example, one of the projects illustrates how to accomplish smooth movement in Scratch. These tutorials usually include a series of comments that annotate the code. https://scratch.mit.edu/studios/1817151
4. On this site you can find a curriculum that I helped develop that used a board game to help students learn Scratch. In the curriculum, students ultimately design a digital version of the board in Scratch. While not specifically geared towards language learners, this could be adapted to a language teaching context. https://sites.google.com/view/tabletop2screenscurriculum/home
5. The Scratch community is one of the best reasons for bringing Scratch into your classroom. Students can engage with students from around the world and discuss their Scratch projects in their target language on the Scratch discussion forums. https://scratch.mit.edu/discuss/