13 Literate Programming and Code as a Language Resource

Chapter Overview

This chapter presents the idea of “literate programming,” or how code can be used as a form of expression as part of social conversations. It defines literate programming in the context of computer science (CS) and considers how literate programming is relevant to CS education (CS Ed). The chapter illustrates ways to engage students in thinking about code and ways to use code as an expressive medium in and of itself to contribute to conversations.

Chapter Objectives

After reading this chapter, I can:

• Define literate programming and identify ways to support students to communicate with and about code.
• Identify ways that using code can support bi/multilingual students’ expression.

Key Terms:

language repertoire; literate programming; translanguaging

John’s Story

In Chapters 11 and 12, we met John, a sixth grade student at a public middle school in New York City. John was in Ms. Kors’ English as a New Language (ENL) class. He spoke Amharic, Arabic, English, and Tigrinya and, by translanguaging (see Chapter 12), drew on his full language repertoire to develop a Scratch-based story about his journey from Eritrea to Ethiopia as a refugee. In this chapter, we consider how Ms. Kors helped John and his classmates think about code in new ways that allowed them to express themselves through their personal narratives.

Code as an Expressive Resource

As we aim to support bi/multilingual and language-minoritized students in CS Ed, it is important to consider the power dynamics of computing education that may be excluding those students in the first place.^[1] CS is often taught in ways that reinforce narrow notions of what counts as CS, who does CS, and for what purposes. Many CS 101 courses ask students to memorize syntaxes and to create test “toy” projects disembodied from real-life contexts.

But these approaches ignore the fact that code is deeply relevant to the human experience. Code is all around us, shaping how we communicate, entertain, transact, vote, and take civic action — not to mention how we are surveilled, scammed, and persuaded. Instead of treating code as something people use to solve de-contextualized problems, we might frame it as a language resource: a resource that computers can process and that people can mobilize to support communication and expression with other humans. As scholar and educator Tom Lynch writes, “software theorists are quite clear on this: like other languages, software is socially constructed, flawed, fickle, and ideological” (Lynch, 2017, p. 165).

In this chapter, we unpack a philosophy about programming that highlights CS’ connections with expression, language, and communication. If we start with the premise that people express and communicate about, with, and through code (Vogel, 2020), then it follows naturally that bi/multilinguals — and all students — already have a lot to contribute and can be more inclusively welcomed into the space.

Communicating About and Around Code: Making Code “Literate”

Many people decide that programming and CS is “not for them” because code itself appears like a jumble of inscrutable white text on a black screen. But there are many ways to make code more readable, supporting experts and novices alike. CS teacher Anjeliqe described how the possibility of making code more accessible is one of her favorite parts of her job:

Let’s return to John’s story to consider how Ms. Kors aimed to make code more readable in her ENL classroom.

Through all of the teaching moves above, Ms. Kors supported John and his peers to represent code and what they hoped it would do for their projects in a way that was easily understandable for the members of this computing community. Students translanguaged with spoken and written Scratch keywords and human language, diagrams, drawings, and role-play. Other CS teachers, like Jennifer, have taken similar approaches:

These types of “unplugged” activities give students opportunities to, as Jennifer described, “get past the fear of what the code will look like.” Students can visualize their thinking in ways that are accessible, motivating, and relevant.

Like John and his classmates, all programmers express themselves about, with, and through code as they engage in broader communities. They use programming languages like Java and C . They write comments in their code, create flow charts and diagrams, post queries on online forums like stackoverflow.com, share meaningful CS projects with the wider world, critique harmful tech on social media, and so much more (Vogel et al., 2020).

The idea of embracing a broad range of language and communication practices has a long history in the field of CS. Prominent computer scientist Donald Knuth coined the phrase literate programming (Knuth, 1984) to emphasize that computer code (programs) are meant to be read and understood by people, not just computers, a stance that we echo here. Knuth advocated that computer scientists should appreciate virtuosic works of programming just like virtuosic works of literature.^[2] He argued that treating programs as not only functional but also expressive creations would allow real progress in CS.

