Principles of Computational Thinking Tools

Abstract

Computational Thinking is a fundamental skill for the twenty-first century workforce. This broad target audience, including teachers and students with no programming experience, necessitates a shift in perspective toward Computational Thinking Tools that not only provide highly accessible programming environments but explicitly support the Computational Thinking Process. This evolution is crucial if Computational Thinking Tools are to be relevant to a wide range of school disciplines including STEM, art, music, and language learning. Computational Thinking Tools must help users through three fundamental stages of Computational Thinking: problem formulation, solution expression, and execution/evaluation. This chapter outlines three principles, and employs AgentCubes online as an example, on how a Computational Thinking Tool provides support for these stages by unifying human abilities with computer affordances.

Full text

Innovations in Instructional Design, Learning Environments, and Performance Technologies
PRINCIPLES OF COMPUTATI O NA L TH INK ING
TOOLS
Authors
Alexander Repenning, School of Education, University of Applied Sciences Northwestern,
Switzerland
Ashok R. Basawapatna, Dept. of Mathematics and Computer Information Systems, SUNY Old
Westbury, USA
Nora A. Escherle, School of Education, University of Applied Sciences Northwestern, Switzerland
Abstract
Computational Thinking is a fundamental skill for the 21st century workforce.
This broad target audience, including teachers and students with no programming
experience, necessitates a shift in perspective towards Computational Thinking
Tools that not only provide highly accessible programming environments, but
explicitly support the computational thinking process. This evolution is crucial if
Computational Thinking Tools are to be relevant to a wide range of school
disciplines including STEM, art, music and language learning. Computational
Thinking Tools must help users through three fundamental stages of
Computational Thinking: problem formulation, solution expression and
execution/evaluation. This chapter outlines three principles, and employs
AgentCubes Online as an example, on how a Computational Thinking Tool
provides support for these stages by unifying human abilities with computer
affordances.
draft

Repenning, Basawapatna, Escherle – 2
Page 2 of 25
Keywords
Computational thinking process: thinking with computers;
Three stages of computational thinking process: abstraction, automation, analysis;
Computational thinking tool: support for all three stages of the computational
thinking process;
Principles of computational thinking tools.

Computational Thinking Tools – 3
Page 3 of 25
PRINCIPLES OF COMPUTATI O NA L TH INK ING
TOOLS
Introduction
The term Computational Thinking (CT), popularized by Wing (Jeannette M.
Wing, 2006), had previously been employed by Papert in the inaugural issue of
Mathematics Education (Papert, 1996). Papert considered the goal of CT to forge
explicative ideas through the use of computers. Employing computing, he argued,
could result in ideas that are more accessible and powerful. Meanwhile, numerous
papers, e.g., (Grover & Pea) and reports, e.g., (National Research Council, 2010)
have created many different definitions of CT. Recently, Wing followed up her
seminal call for action paper with a concise operational definition of CT
(Jeannette M. Wing, 2014): “Computational thinking is the thought processes
involved in formulating a problem and expressing its solution(s) in such a way
that a computer—human or machine—can effectively carry out.”
While the term Computational Thinking is relatively new, the process implied by
Wing can be recognized as a computationally enhanced version of the well-
established scientific method. Based on Wing’s definition the Computational
Thinking Process (Figure 1) can be segmented into three stages. The example in
Figure 1 of a mudslide simulation is used to illustrate the three Computational
Thinking Process stages.

Repenning, Basawapatna, Escherle – 4
Page 4 of 25
(1) Problem formulation (abstraction): Problem formulation attempts to
conceptualize a problem verbally, e.g., by trying to formulate a question such
as “How does a mudslide work?,” or through visual (Arnheim, 1969) thinking,
e.g., by drawing a diagram identifying objects and relationships.
(2) Solution expression (automation): The solution needs to be expressed in a
non-ambiguous way so
that the computer can
carry it out. Computer
programming enables
this expression. The rule
in Figure 1 expresses a
simple model of gravity:
if there is nothing below
a mud particle it will
drop down.
(3) Execution & evaluation
(analysis). The computer
executes the solution in ways that show the direct consequences of one’s own
thinking. Visualizations—for instance the representation of pressure values in
the mudslide as colors—support the evaluation of solutions.
As shown in Figure 1, Computational Thinking is an iterative process describing
thinking with computers by synthesizing human abilities with computer
affordances. The three stages describe different degrees of human and computer
Figure 1. Three stages of the Computational
Thinking Process

