The social turn in K-12 programming: Moving from computational thinking to computational participation

Abstract

In this conceptual paper, we argue that recent developments in K-12 programming education are suggestive of what can be called a "social turn", a shift in the field in which learning to code has shifted from being a predominantly individualistic and tool-oriented approach to now one that is decidedly sociologically and culturally grounded in the creation and sharing of digital media. We discuss in detail three dimensions of this social turn (1) from writing code to creating applications, (2) from composing "from scratch" to remixing the work of others, and (3) from designing tools to facilitating communities. These three shifts illustrate how the development of artifacts, tools, and communities of programming lead us to move from computational thinking to computational participation. We draw from examples of past and current research, both inside and outside of school, and situate these developments in the context of current discussions around computational thinking, which has become a driving force in revitalizing programming in K-12 curricula and altogether broadening participation in computing.

Full text

The Social Turn in K-12 Programming:
Moving from Computational Thinking to Computational Participation
Yasmin B. Kafai
University of Pennsylvania
Graduate School of Education
Philadelphia, PA
215-746-3468
kafai@gse.upenn.edu
Quinn Burke
College of Charleston
School of Education, Health, & Human Performance
Charleston, SC
843-953-7433
burkeqq@cofc.edu
ABSTRACT
In this conceptual paper, we argue that recent developments in K-
12 programming education are suggestive of what can be called a
“social turn”, a shift in the field in which learning to code has
shifted from being a predominantly individualistic and tool-
oriented approach to now one that is decidedly sociologically and
culturally grounded in the creation and sharing of digital media.
We discuss in detail three dimensions of this social turn—(1) from
writing code to creating applications, (2) from composing from
scratch to remixing the work of others, and (3) from designing
tools to facilitating communities. These three shifts illustrate how
the development of artifacts, tools, and communities of
programming lead us to move from computational thinking to
computational participation. We draw from examples of past and
current research, both inside and outside of school, and situate
these developments in the context of current discussions around
computational thinking, which has become a driving force in
revitalizing programming in K-12 curricula and altogether
broadening participation in computing.
Categories and Subject Descriptors
K.3.0 [Computers & Education]: General
General Terms
Human Factors
Keywords
Novice programming, tools, networked commons
1. INTRODUCTION
More than 30 years ago, Seymour Papert [28] wrote about
computers, children, and powerful ideas promoting the use of
Logo programming for learning about mathematics, complex
ideas, learning communities, and creative expression. However
while Logo grew quite prominent in K-12 schools throughout the
1980s, it literally had disappeared from the curriculum by the
1990s [14]. Schools largely turned away from programming as the
availability of pre-assembled multi-media packages arrived via
glossy CD-Roms. These along with the Internet seemingly
negated the need for learning programming. With such a plethora
of new applications and content just a mouse-click away, who was
still interested in toiling over creating these applications oneself?
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, or
republish, to post on servers or to redistribute to lists, requires prior
specific permission and/or a fee.
Conference’10, Month 1–2, 2010, City, State, Country.
Copyright 2010 ACM 1-58113-000-0/00/0010…$10.00.
Logo’s departure was only further shuttled along by the difficulty
of finding qualified K-12 educators, knowledgeable about
computers and programming, who could highlight the long-term
merits of such “toil” and even make it palpable.
In the last few years, however, we have witnessed a renewed
interest in learning programming in K-12 propelled by several
developments, including the educational initiative to promote
computational thinking [41], a need to broaden participation in the
technology culture at large [25], and perhaps most significantly,
the wider “do-it-yourself” (DIY) reach and ethos of digitally-based
youth cultures [15]. Computers indeed now seem to be accessible
everywhere, particularly outside of school. But with few students
digitally fluent and persistent disparities in participation, it is
crucial that computer science education recognizes its role in
leveraging significant shifts in (a) what students are interested in
programming, (b) the contexts in which they do it, and (c) how
they do it. Broadly speaking, we view these shifts as a social turn,
moving from a predominantly individualistic view of technology
to one that includes a greater focus on the underlying sociological
and cultural dimensions in learning programming, re-
conceptualizing computational thinking as computational
participation.
We see three shifts as the key levers of this social turn. The first
shift, from code to applications, focuses on the emergence of
programming artifacts as the focal point of learning. Learning
programming was once largely considered a task that centered
upon coding accuracy and efficiency as the signifiers of success.
Today however, rather than programming for the sake of
programming, students can create authentic applications such as
games and stories as part of a larger learning community. It is the
quality of these shareable artifacts—a highly playable game, a
sophisticated animation, or a particularly nuanced digital story—
that offers entry to such communities and fosters camaraderie.
This is characteristic of the second major social turn in
programming, from tools to communities, in which coding is no
longer performed as an isolated endeavor but within a shared
social context, utilizing open software environments and mutual
enthusiasm to spur participation. The third shift, from scratch to
remixes, marks the hallmark activity of these new networked
communities. Whereas programs once had to be created “from
scratch” to demonstrate competency, today, seamless integration
via remixing is the new social norm for writing programs. While
this certainly presents particularly ethical challenges, remixing
also offers newfound networks for participation.
The goal of this paper is to review what we know about these
shifts and outcomes from the research literature of educational
programming to inform rationales for the design of programming
tools, applications and environments for learners and to help us
design more appropriate and effective research, interventions, and