In addition to advocating that coders should be well read in excellent works of programming, Knuth also advocated that programming itself should involve combining human language and computer programming languages in specific ways. Knuth built systems to support a software development process where programmers first specified and refined with others what their programs should do in human language and then gradually refined these drafts to include a combination of executable code and comments. The result was a clear and expressive “literate” program that could be run on the computer and read (or modified) by other people. Thinking about how to make programs literate for all can help reduce perceptions of programming as the domain of an elite few, what has been metaphorically called a programming “priesthood” (Backus, 1980; Doctorow, 2009; Maz, 2017; Nelson, 1973; Sabelli, 1998).

The idea of literate programming helps us understand that coding is a part of a social conversation, one of many ways that we can express and communicate ideas to and with others. This means that coding is not just about correctness but about how ideas are encoded, expressed, and understood in social contexts. Programmers must consider the other people they are in conversation with.

When we understand that computer programs are for people — not just computers — to interact with, we also pay more attention to the ways that language mediates how people learn, solve problems, and collaborate in CS. “Communication about computing” is a core practice identified in the K-12 CS Education Framework (K-12CS.org, 2016). Research has shown that even though students may be able to correctly solve programming problems, if they can’t explain how the solutions work, they may not actually understand what they’ve done (Hoadley et al., 1996). When teachers engage students in talking about computing and pair-programming interactions, they can help develop students’ computational thinking (Grover & Pea, 2013; Israel et al., 2017; Werner & Denning, 2009). Tarek Elabsy, a New York City educator, shared how he works to support students’ understanding through communicating about code:

Social interactions mediated through text comments, code, and tutorials on the Scratch programming platform have been found to support younger students in improving their interactive media projects (Brennan et al., 2011). Similarly, teachers can encourage students to express themselves through multiple modalities such as interviews, drawings, and design journals to show what they know about computing (Brennan & Resnick, 2012), much in the same way that John did in Chapter 12. Attending to students’ language use in conversation about and with code is key to supporting robust CS learning.

Inviting students to not just write programs but also read and engage with programs to make them more “literate” can create space for novices to participate in CS. Just like translanguaging pedagogy, the literate programming philosophy helps educators take an asset-based approach where all of a student’s linguistic resources can be used to develop new literacies: using human language and pseudocode to leverage into executable code.^[3]

Leveraging Code for Expression and Criticality

The literate programming philosophy underscores that computer programs are for people and not just computers — to read and parse. Not only is communicating about and around code integral to sustaining computing communities but people can create through code as its own expressive medium. The assignment John was asked to complete in his ENL class is an example of this.

While many programmers use code for problem-solving (e.g., creating efficient algorithms to sort or search through data), many people who engage in computing, like John, also use code, images, and data for expression and communication. For example:

• The artist Shantell Martin created her own font, Shantell Sans, and shared the story behind how and why she made it on this website.^[4]
• The Women of Color archive uses digital technologies to document and preserve the stories of matriarchs of color.^[5]
• “Unplugged” CS and knitting projects like Dr. Elisabetta Matsumoto’s work with physicists at Georgia Tech and the National Science Foundation funded project Re-Crafting Computer Science (Keune, 2022) bring together code and materials science with ancestral crafting knowledge.^[6]

CS teacher Anjeliqe shared her approach to teaching computing in ways that leverage code for expression:

Revisiting John’s Story

John’s project and the other examples shared in this chapter bring together things that are not traditionally seen as relevant to CS (e.g., refugee journeys, the artistry of handwriting, your abuela’s favorite story, knitting, family heritage practices) with computing to represent people’s ideas in easy-to-understand, aesthetically beautiful, and compelling ways.

In this chapter, we’ve explored how leveraging students’ translanguaging and code as a “literate” language resource can offer bi/multilingual learners a way to express themselves and participate in conversations that involve CS and coding.

But to truly advance equitable practices in CS, we must also examine the nature of the computing conversations that students take part in: What is being discussed in these conversations? Toward what ends? Who is taking part? Who is left out? These questions are ones we explore in Chapter 14.

Reflection Questions:

1. How has code been relevant to your life? How have you used it as a way to express yourself?
2. Which of the strategies from Ms. Kors and her class have you used as part of your coding experiences? Which ones resonate with you as effective to use with students in your context? Why?

Takeaways for Practice:

• Find an existing CS lesson or activity. Evaluate how it provides students with opportunities to communicate about and with code. How could you revise the lesson or activity to better leverage code as a medium of expression?

Glossary