Computational Thinking Tools – 5
Page 5 of 25
responsibilities. The solution execution appears to be largely the responsibility of
the computer and the problem expression largely the responsibility of the human.
Although problem formulation is typically considered the responsibility of the
human, computers can help support the conceptualization process as well, for
instance, through facilitating visual thinking.
Principles of Computational Thinking Tools
The fundamental goal of a Computational Thinking Tool is to support all stages
of the Computational Thinking process outlined above. Programming should be,
and can be, an exciting new literacy in the sense described by DiSessa (A.
diSessa, 2000) enabling constructivist learning for all (Yager, 1995). Using
traditional programming languages severely limits this practice outside of
Computer Science class contexts. For example, a student in a STEM class
attempting to make a basic predator prey simulation with traditional programming
languages may have to write hundreds of lines of code. Conversely, the goal of
Computational Thinking Tools leads to three core principles corresponding to the
three stages of the CT process. Computational Thinking Tools should:
(1) support problem formulation. Similar to playing with numbers in a
spreadsheet, using a mind map tool, or just doodling on a whiteboard,
Computational Thinking Tools should empower users to explore
representations without the need to code.
(2) support solution expression. Computational Thinking Tools should employ
end-user programming approaches (Lieberman, Paternò, & Wulf, 2006;

Repenning, Basawapatna, Escherle – 6
Page 6 of 25
Repenning, 2001), to allow computer users who may not have or may not
want to gain professional programming experience, to create relevant
computational artifacts such as games (Repenning et al., 2015) and
simulations (Repenning, 2001).
(3) support solution execution & evaluation. Computational Thinking Tools
should include accessible execution visualization mechanisms helping users to
comprehend and validate computational artifacts such as simulations.
The AgentCubes online end-user programming environment (Ioannidou,
Repenning, & Webb, 2009; Repenning, 2013b; Repenning & Ioannidou, 2006;
Repenning et al., 2014) will be employed as an example to illustrate these
principles, but these principles can be applied to any C.T. Tool. The AgentCubes
user interface is relatively simple. The tool bar at the top of Figure 3a provides a
number of controls to start/stop a simulation, to manage worlds and to operate the
3D camera. The panel to the left contains all the user-defined agents. The top
panel is the current world. The three bottom panels contain the drag and drop-
programming environment with the conditions palette to the left, the agent
behavior in the middle and the palette of actions to the right. The following
sections discuss the three Computational Thinking Tool principles and provide
concrete examples through AgentCubes.
Supporting Problem Formulation
Problem formulation is a conceptualization process (Repenning et al., 2015)
dealing with abstractions often based on verbal or visual thinking, which can be

Computational Thinking Tools – 7
Page 7 of 25
supported by tools. Computational Thinking Tools can support visual thinking by
offering various evocative spatial metaphors. Mind map tools capture concepts as
nodes and links (Willis & Miertschin, 2005). Spreadsheets (B. A. Nardi & Miller,
1990) are two-dimensional grids containing numbers and strings. The versatile
nature of grids has helped spreadsheets to become the world’s most used
programming tools. Tools such as Boxer (A. A. diSessa, 1991) and ToonTalk
(Kahn, 1996) employ the notion of microworlds based on containers to represent
relationships. In Logo, Papert argues, the notion of a turtle helps users
comprehend difficult geometric transformations through body syntonicity (Papert,
1993), that is, the ability for people to project themselves, as turtle, into geometric
microworlds. Papert (Papert, 1993) and Turkle (Turkle, 2007) consider the use of
evocative objects to think with as a powerful conceptualization approach. All
these tools help the forging of abstractions serving as the beginning of a path from
problem formulation to solution expression. Wing suggests that finding these
kinds of abstractions is an essential part of computational thinking (J.M. Wing,
2008): “In working with rich abstractions, defining the ‘right’ abstraction is
critical. The abstraction process—deciding what details we need to highlight and
what details we can ignore—underlies computational thinking.”
Abstractions need to be made explicit to enable transfer. Ideally, Computational
Thinking Tools should not only support users to find rich, evocative abstractions
but also make these abstractions explicit in order to facilitate their transfer and
application within other problem solving contexts. For instance, the use of
phenomenalistic (Michotte, 1963) abstractions describing object interactions such