assessments. We also hope to demonstrate how these shifts build
on pedagogical ideas of Constructionist learning theory that were
articulated early on in Mindstorms [28], but were subsequently
neglected because of what Papert himself called a “technocentric”
focus, valuing the technology over people and social actions. We
argue that understanding this newly emerging social turn in
programming can help us to generate better ways of how to think
differently about K-12 computing and support the pivotal roles of
context and community in learning [8]. Equally important, these
shifts provide compelling illustrations of computational thinking
[41] in K-12 educational programming. While much attention has
focused on different concepts, practices and perspectives [4] and
dimensions of programming [5], our goal is to connect to a broader
conceptualization of computational thinking that encompasses its
functional, political, and personal purposes [36]. Functional
purposes usually describe the basic skills and concepts that
someone needs to learn in order participate in society; political
purposes captures why understanding these skills and concepts are
relevant in society; personal purposes describe the role that these
skills and concepts plays in building and maintaining relationships.
These various purposes describe the fundamental aspects of any
literacy, whether its reading and writing printed texts, or using and
programming digital media, but they also make clear that when we
talk about computational thinking, we need to understand that
basic concepts and skills are situated within a larger cultural and
personal context of learning and schooling. For that reason, we
begin this review with outlining central ideas of Constructionist
theory that situate these shifts in educational programming.
2. CONSTRUCTIONISM: PERSONAL,
SOCIAL, & CULTURAL DIMENSIONS OF
LEARNING
When Papert wrote Mindstorms in 1980, the term
“Constructionism” had yet to be coined. He [29] later defined it as,
“[C]onstructionism – the N Word as opposed to the V word –
shares Constructivism’s connotation to learning as building
knowledge structures irrespective of the circumstances of learning.
It then adds the idea that this happens especially felicitously in a
context where the learner is consciously engaged in constructing a
public entity whether it’s a sand castle on the beach or a theory of
the universe that can be shared with others”. The idea that
knowledge is represented in a public entity foreshadows the social
as well as the cultural dimensions of Constructionist learning and
their application to learning programming.
2.1 Personal dimensions
Most of Papert’s writings have focused on learning programming
from a personal perspective, very much in the Piagetian tradition.
He saw the engagement with Logo programming as a way to
facilitate the construction of knowledge structures and what he
termed “appropriation” so that learners could make knowledge
their own and begin to personally identify with it. Programming
the Logo turtle very much makes the construct an “object-to-
think-with” [28] linking together artifacts in the physical world (in
this case, a turtle) with those of the digital world (e.g., programs,
robots, and games). Papert argued that objects-to-think-with such
as the Logo turtle are particularly effective at supporting
appropriation, because they facilitate the child’s personal
identification with the object and help to construct, examine, and
revise connections between old and new knowledge. By designing
a program or game (or, on a more granular level, its procedures,
algorithms and data structures) the personal knowledge becomes
public and can then be shared with others. Of course, thinking
about programs as personal objects that can be shared widely as
public entities articulates a phenomenon entirely akin to the
growth of Internet culture, which too is built upon the amassment
of intimately personal items (e.g., photos, stories, and designs)
introduced on an equally massive wider public sphere, taking on
entirely new meanings upon this wider scale.
2.2 Social dimensions
The social dimensions of Constructionist learning have focused on
learning communities, girded by the understanding that personal
construction of programs does not happen in a vacuum but very
much in a social context. Papert’s [28] first-hand experience
researching Brazilian samba schools encapsulated his sense of
social norms and interactions as pivotal to any form of learning:
“[t]hese are not schools as we know them; they are social clubs
with memberships that may range from a few hundred to many
thousands. Each club owns a building, a place for dancing and
getting together. … During the year each samba school chooses its
theme for the next carnival, the stars are selected, the lyrics are
written and rewritten, and the dance is choreographed and
practiced. Members of the school range in age from children to
grandparents and in ability from novice to professional. But they
dance together and as they dance everyone is learning and teaching
as well as dancing. Even the stars are there to learn their difficult
parts” (p. 178). In many ways the proposal of samba schools as an
example of learning culture predates the move away from
traditional schools to apprenticeship learning that was ushered in
years later by Lave and Wenger’s seminal work [23] and then
again in the form of affinity cultures by Gee [11] in the context of
gaming communities.
2.3 Cultural dimensions
Finally, a cultural dimension of Constructionist learning has
focused on the politics that determine how one way of knowing is
valued over others. By studying and interviewing programmers,
Turkle and Papert [39] revealed that the officially promoted “top-
down” planning approach is not always superior to a more
improvised, bricoleur-like approach. The bricoleur style is not a
stepping stone towards more advanced forms of knowledge
construction, but rather is a qualitatively different way of
organizing one’s planning and problem solving. Turkle and Papert
argued that the bricoleur style favoring concrete thought could be
just as advanced as abstract thought and observed that among the
sciences, computer science, prized abstract thinking. It’s not just
the approach but also the programming artifacts that we design
that reflect these values and provide a context for learners to
connect and engage with the practices in the field. The re-
evaluation of the concrete finds today perhaps its most popular
expression in the interest that youth display for learning
programming apps [42] or other digital artifacts illustrating the
complex issues can also be learned in the process of making a
sharable and usable artifact that can situate learning of algorithms,
data structures and other features.
These three dimensions, the personal, social, and cultural, of
Constructionist theory highlight that learning to program, and
learning anything for that matter, is not solely a technical matter of
skills to be mastered. Rather, like Kelleher and Pausch [21] aptly
recognized, the social and cultural barriers to learning
programming are often “harder to address than mechanical ones
because they are harder to identify and some cannot be addressed
through programming systems” (p. 132) alone.