Term	Definition
language repertoire	A collection of resources (e.g., words, sounds, syntaxes, gestures, signs, symbols, objects, and social knowledge about how, when, and where to use those forms ) used to communicate, make sense of the world around us, and learn.
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).
translanguaging	A theory of language that argues that people have one system of language features and practices that they draw on to make meaning, learn, and express themselves. These features and practices defy the named languages (like English, Spanish, etc.) that society has used to categorize language.

References

Backus, J. (1980). Programming in America in the 1950s — Some personal impressions. In N. Metropolis (Ed.), A history of computing in the twentieth century (pp. 125-135). Academic Press. https://doi.org/10.1016/B978-0-12-491650-0.50017-4

Brennan, K., & Resnick, M. (2012, April). New frameworks for studying and assessing the development of computational thinking. In Proceedings of the 2012 annual meeting of the American Educational Research Association, Vancouver, Canada (Vol. 1, p. 25).

Brennan, K., Valverde, A., Prempeh, J., Roque, R., & Chung, M. (2011, June). More than code: The significance of social interactions in young people’s development as interactive media creators. In EdMedia Innovate Learning (pp. 2147-2156). Association for the Advancement of Computing in Education.

Doctorow, C. (2009, 12 March). The high priests of IT — And the heretics. Harvard Business Review. https://hbr.org/2009/03/the-high-priests-of-it

Grover, S., & Pea, R. (2013). Computational thinking in K–12: A review of the state of the field. Educational Researcher, 42(1), 38-43. https://doi.org/10.3102/0013189X12463051

Hoadley, C. M., Linn, M. C., Mann, L. M., & Clancy, M. J. (1996). When, why and how do novice programmers reuse code. In W. Gray & D. Boehm-Davis (Eds.), Empirical Studies of Programmers: Sixth workshop (pp. 109-129). Ablex Norwood.

Israel, M., Wherfel, Q. M., Shehab, S., Melvin, O., & Lash, T. (2017). Describing elementary students’ interactions in K-5 puzzle-based computer science environments using the Collaborative Computing Observation Instrument (C-COI). ICER ‘17: Proceedings of the 2017 ACM Conference on International Computing Education Research (pp. 110-117). https://doi.org/10.1145/3105726.3106167

K-12CS.org. (2016). K-12 Computer Science Framework.org. https://k12cs.org/

Keune, A. (2022). Material syntonicity: Examining computational performance and its materiality through weaving and sewing crafts. Journal of the Learning Sciences, 31(4-5), 477-508. https://doi.org/10.1080/10508406.2022.2100704

Knuth, D. E. (1984). Literate programming. The Computer Journal, 27(2), 97-111. https://doi.org/10.1093/comjnl/27.2.97

Lynch, T. L. (2017). How English teachers will save the future: Reimagining computer science as the language art it is. Journal of English Teaching through Movies and Media, 18(4), 163–180. https://doi.org/10.16875/stem.2017.18.4.163

Maz, A. (2017, 5 December). A priesthood of programmers. Jacobite. https://web.archive.org/web/20171207063309/https://jacobitemag.com/2017/12/05/a-priesthood-of-programmers/

Nelson, T. H. (1973, June 4-8). A conceptual framework for man-machine everything. Proceedings of the National Computer Conference and Exposition – AFIPS ‘73, New York, USA. http://doi.org/10.1145/1499586.1499776

Sabelli, N. H. (1998). We are no longer a priesthood. Communications of the ACM, 41(1), 20-21. http://doi.org/10.1145/268092.268100

Vogel, S. (2020). Translanguaging about, with, and through code and computing: Emergent bi/multilingual middle schoolers forging computational literacies [Doctoral dissertation, City University of New York]. https://academicworks.cuny.edu/cgi/viewcontent.cgi?article=5015&context=gc_etds

Vogel, S., Hoadley, C., Castillo, A. R., & Ascenzi-Moreno, L. (2020). Languages, literacies and literate programming: Can we use the latest theories on how bilingual people learn to help us teach computational literacies? Computer Science Education, 30(4), 420-443. https://doi.org/10.1080/08993408.2020.1751525

Werner, L., & Denning, J. (2009). Pair programming in middle school: What does it look like? Journal of Research on Technology in Education, 42(1), 29-49. https://doi.org/10.1080/15391523.2009.10782540