Repenning, Basawapatna, Escherle – 8
Page 8 of 25
as collision and diffusion, was
found to support student
formulation of STEM
simulations in middle school
curricula (Koh, Basawapatna,
Bennett, & Repenning, 2010;
Repenning et al., 2015). In our
research, the patterns found to be
especially helpful in allowing
students to create elements of
games and simulations we
termed Computational Thinking Patterns (CTPs). Figure 2 lists examples of
Computational Thinking Patterns. For example, the collision CTP describes both
the interaction of a truck hitting a frog in a Frogger-like game or the interaction of
molecules colliding in a STEM simulation. Similarly the generate CTP could
describe a ship shooting lasers in a Space Invaders type game but also two foxes
mating and creating offspring in a predator prey simulation. Learning these CTPs
provides students with a useful high-level language to begin thinking about a
problem before coding begins and previous research has shown that novice users
can recognize these patterns across contexts and implement them in their project
creations (Ashok Basawapatna, 2011).
How AgentCubes supports problem formulation. AgentCubes online supports the
problem formulation stage similarly to a mind map tool by enabling users to
•Change: One agent changes into another
agent.
•Absorb: One agent makes another agent
disappear.
•Transport: One agent transports another
agent.
•Push: One agent pushes another agent.
•Random Movement: An agent moves
randomly.
•Tracking: One agent chases another
agent.
•Keyboard Movement: keyboard button
presses control an agent’s movement.
•Directional Movement: An agent moves
Figure 2. Examples of Computational Thinking
Patterns

Computational Thinking Tools – 9
Page 9 of 25
organize information visually setting the stage for coding. At the problem
formulation stage, AgentCubes online can be used much like a white board is
used for drawing. The 2D or 3D objects, called agents, created by users are
similar to Papert’s objects to think with (Papert, 1993). In AgentCubes,
information can be organized in 3D space to create 3D worlds. Similar to
Minecraft, users create one, two or three dimensions grids and stacks by placing
agents using the pen tool (Repenning et al., 2014). At this stage no coding is
necessary. Users can explore their worlds by employing 3D camera tools to
navigate or manipulate their worlds by adding, removing, and rearranging agents.
AgentCubes allows users to select any agent and assume its perspective by
switching to first person camera mode. This ability, we speculate, may help to
achieve the body syntonicity (Repenning & Ioannidou, 2006) that Papert is
referring to.
Visual thinking is supported by AgentCubes online through a four dimensional
grid structure called the agent matrix (Figure 3). The grid is based on cells
organized as rows, columns and layers. Each cell, in turn, contains a stack of
agents. Agents can be simple textured shapes such as cubes, spheres or cylinders
but can also be quite sophisticated user-created 3D shapes implemented as
inflatable icons (Repenning et al., 2014). Users’ ability to produce their own 3D
shapes has been
identified as an important
creativity tool to
overcome affective
Figure 3. AgentCubes online environment depicting a
side view of an example “Flabby Bird 3D” game

Repenning, Basawapatna, Escherle – 10
Page 10 of 25
challenges of programming, but it can also be useful to quickly sketch out 3D
worlds similar to the use of a cocktail napkin in the formulation stage depicted in
Figure 1.
As an example, an interesting problem could be how to generalize a 2D side
scrolling game into a 3D scrolling game. In Figure 3, the grid has been enabled to
show the AgentCubes cell structure of a game called “Flabby Bird 3D”, which is
a generalization of the popular 2D scrolling phone game “Flappy Bird.” In Flabby
Bird 3D, it is the objective is to navigate a bird called Flabby past oncoming
cubes. Usually, a player would see this
game from the first person camera
viewpoint of Flabby (Figure 4). The
enabled grid helps to reveal the 3D
scrolling approach of the game. To the
right there is a solid wall of cube
maker agents creating cubes (an
example of the generate CTP) with an
increasing probability depending on
the level of the game. These cubes are flying towards Flabby as depicted in Figure
4. Playing the game, by seeing it from Flabby’s point of view, the player gets the
illusion of flying through a never-ending labyrinth of walls. To make the game
more challenging, the approaching walls reconfigure occasionally.
Figure 4. First person view perspective of
the “Flabby Bird 3D” game

Computational Thinking Tools – 11
Page 11 of 25
Breaking down game descriptions into explicit abstractions enables students to
transition from problem formulation to solution expression (Repenning et al.,
2015). Computational Thinking Patterns serve as framework of useful
abstractions describing the interactions between objects and the interaction of
users with objects. For instance, the creation of Flabby Bird involves the
implementation of various Computational Thinking Patterns such as collision,
generation, absorption and keyboard control. Part of the support structure for this
activity is external. For instance, some teachers hang up posters describing the
Computational Thinking Patterns and make students refer to these posters when
working on problem formulation tasks. However, it is essential that the
Computational Thinking Tool provides for a solution expression that is an
intuitive implementation of the problem formulation. It should be noted that this
step can be fully integrated into the tool itself. For example, tools that allow users
to program agents directly, through Computational Thinking Patterns, have
successfully been piloted in the past, further bridging the act of problem
formulation with solution expression (Basawapatna, Repenning, & Lewis, 2013).
Supporting Solution Expression
The goal of Computational Thinking is to be an instrument for problem solving
that is not limited to computer scientists or professional programmers. For
example, assuming an educational context, such as STEM classes, Computational
Thinking Tools need to be viable in non-computer science classes by avoiding the
need for difficult and excessive coding. CT employing traditional programming
tools is likely to introduce a significant amount of accidental complexity, as