3. THE SOCIAL TURN IN K-12
PROGRAMMING
The following three dimensions highlight how learning
programming has shifted with the wider cultural perceptions and
practices of what it is to socialize and produce in the 21st century
and how this relates to computational thinking, resulting as we
argue in better learning opportunities and, by extension, better
teaching opportunities.
3.1 From code to applications
Learning to program is about writing code, developing algorithms,
data and control structures that result in functional, if not, efficient
programs. We have numerous studies of what students learn about
syntax, control structures, conditionals, and recursion as well as
data structures and variables while writing code, just as we have
documentation on the connected challenges of learning to do so
[38]. While much planning and problem solving went into these
programs, there was also prompt criticism [30] that the empirical
evidence was slim in demonstrating exactly what students were
learning and how such learning transferred to other subjects.
Others also noticed a lack of integration with the rest of the school
curriculum [27]. In its initial foray into K-12 schools,
programming largely existed as a stand-alone activity which
students would participate in once or twice a week for an hour at a
time. And typically, these isolated moments of coding existed
apart from classrooms within the computer lab after which the
students were return to their “normal” classes back down the
hallway.
On the tail end of this development, a new pedagogical approach
to programming emerged, called instructional software design
[12]. Rather than simply composing code, students designed full-
fledged software applications. This approach was inspired by
writings that saw design practices as contexts that could promote
open-ended forms of problem solving and situate learners in the
application of academic content in the design of meaningful,
authentic applications [35]. Harel’s seminal study not only
illustrated that treating students as designers of instructional
mathematics software could make them manifestly more invested
in their learning, but also helped the students learn programming
and mathematics significantly better than students in control
classes. The instructional software design approach has since then
successfully applied to other contexts such as game design [17]
and integrated with other school subjects such as language arts [6],
science [7], as well as music and art [10]. By leading with a
particular project within a particular subject matter, be it digital
stories in an English class or fraction games in a math course,
programming pedagogy engages children with the potential to
create “real-world” applications. It also builds on successful
instructional practices in which educators can leverage content-
based subject matter with what students already know informally
to design software that is meaningful and authentic beyond the
classroom [3].
Today, the surge of “app” design courses [42] is a testament to the
recruiting pull of such applied programs and ought to be leveraged
more intently for broadening participation. It widens the walls [33]
in suggesting applicability of programming to a range of activities
rather than just narrow technical ones. More broadly speaking,
designing applications can also be considered a direct and, more
importantly, an accessible application of Wing’s computational
thinking [41]. It captures key aspects of designing systems, solving
problems and understanding human behaviors because designing
an application like a game or simulation involves the creation of a
system, albeit on a smaller scale, that requires the designers to
think carefully about how users will interface with the applications
they design as well as solve problems of how to implement
features according to their intentions. On a personal level, the idea
of designing applications has most likely generated the broadest
interest and success rate in getting youth actually interested in
computer programming. Perhaps this is why making games for
learning has received such widespread attention with so many
programs, for-profit and non-profit alike, vying for children’s
attention. This sense of empowerment, personal as well as
political, that one can make what one uses is also related to
premises of self-reliance that drive the wider DIY movement that
has witnessed a boon since the advent of Web. 2.0.
3.2 From programming tools to communities
Many efforts have focused on helping novice programmers to
become more fluent and expressive with new technologies by
developing programming tools [21]. In particular, addressing
issues such as syntax problems have been simplified by using
visual programming languages that reduce the amount of typing,
or arranging control structures by providing linkages between
different levels [38]. Particularly popular have been construction
tool kits such as Scratch [34] or Kodu have focused on facilitating
the programming of different multimedia applications to create
games, animations and music videos, whereas others such as Alice
[22] have focused on applications that engage in storytelling by
providing characters from the popular program The Sims or have
designed tools such as Agentsheets [32] to facilitate the creation of
simulations. Both inside and outside of schools tools like these
have been successful in lowering the floors of entering into
programming. The design of computational construction kits has
generated rich insights into how to make programming accessible
for beginners and support many styles and interests [33].
One of the primary attractions for youth in creating applications
rather than simply generating code is the capacity to share such
applications with others and gain status by these shared creations.
For instance, early use of the Scratch tool in a Computer
Clubhouse illustrated how a vibrant game design community
emerged over the course of two years with hundreds of different
games developed [20]. The recent creation of Internet-based
sharing sites has expanded the tool users into communities of
designers. The most prominent example is the Scratch site, one of
the largest youth programming communities that was inspired in
part by Seymour Papert’s samba schools. It is an online
community for youth to create and share stories, games, and
animation with over one million registered users, primarily
between the ages of 8 and 16. Scratch collaborative activities
typically revolve around the production of particular types of
projects in which dozens of members can participate bringing
different skills such as music, graphics or editing to the group [1].
More importantly, it builds on essential insights from educational
research that fruitful learning is not done in isolation but in
conjunction with others. While some early work by Webb [40]
examined some of the challenges as well as opportunities in
having students program in small teams, programming in K-12
contexts is still mostly an individual activity. One of the perhaps
most successful collaborative designs has been the introduction of
pair programming that is now widely practiced on grade levels K-
16 because it has shown to be effective in helping and motivating
beginning programmers [9].
Today programming and design tools such as Alice, Gamestar
Mechanic, and Kodu all include communities, creating open
source sites in the style of communities like Linux for youth to
share, comment on, and contribute to their coded creations. While