Repenning, Basawapatna, Escherle – 12
Page 12 of 25
opposed to dealing with the intrinsic complexity (Dijkstra, 2001) of the problem
solving process. If the intended outcome is to become a professional programmer,
then this approach may be highly effective or indeed entirely necessary.
If instead the goal is to become a Computational Thinker, then the resulting
overhead and lack of support may turn into an insurmountable educational
obstacle. Focusing less on the notion of essence but on understandable mappings
Natural programming (Myers, Pane, & Ko, 2004) attempts to better align the
expression of a solution with the problem formulation based on peoples’ intuitive
comprehension of semantics such as the use of Boolean operators. Rittel
differentiated the notion of human computer interaction from human problem
domain interaction (Rittel & Webber, 1984) to clarify this important philosophical
dichotomy. Guzdial reached a similar conclusion in the context of computing
education (Guzdial, 2015) by suggesting that “If you want students to use
programming to learn something else [e.g., how to author a simulation] then limit
how much programming you use.” The limitation of accidental complexity can be
supported at three different levels:
(1) Syntax: Visual programing approaches such as drag and drop programming
(Conway et al., 2000; Repenning & Ambach, 1996; M. Resnick et al., 2009)
can avoid frustrating syntactic challenges such as missing semicolons.
(2) Semantics: Live programming (Burckhardt et al., 2013; McDirmid, 2013;
McDirmid., 2007) and similar approaches help users to understand the
meaning of programs by illustrating the consequences of changes to programs.

Computational Thinking Tools – 13
Page 13 of 25
(3) Pragmatics: Domain-oriented (Fischer, 1994) or task specific (B. Nardi, 1993)
programming languages support users in employing programming languages to
achieve their goals.
How AgentCubes supports solution expression. At the syntactic level AgentCubes
offers drag and drop programming, which its predecessor, AgentSheets, pioneered
over 20 years ago (Repenning & Ambach, 1996). A first version of AgentSheets
initially introduced the idea of agent-based graphical rewrite rules (Repenning,
1994, 1995), a programming by example (Repenning & Perrone, 2000;
Repenning & Perrone-Smith, 2001) approach to define the behavior of agents by
demonstrating it. However, the graphical rewrite rules were ultimately considered
to be too constraining (Schneider & Repenning, 1995). Meanwhile, the benefits of
drag and drop programming have become quite clear and consequently drag and
drop programming has proliferated to a very large number of programming
environments for kids (Conway et al., 2000; M. Resnick, Maloney, J., Monroy-
Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner, A., Rosenbaum, E.,
Silver, J., Silverman, B., Kafai, Y. , 2009).
Semantic support is considerably harder than syntactic support (Repenning,
2013a). At the level of semantics AgentCubes offers not only live programming
(McDirmid, 2013; McDirmid., 2007) but also a technique called Conversational
Programming (Repenning, 2013a). Conversational Programming will observe the
agent a user is interested in and then annotate the program behaviors of that
particular agent in its particular situation by running the program one step into the
future to illustrate which agent behavior rules will evaluate to true, which will

Repenning, Basawapatna, Escherle – 14
Page 14 of 25
evaluate to false, and which rules will not be tested. For instance, in a Frogger-
like game a user can click the frog agent and look at its behavior rules to see what
will happen to the frog after it has just jumped in front a of a car moving towards
it. In this case, if the frog-car collision pattern is programmed correctly, the
behavior rule wherein the frog dies and the game restarts will be annotated by
Conversational Programming to appear as true.
Of the three levels, pragmatics is the most challenging one to support. One might
naturally want to have a simple mapping between the problem domain and the
solution domain. However, the least amount of code cannot be the only objective.
For example, languages such as APL are well known for their parsimonious
nature but not for their general readability. Instead, programs should be short and
intuitive expressions of a given idea. An example may help to illustrate this.
The 15 squares puzzle, shown in Figure 5, is a classic
children’s toy. The game consists of sliding 15 numbered
squares into a sorted arrangement, 1-15, in a 4 x 4 grid.
Many computer program implementations of the game
exist. From a CT point of view the core idea is simple:
click the square you want to slide into the empty space.
From a coding point of view, however, efforts can vary
widely. A Python program to implement the “click to
slide” functionality (e.g., (Sweigart, 2010)) quickly runs into hundreds of lines of
code not including the functionality to solve the puzzle. The view here is not to be
Figure 5. 15 squares
puzzle

Computational Thinking Tools – 15
Page 15 of 25
negative regarding coding. If a CS class codes the 15 squares puzzle to learn
about arrays, loops, animations, or Python syntax then writing the 300 lines of
code could be extremely beneficial.
An AgentCubes implementation, in contrast, will include very little coding
overhead. The “click to slide” functionality requires only four rules checking if
there is an empty spot adjacent to the clicked square and then move into that spot.
This is depicted in Figure 6. Trading in clarity for brevity, one could even employ
the more arcane moveRandomOn (background) AgentCubes action to solve the
15 squares puzzle benchmark in a single line of code. Comparing Python to
AgentCubes seems hardly fair. In AgentCubes the notion of a grid, animations,
and even numbered squares already
exists. This is what domain
orientation (Fischer, 1994) can do.
It reduces coding overhead by
providing and implementing
abstractions to help users express a
solution succinctly.
Of course, domain orientation
introduces trade-offs. For instance,
it would not be advisable to write a
compiler in AgentCubes. Similar to
spreadsheets – which have been
Figure 6. AgentCubes online implementation
of the 15-squares puzzle with 4 rules

Repenning, Basawapatna, Escherle – 16
Page 16 of 25
used creatively to create amazing projects such as flight simulators and planetary
models – AgentCubes’ grid structure maps well onto a wide variety of projects
such as 2D/3D games, simulations, and cellular automata. For instance, a simple
version of the Pac-Man game can be implemented in just 10 rules (IF/THEN
statements) including collaborative AI (Repenning, 2006) and win/lose detection.
Studies show that students can use such system affordances of AgentSheets and
AgentCubes to successfully implement the Computational Thinking Patterns
planned in the formulation step in game and simulation development (Repenning
et al., 2015). Studies also show that users are highly motivated to create these
artifacts, speaking to the power of reducing coding overhead (Repenning,
Basawapatna, Assaf, Maiello, & Escherle, 2016). Guzdial points out the
importance of avoiding coding overhead in education (Guzdial, 2008) and refers
to a number of languages explored in computer science education to establish
essence by employing implicit loops and other task-specific (B. Nardi, 1993)
constructs. An example of this approach in AgentCubes is the built in
management of parallelism. For instance, even a very large number of agents,
looking like boxes, moving around randomly in a three dimensional world will
automatically reshuffle and stack up correctly in parallel with very little code.
Computing trajectories that can be executed in parallel, determining the order of
boxes stacked up, would be complex code to write.

Computational Thinking Tools – 17
Page 17 of 25
Supporting Execution & Evaluation
The execution & evaluation stage can be supported by helping users debug their
programs as well reveal their misconceptions. Pea (Pea, 1983) describes
debugging as “…systematic efforts to eliminate discrepancies between the
intended outcomes of a program and those brought through the current version of
the program.” Given that the computer does not currently “understand” the
problem it will not be able to automatically compute these discrepancies, but there
are still strategies for a Computational Thinking Tools to aid the debugging
process. One strategy is to simply reduce the gap between solution expression and
solution execution & evaluation. Punch cards are the classical negative example
resulting in an extremely large gap. As this gap increases, users quickly lose sight
of the causal relation between changes made to a program and manifestations of
different behavior exhibited by running the modified program (Repenning,
2013a).
Live programming (McDirmid, 2013) can help by enabling users to instantly see
the consequences of any change to a program. Unfortunately, there are issues such
as the halting problem in computer science theory with practical consequences,
suggesting that it is not actually possible to determine all consequences of
arbitrary program changes. However, for a more constrained class of programs,
including spreadsheets, this is not a problem. Very much in the spirit of live
programming, spreadsheets will instantly update results when formulae or cell
values are changed by a user.

Repenning, Basawapatna, Escherle – 18
Page 18 of 25
A Computational Thinking Tool would support visualization through the
inclusion of easy to use visualization affordances. Additionally, a Computational
Thinking Tool may apply the idea of visualization to itself by annotating
programs in ways to make discrepancies between the programs users have and the
ones they want more understandable (Repenning, 2013a).