such communities have always existed—the pre-Internet Logo
community is testament to that—with access to sharing programs
online and finding like-minded peers and others, even novice
programmers now have an audience that values their artifacts and
thus provides a community or affinity group. Designing tools that
facilitate particular mechanics of programming is not enough.
Rather, providing a social context in which these programming
tools are used and where programming artifacts are shared is
equally important. It suggests that how we engage beginners in
programming can be a collaborative activity. Learning how to
program collaboratively brings other elements of computational
thinking into the foreground such as decomposing a complex task
and coordinating control flow between different components. In
addition, we can also use computational thinking as a way for
participants to parse the networked commons itself. Many data
mining tools rely on algorithms to search for and extract patterns
from interactions and behaviors in massive communities.
Likewise, tools like crowd-sourcing not only leverage feedback
from others but also need to be understood in how those can be
used more effectively to not only gauge wider opinion but also
promote greater efficiency and reliability in applied programming
activities.
3.3 From scratch to remix
In the past, not only did most programs have to be created “from
scratch” (no pun intended!) to illustrate programming
competencies, but the expectation was that code was very much a
proprietary commodity, to be built and ever-refined but certainly
not freely shared. This mindset very much set the tone for early
computing coursework as children were introduced to the potential
of programming in terms of text-based functionality, akin to
learning about fiction in a language arts course by being taught the
meaning of nouns, verbs, and modifiers. The idea however to
design programs on existing building blocks is by no means a new
concept. Traditionally, as part of instruction, beginning
programmers are given pieces of code to modify for their own
programs and this allows novices to build far more complex
designs than they could do their own. But the concept of
repurposing code has taken on a new life through the Internet,
mirroring prominent remix practices in digital media culture.
Today, the repurposing and remixing of code has become standard
practice. It has been argued that remixing is a key practice in
today’s networked culture in support of our knowledge production
[16]. Crediting ownership consists of referencing the intellectual
origins of “text” used in media productions, be it graphics,
animations or music. Remixing is also a particular form of
participation within the Scratch community, taking existing
Scratch projects and changing them before uploading them back to
the website. With nearly 25% of the 3 million project posted at the
Scratch site as remixes, members use the practice as means to
familiarize oneself with the software as well as to socialize and
collaborate with others via their creations [26] and this number has
been steadily increasing since its launch. In some instances,
authors design programs and explicitly invite others to remix their
cod, thus using programs as design-starters whereas in other cases
remixes can range from direct copying to small tweaks of code or
simply serve as inspiration for new, very different programs.
Indeed, the culture of remixing in Scratch itself is not without
fraught as positive and negative comments are prevalent as evident
in previous attempts to introduce the practice within school-based
environments. In an after-school club, Scratch programmers ages
10-12 years were adamant that their fellow programmers credited
the origins of programs that they had remixed and posted online.
Scratch programmers initially were concerned about others taking
their programs, but they soon came to understand the remixes as a
form of recognition that represented attention they received from
others [19]. The issue of intellectual ownership looms large in
discussion even among youth scratch members, from feeling
complimented for the attention to distraught of the seeming lack of
acknowledging the sources of work.
It’s perhaps the aspect of computational thinking that raises the
most interesting intersection of technical and social issues because
what’s prevalent in amateur creators cultures such as Scratch
might not be considered appropriate in school contexts that value
individual authorship and explicitly would consider remixing a
violation of their policies. A growing number of media theorists
and educators posit remix as very much a new literacy that schools
need to address [31]. In fact, school’s traditional conception of
“copying” sits directly at odds with the wider culture of remix that
prevails in children’s interactions outside of school. While
remixing on the most basic level requires just a few mouse-clicks
to copy programs and thus would be a hard-sell for any
consideration of computational thinking, we do know that selective
remixing can actually require a far more degree of sophistication.
Considering what to modify in selected code segments versus what
to keep and where to add or delete procedures or variables within a
program are examples of remixing activity that very much requires
a deeper, functional understanding of the code, and in some
instances remixing here may very well be more complex than
starting with a blank slate. On a political level, the issues of
copyright in the digital domain (and this extends to code as well as
interfaces) present a highly complicated matter that is only in the
process of being defined in light of new cultural practices [24].
Personally, for many youth, this is a complex issue to deal with.
The remixing dilemma—the difficulty to promote both originality
and generativity in projects—suggests that remixing can serve as
an opportune case for critically understanding copyright issues and
thus address the wider social implications of computational
thinking, which too often get neglected in the overt focus on
technical prowess.
4. DISCUSSION
We painted in broad strokes here a social turn in K-12 educational
programming community to emphasize that engaging with
computational thinking at large, and with programming in
particular, is not solely individual act but should be thought of as a
social practice. Programming applications are increasingly being
developed in order to design artifacts of genuine significance for
others. Programming in a community suggests that such
significance ultimately lies in the fact that we design to share with
others. Remixing code suggests that we build on the work of
others and need to understand the ramifications of this. Most
importantly, in the context of computational thinking, this means
that we need to move beyond seeing programming as an
individualistic property but rather begin to understand it as a
communal practice steeply grounded in how we think about what
students today should learn in order to be functional participants in
their respective communities. Who defines what is relevant at
these communal spaces and how does this contribute to an
individual’s personal development? Computational thinking
should really be thought of computational participation to
emphasize that “objects-to-think-with”—to use one of Papert’s key
ideas—are indeed “objects-to-share-with” others.
Of course, just by having kids program applications, placing them
in groups, and encouraging them to remix code hardly addresses
all of the problems that have faced efforts in broadening
participation in computing. In fact, a renewed focus on