Computational Thinking Tools – 19
Page 19 of 25
How AgentCubes supports execution & evaluation. To support the goal of
visualizing the consequences of one’s own thinking, a number of visualization
techniques are included in AgentCubes. In the mudslide example (Figure 1
solution execution and evaluation) it helps considerably to understand the
pressure distribution among the thousands of agents employed in the model. The
simple visualization scheme mapping each pressure value into a single color helps
the forging of explicative ideas by depicting pressure build up.
Particularly useful when making simulations, AgentCubes supports the plotting of
simulation properties. An example would be to plot the number of predators and
Figure 7. Bird’s eye view of a city traffic simulation in AgentCubes with an overlaid 3D
plot of traffic wait times with the higher red peaks indicating a longer wait

Repenning, Basawapatna, Escherle – 20
Page 20 of 25
prey in an ecological simulation. One can also use 3D plotting to visualize value
fields in real time. For instance, in a city traffic simulation 3D plots (Figure 7)
show the spatial distribution of wait times in the city over the world grid itself.
Finally, AgentCubes online narrows the gap between solution expression and
execution through Conversational Programming (introduced above in Supporting
Solution Expression) (Repenning, 2013a) extending the notion of live
programming (McDirmid, 2013). Even when a game is not running, by selecting
an agent in the world, AgentCubes will execute relevant code fragments one step
into the future and annotate the code, specifying which rule will execute, in order
to visualize potential discrepancies between the programs users have and the
programs users want (Pea, 1983). This indicator can guide users into another
iteration cycle depicted in Figure 1 yielding more useful representations.
Conclusions
Computational Thinking Tools should support Papert’s vision of enabling users to
forge explicative ideas through the use computers. By minimizing coding
overhead Computational Thinking Tools can allow all users to focus on the
essence of abstraction, automation, and analysis. In contrast to traditional
programming environments Computational Thinking Tools support all three
stages, problem formulation, solution expression and execution & evaluation, of
the Computational Thinking process. This support will make Computational
Thinking feasible to a wide range of applications including STEM, art, music, and
language.

Computational Thinking Tools – 21
Page 21 of 25
References
Arnheim, R. (1969). Visual Thinking. Berkley: University of California Press.
Ashok Basawapatna, K. H. K., Alexander Repenning, David C. Webb, Krista Sekeres Marshall.
(2011). Recognizing Computational Thinking Patterns. Paper presented at the The 42nd
ACM Technical Symposium on Computer Science Education (SIGCSE), Dallas, Texas,
USA.
Basawapatna, A. R., Repenning, A., & Lewis, C. H. (2013). The Simulation Creation Toolkit: An
Initial Exploration Into Making Programming Accessible While Preserving
Computational Thinking Paper presented at the 44th ACM Technical Symposium on
Computer Science Education (SIGCSE 2013), Denver, Colorado, USA.
Burckhardt, S., Fahndrich, M., Halleux, P. d., McDirmid, S., Moskal, M., Tillmann, N., & Kato, J.
(2013). It's alive! continuous feedback in UI programming. Paper presented at the
Proceedings of the 34th ACM SIGPLAN conference on Programming language design
and implementation, Seattle, Washington, USA.
Conway, M., Audia, S., Burnette, T., Cosgrove, D., Christiansen, K., Deline, R., . . . Pausch, R.
(2000). Alice: Lessons Learned from Building a 3D System For Novices. Paper presented
at the CHI 2000 Conference on Human Factors in Computing Systems, The Hague,
Netherlands.
Dijkstra, E. W. (2001). The end of computing science? Commun. ACM, 44(3), 92. doi:
10.1145/365181.365217
diSessa, A. (2000). Changing Minds: Computers, Learning, and Literacy. Cambridge, MA: The
MIT Press.
diSessa, A. A. (1991). An Overview of Boxer. Journal of Mathematical Behavior(10), 3-15.
Fischer, G. (1994). Domain-Oriented Design Environments Automated Software Engineering (Vol.
1, pp. 177-203). Boston, MA: Kluwer Academic Publishers.
Grover, S., & Pea, R. Computational Thinking in K–12: A Review of the State of the Field.
Educational Researcher, 42(1), 38-43. doi: 10.3102/0013189X12463051
Guzdial, M. (2008). Education: Paving the way for computational thinking. Communications of the
ACM, 51(25-27), 25-27.
Guzdial, M. (2015). Learner-Centered Design of Computing Education: Research on Computing
for Everyone, Synthesis Lectures on Human-Centered Informatics: Morgan & Claypool
Publischers.
Ioannidou, A., Repenning, A., & Webb, D. (2009). AgentCubes: Incremental 3D End-User
Development. Journal of Visual Language and Computing, 20(4), 236-251.
Kahn, K. (1996). Seeing Systolic Computations in a Video Game World. Paper presented at the
Proceedings of the 1996 IEEE Symposium of Visual Languages, Boulder, CO.
Koh, K. H., Basawapatna, A., Bennett, V., & Repenning, A. (2010). Towards the Automatic
Recognition of Computational Thinking for Adaptive Visual Language Learning. Paper
presented at the Conference on Visual Languages and Human Centric Computing
(VL/HCC 2010), Madrid, Spain.
Lieberman, H., Paternò, F., & Wulf, V. (Eds.). (2006). End User Development (Vol. 9): Springer.

Repenning, Basawapatna, Escherle – 22
Page 22 of 25
McDirmid, S. (2013). Usable Live Programming. Paper presented at the SPLASH Onward!,
Indianapolis, Indiana.
McDirmid., S. (2007). Living it up with a live programming language. Paper presented at the
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented
programming systems and applications (OOPSLA '07).
Michotte, A. (1963). The Perception of Causality (T. R. Miles, Trans.). London: Methuen & Co.
Ltd.
Myers, B. A., Pane, J. F., & Ko, A. (2004). Natural programming languages and environments.
Communications of the ACM, 47(9), 47-52. doi: DOI=
http://doi.acm.org/10.1145/1015864.1015888
Nardi, B. (1993). A Small Matter of Programming. Cambridge, MA: MIT Press.
Nardi, B. A., & Miller, J. R. (1990). The Spreadsheet Interface: A Basis for End User
Programming. Paper presented at the INTERACT 90 - 3rd IFIP International Conference
on Human-Computer Interaction, Cambridge, UK.
http://www.miramontes.com/writing/spreadsheet-eup/
National Research Council, C. f. t. W. o. C. T., Computer Science and Telecommunications Board,
Division on Engineering and Physical Sciences. (2010). Report of a Workshop on The
Scope and Nature of Computational Thinking. Washington, D.C.: The National
Academies Press.
Papert, S. (1993). The Children's Machine. New York: Basic Books.
Papert, S. (1996). An Exploration in the Space of Mathematics Educations. International Journal of
Computers for Mathematical Learning, 1(1), 95-123.
Pea, R. (1983). LOGO Programming and Problem Solving. Paper presented at the Paper presented
at symposium of the Annual Meeting of the American Educational Research Association
(AERA), "Chameleon in the Classroom: Developing Roles for Computers" Montreal,
Canada, April 1983.
Repenning, A. (1994). Bending Icons: Syntactic and Semantic Transformation of Icons. Paper
presented at the Proceedings of the 1994 IEEE Symposium on Visual Languages, St.
Louis, MO.
Repenning, A. (1995). Bending the Rules: Steps toward Semantically Enriched Graphical Rewrite
Rules. Paper presented at the Proceedings of Visual Languages, Darmstadt, Germany.
Repenning, A. (2001). End-User Programmable Simulations in Education. Paper presented at the
HCI International 2001, New Orleans.
Repenning, A. (2006). Collaborative Diffusion: Programming Antiobjects. Paper presented at the
OOPSLA 2006, ACM SIGPLAN International Conference on Object-Oriented
Programming Systems, Languages, and Applications, Portland, Oregon.
Repenning, A. (2013a). Conversational Programming: Exploring Interactive Program Analysis.
Paper presented at the 2013 ACM International Symposium on New ideas, New
Paradigms, and Reflections on Programming & Software (SPLASH/Onward! 13),
Indianapolis, Indiana, USA.
Repenning, A. (2013b). Making Programming Accessible and Exciting. IEEE Computer, 18(13),
78-81.

Computational Thinking Tools – 23
Page 23 of 25
Repenning, A., & Ambach, J. (1996). Tactile Programming: A Unified Manipulation Paradigm
Supporting Program Comprehension, Composition and Sharing. Paper presented at the
1996 IEEE Symposium of Visual Languages, Boulder, CO.
Repenning, A., Basawapatna, A., Assaf, D., Maiello, C., & Escherle, N. (2016). Retention of Flow:
Evaluating a Computer Science Education Week Activity. Paper presented at the Special
Interest Group of Computer Science Education (SIGCSE 2016), Memphis, Tennessee.
Repenning, A., & Ioannidou, A. (2006). AgentCubes: Raising the Ceiling of End-User
Development in Education through Incremental 3D. Paper presented at the IEEE
Symposium on Visual Languages and Human-Centric Computing 2006, Brighton, United
Kingdom.
Repenning, A., & Perrone, C. (2000). Programming by Analogous Examples. Communications of
the ACM, 43(3), 90-97.
Repenning, A., & Perrone-Smith, C. (2001). Programming by Analogous Examples. In H.
Lieberman (Ed.), Your Wish Is My Command: Programming by Example (Vol. 43, pp. 90-
97): Morgan Kaufmann Publishers.
Repenning, A., Webb, D. C., Brand, C., Gluck, F., Grover, R., Miller, S., . . . Song, M. (2014).
Beyond Minecraft: Facilitating Computational Thinking through Modeling and
Programming in 3D. IEEE Computer Graphics and Applications, 34(3), 68-71. doi:
10.1109/MCG.2014.46
Repenning, A., Webb, D. C., Koh, K. H., Nickerson, H., Miller, S. B., Brand, C., . . . Repenning, N.
(2015). Scalable Game Design: A Strategy to Bring Systemic Computer Science
Education to Schools through Game Design and Simulation Creation. Transactions on
Computing Education (TOCE), 15(2), 1-31. doi: 10.1145/2700517
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., . . . Kafai,
Y. (2009). Scratch: programming for all. Communincation of the ACM, 52(11), 60-67.
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner,
A., Rosenbaum, E., Silver, J., Silverman, B., Kafai, Y. . (2009). Scratch: Programming for
All. Communications of the ACM, November 2009.
Rittel, H., & Webber, M. M. (1984). Planning Problems are Wicked Problems. In N. Cross (Ed.),
Developments in Design Methodology (pp. 135-144): John Wiley & Sons, New York.
Schneider, K., & Repenning, A. (1995). Deceived by Ease of Use: Using Paradigmatic
Applications to Build Visual Design. Paper presented at the Proceedings of the 1995
Symposium on Designing Interactive Systems, Ann Arbor, MI.
Sweigart, A. (2010). Invent Your Own Computer Games with Python, A beginner's guide to
computer programming in Python.
Turkle, S. (2007). Evocative Objects: Things We Think With. Cambridge, USA: MIT Press.
Willis, C. L., & Miertschin, S. L. (2005). Mind tools for enhancing thinking and learning skills.
Paper presented at the Proceedings of the 6th conference on Information technology
education, Newark, NJ, USA.
Wing, J. M. (2006). Computational Thinking. Communications of the ACM, 49(3), 33-35.
Wing, J. M. (2008). Computational thinking and thinking about computing. Philosophical
Transactions of the Royal Society, 2008(366), 3717-3725.
Wing, J. M. (2014). Computational Thinking Benefits Society.

Repenning, Basawapatna, Escherle – 24
Page 24 of 25
Yager, R. (Ed.). (1995). Constructivism and Learning Science. Mahway, New Jersey: Lawrence
Earlbaum Assoc.
Acknowledgements
This work is supported by the Hasler Foundation and the National Science
Foundation under Grant Numbers 0833612, 1345523, and 0848962. Any
opinions, findings, and conclusions or recommendations expressed in this
material are those of the authors and do not necessarily reflect the views of these
foundations.
Author Information
Complete name of the 1st author: Alexander Repenning
Institutional affiliation: School of Education, University of Applied Sciences and
Arts, Northwestern Switzerland
Institutional address: Bahnhofstrasse 6, 5210 Windisch, Switzerland
Permanent address:
Telephone number: 0041 56 202
Email address: alexander.repenning@fhnw.ch
Website (optional): www.scalablegamedesign.ch
Short biographical sketch – 100-200 words including your most important
publications, awards, and projects. Only the biographical sketch and institutional
position and affiliation will appear in the published version.

Computational Thinking Tools – 25
Page 25 of 25
Complete name of the 2nd author: Ashok Ram Basawapatna
Institutional affiliation: Department of Mathematics and Computer Information
Systems, SUNY, Old Westbury
Institutional address: Old Westbury
Permanent address:
Telephone number:
Email address: basawapatnaa@oldwestbury.edu
Website (optional): www.scalablegamedesign.ch
Short biographical sketch – 100-200 words including your most important
publications, awards, and projects. Only the biographical sketch and institutional
position and affiliation will appear in the published version.
Complete name of the 3rd author: Nora Anna Escherle
Institutional affiliation: School of Education, University of Applied Sciences and
Arts, Northwestern Switzerland
Institutional address: Bahnhofstrasse 6, 5210 Windisch, Switzerland
Permanent address: Gundeldingerrain 69, 4059 Basel, Switzerland
Telephone number: 0041 56 202 72 54
Email address: nora.escherle@fhnw.ch
Website (optional): www.scalablegamedesign.ch