communities of programming likely will present whole new issues
of implementation when it comes to integrating into schools. This
move toward membership in a large-scale community is a complex
interplay between how young software designers develop personal
agency through programming and how they gain status as
“experts” amongst their peers. For instance, we followed two 12-
year old participants, Lucetta and Matthew, as they learned the
programming software Scratch and then joined the corresponding
website both in an after-school club and in a class as part of a four-
month long ethnographic study [19]. We found that participating
in the online community furthered both Lucetta and Matthew’s
membership in a programming community in different ways.
Lucetta friended other users, commented on projects, and uploaded
her own projects, taking advantage of the social aspects. This fit
her cooperative social style. In contrast, while Matthew embraced
the potential of remixing, he never developed the confidence to
embrace other aspects of participation such as sharing his own
project for feedback from the community.
These vignettes of early participation in the Scratch community
illustrate that as educators and researchers design and study K-12
programming communities, they need to focus not just on
participation but also on how novice participants both opt to
participate and have opportunities to do so. This issue of equity in
participation, is of course not a new one. On a basic level the
classrooms that builds around software design or game activities
always formed communities where students engaged in the forms
of peer pedagogy often observed in large online networks [2]. But
what’s different now is that these large-scale communities now
connect hundreds, if not thousands, of young programmers. How
we can design communities around tools such as Scratch, Alice or
Kodu that can be done both online and offline, in the local
classrooms and clubs as well as from home? Addressing these
various contexts is of course no small feat and points toward
making these massive online sites more modular, in which
members can access those sections and communities that they find
particularly interesting and compatible to their learning
environment(s).
Furthermore, we need to broaden our array of applications. Some
have argued that joining the “existing” clubhouse like you would
find in the Scratch community, still leaves many outside. Indeed,
in terms of Scratch online, only 37% of its members are girls.
Rather than just to focus on games and animations, we also need to
further encourage stories and perhaps even introduce different
materials and contexts. New directions in tangible construction kits
suggest that new clubhouse can be build that serve other members
rather than getting them to join the existing ones. Equally
important, further emphasizing this shift to computational
participation is that we need to recognize programming as a
collaborative, distributed effort. While bearing similarities to
collaborative groups found in many assigned classrooms, what
distinguishes these types of online collaboratives from regular
groups is that they are self-organized with flexible roles. For
instance, in the Scratch online community collaborative activities
typically revolve around the production of particular types of
Scratch projects by a small group of individuals that have
commonly met one another in the online environment. One study
focused on observations of a small collaborative group within the
Scratch community called “Gray Bear Productions” that had
formed spontaneously on the Scratch website by three children
ages 8, 13, and 15 [1]. Over time, this group expanded and was
later joined by over a dozen other members. They posted their
projects on a gallery and members voted on which projects to
further develop since each member brought different skills such as
music, graphics or editing to the group. Based on an analysis of
comments on the gallery as well as a survey, researchers observed
that collaborative groups do more than just getting the job done;
rather, they can also provide social and emotional support. This
seemingly minor point has larger implications, reinforcing that
even online fruitful learning is not done in isolation but in contact
and conjunction with others.
From our vantage point, these developments provide clear
directions for the design of activities, tasks, tools and communities
in K-12 educational computing efforts that are aimed at
broadening participation in and perceptions of computing on a
considerably larger scale than previous attempts of integration in
the past. We are not arguing that all the standard staples of
traditional computer science courses should be dismissed or will
simply go away. The merits of writing code to learn about the
nature of algorithms, and developing data structures, compilers
and general architecture remain crucially important. But we want
to make the case that K-12 educational computing can take the
road that mathematics and science education have taken long ago
and leverage with success the insights gained from youth digital
media and networked culture in conjunction with learning theory
that initially promoted the idea of children programmers against all
conventional wisdom.
5. ACKNOWLEDGEMENT
The writing of this paper was supported by a grant from the
National Science Foundation (NSF-CDI-1027736) to Mitchel
Resnick, Yasmin Kafai, and Yochai Benkler. The views expressed
are those of the authors and do not necessarily represent the views
of the Foundation, University of Pennsylvania, or College of
Charleston.
6. REFERENCES
[1] Aragon, C., Poon, S, and Monroy-Hernandez, A. 2009. A
tale of two communities: Fostering collaboration and
creativity in scientists and children. In Proceedings of the 7th
ACM Conference on Creativity and Cognition, (Berkeley,
CA, October 27-30). ACM, New York, NY, 9-18.
[2] Benkler, Y. 2006. The Wealth of Networks: How Social
Production Transforms Markets and Freedom. New Haven,
CT: Yale University Press.
[3] Bransford, J., Brown, A., and Cocking., R. 2000. How People
Learn. Washington, DC: National Academy Press.
[4] Brennan, K., & Resnick, M. (2012). New frameworks for
studying and assessing the development of computational
thinking. Paper presented at the 2012 Annual Meeting of the
American Educational Research Association (Vancouver,
Canada, April 13-17).
[5] Brown, A., Allan, W., Coulter, B., Denner, J., Erickson, J.,
Lee, I., Malyn-Smith, J., and Martin, F. (2010).
Computational thinking for youth. White Paper for the ITEST
Small Working Group on Computational Thinking (CT).
[6] Burke, Q. and Kafai, Y.B. 2012. The writers’ workshop for
youth programmers. In Proceedings of the 43rd SIGCSE
Technical Symposium on Computer Science Education,
(Raleigh, NC February 29-March 03), ACM, New York, NY,
433-438.
[7] Ching, C., Kafai, Y., and Marshal, S. 1998. Give girls some
space. In Proceedings of World Conference on Educational
Multimedia, Hypermedia, and Telecommunications (pp. 56-
62). Chesapeake, VA: AACE.

[8] Cole, M. (2005). Cross-cultural and historical perspectives on
the developmental consequences of education. Human
Development, 48, 4, 195-216.
[9] Denner, J. and Werner, L. 2007. Computer programming in
middle school: How pairs respond to challenges. Journal of
Education Computing Research, 37, 2, 131-150.
[10] Gargarian, G. 1996. The art of design. In Y.B. Kafai, & M.
Resnick (Eds.), Constructionism in Practice: Designing
Thinking, and Learning in a Digital World (pp. 125-160).
Mahwah, NJ: Lawrence Erlbaum.
[11] Gee, J. 2003. What Video Games Teach Us about Learning
and Literacy. New York, NY: Palgrave.
[12] Harel, I. 1991. Children Designers: Interdisciplinary
Constructions for Learning and Knowing Mathematics in a
Computer-rich School. Norwood NJ, Ablex Publishing.
[13] Harel, I., and Papert, S. 1990. Software design as a learning
environment. Interactive Learning Environments, 1, 1–32
[14] Noss, R. & Hoyles, C. 1996. Windows on Mathematical
Meanings: Learning Cultures and Computers. Norwell, MA:
Kluwer Academic Publishers.
[15] Ito, M., Baumer, S., Bittanti, M., boyd, d., Cody, R., Herr, B.,
Horst, H. A., Lange, P. G., Mahendran, D., Martinez, K.,
Pascoe, C. J., Perkel, D., Robinson, L., Sims, C., and Tripp,
L. 2009. Hanging Out, Messing Around, Geeking Out: Living
and Learning with New Media. Cambridge, MA: MIT Press.
[16] Jenkins, H. Clinton, K., Purushotma, R., Robison, A., &
Weigel, M. (2006). Confronting the challenges of
participation culture: Media education for the 21st century.
White Paper. Chicago, IL: The John D. & Catherine T.
MacArthur Foundation.
[17] Kafai, Y. B. 1995. Minds in Play: Computer Game Design as
a Context for Children’s Learning. Mahwah, NJ: Lawrence
Erlbaum.
[18] Kafai, Y. B. 2005. The classroom as living laboratory:
Design-based research for understanding, comparing, and
evaluating learning science through design. Educational
Technology, 45, 28–33.
[19] Kafai, Y., Fields, D., and Burke, W. 2010. Entering the
clubhouse: Case studies of young programmers joining the
online Scratch communities. Journal of Organizational and
End User Computing. 22, 1, 21-35.
[20] Kafai, Y., Peppler, K.A., & Chapman, R. (Eds.). (2009). The
Computer Clubhouse. Creativity and Constructionism in
Youth Communities. New York, NY: Teachers College Press.
[21] Kelleher,C. and Pausch, R. 2005. Lowering the barriers to
programming: A taxonomy of programming environments
and languages for novice programmers. ACM Computing
Surveys, 37, 2, 83-137.
[22] Kelleher, C. and Pausch, R. 2007. Using storytelling to
motivate programming. Communications of the ACM, 50, 7,
58-64.
[23] Lave, J., and Wenger, E. 1991. Situated Learning: Legitimate
Peripheral Participation. Cambridge, England: Cambridge
University Press.
[24] Lessig, L. 2008. Remix: Making Art and Commerce Thrive in
a Hybrid Economy. New York: Penguin Press.
[25] McGrath-Cohoon, J. and Asprey, W. (Eds.). 2006. Women
and Information Technology: Research on Under-
representation. Cambridge, MA: MIT Press.
[26] Monroy- Hernández, A. and Resnick, M. 2008. Empowering
kids to create and share programmable media. Interactions,
15, 2, 50-53.
[27] Palumbo, D.B. 1990. Programming language/problem-
solving research: A review of relevant issues. Review of
Educational Research, 60, 1, 65–89.
[28] Papert, S. 1980. Mindstorms: Children, Computers, and
Powerful Ideas. New York, NY: Basic Books.
[29] Papert, S. and Harel, I. 1991. Situating Constructionsim.
Norwood, NJ: Ablex Publishing.
[30] Pea, R.D. and Kurland, D.M. 1983. Logo programming and
the development of planning skills. Center for Children &
Technology. New York, NY: Bank Street College.
[31] Perkel, D. 2008. “No I don’t feel complimented”.. Digital
Youth Research, (February 6). Available at
http://digitalyouth.ischool.berekley.edu/node/105.
[32] Repenning, A. and Ioannidou, A. 2008. Broadening
participation through scalable game design. In SIGCSE ’08
Proceedings of the 39th SIGCSE Technical Symposium on
Computer Science Education (Portland, OR, March 12-15),
ACM, New York, NY, 305-309.
[33] Resnick, M. and Silverman, B. 2005. Some reflections on
designing construction kits for kids. In Proceedings of the
2005 Conference on Interaction Design and Children,
IDC’05 (Boulder, CO, June 05-08), ACM, New York, NY,
117-122.
[34] Resnick, M., Maloney, J., Hernández, A. M., Rusk, N.,
Eastmond, E., Brennan, K., Millner, A. D., Rosenbaum, E.,
Silver, J., Silverman, B., and Kafai, Y.B. 2009. Scratch:
Programming for everyone. Communications of the ACM, 52,
11, 60-67.
[35] Schön, D. A. (1983). The Reflective Practitioner. New York,
NY, Basic Books.
[36] Scribner, S. (1984). Literacy in three metaphors. American
Journal of Education, 93, 1, 6-21.
[37] Shaffer, D. W. and Resnick, M. 1999. Thick authenticity:
New media and authentic learning. Journal of Interactive
Learning Research, 10, 2, 195-215.
[38] Soloway, E., Guzdial, M., and Hay, K. 1994. Learner-
centered design: The challenge for HCI in the 21st century.
Interactions, 1, 22, 36-48.
[39] Turkle, S. & Papert, S. 1990. Epistemological pluralism:
Styles and voices within the computer culture. Signs, 16,1,
128-157.
[40] Webb, N. 1980. A process-outcome analysis of learning in
group and individual settings. Educational Psychologist, 15,
69-83.
[41] Wing, J.M. 2006. Computational thinking. Communications
of the ACM, 49, 3, 33-35.
[42] Wolber, D., Abelson, H., Spertus, E. and Looney, L. 2011.
App Inventor: Create Your Own Android Apps. Sebastopol,
CA: O'Reilly Media.