Bergin, M: Computational Literacy vs Computational thinking

           Throughout this class we has been working to differentiate between the two terms listed above. In this week's article DiSessa defines computational literacy as "an intelligence achieved cooperatively with external materials." Last week we read Grover and Pea's article which outlines that "computational thinking is the process of recognizing aspects of computation in the world that surrounds us, and applying tools and techniques from Computer Science to understand and reason about both natural and artificial systems and processes." The differences between the two are subtle as they interact and overlap in multiple ways. However, CL occurs when working with external materials more specifically computers, it is not simply the ability to use a computer but to rather to use the computer as an "object to think with" in the spirit of Papert. CT on the other hand is not exclusive to working with computers, although it can include them as a tool. This second term describes a mindset rather than a tool which involves systematic and high level thinking skills. Although some parties might argue that computational literacy is an extremely important skill in achieving computational thinking, the terms are not synonymous.

Karan: Computational Literacy

Computational literacy share several ideas with Grover and Pea's definition of computataional thinking. DiSessa's idea of "information factoring" in boxer sounds a lot like abstraction (though he is way of too much abstraction, as he explained with his examples about d = t*s and the many other conceptual relationships with that structure). His emphasis on programming languages aligns with Grover and Pea's "symbol systems and representations" and he explicitly includes "detecting patterns and making discoveries" which parallels Grover and Pea's pattern generalization.

The main difference is that while Grover and Pea seem to focus on skills, most of which are not emphasized in Changing Minds (algorithms, flow control, iterative/recursive thinking, etc.), diSessa emphasizes the social aspect of computational literacy. This seems more in line with the Kafai/Peppler perspective on computational participation that it does with computataional thinking as defined by Grover and Pea. It also seems like diSessa has a more pedagogical approach, as he addresses issues like making learning experiential.

DiSessa's definition of literacy is: Literacy is a socially widespread patterned deployment of skills and capabilities in a context of material support (that is, it is an exercise of material intelligence) to achieve valued intellectual ends. Though I imagine Grover and Pea value computational thinking for the outputs it can produce over the skills in isolation, their list seems more like a check-list of skills, whereas diSessa sees computational literacy as a way to get to intellectual ends. So while Grover and Pea risk getting attached to demonstrating mastery in these 9 categories, if new or different tools or strategies were created, I think diSessa would be on board with adopting a different type of literacy - he wouldn't place intrinsic value on computataional thinking.

It is also interesting that diSessa makes a kind of distributed-cognition argument about humans and tools like computers. I thought that was more of a sociocultural perspective, and that diSessa was more of a cognitive person. Yet, he describes a shared cognition between humans and the tools they are using.

S. Misar- Computational Thinking and video games

In my opinion, the two best supported and easiest aspects of computational thinking in creating video games on the computer are conditional logic and debugging. In my experience with programming the majority of my interactions have relied on “if-then-else” construct. In reading the Berland article the players use conditional logic throughout the game in their collaborative attempt to control the disease. In Peppler, Jorge demonstrates his conditional logic as he builds the rules and sets the parameters of his game, which mimics another game that he had played. In Kafai & Burke, conditional logic is critical in students acquisition of coding skills and incorporating it into the academic content they are learning in class.

Debugging is supported in a variety of ways through students use of the open source coding to edit others’ work and through their own analysis of their work (as well as simulating the experience). I enjoyed reading Kafai’s articles about “computation participation” and how constructionist programing can broaden access to students of all backgrounds. Debugging was part of the collaborative and strategic board came playing in Berland’s article and Jorge (Peppler) needed to debug his program when it didn’t work the way he thought it should.

I think conditional logic provides the foundation for algorithm building and debugging works simultaneously with simulation and distributed computation.  I agree with Kafai that it is vitally important that students are empowered to conduct coding as a “shared social practice”, but wonder how we (educators, policy writers, administrators, etc) can encourage schools to make this a priority and support the professional development needed to implement such programs that provide this access? Jorge’s (Peppler) transformation from creating his game on his own to responding and participating in an online community about his work is inspiring but how do we encourage students to make that leap? I wonder what was the catalyst for him to begin seeking others’ involvement and feedback? At what stage in is programming?

Daily - CT was built for Gaming

Last week, Grover and Pea suggested that there were nine widely accepted elements of computational thinking (2013).  Of these elements, many of them are represented in gaming. I believe that Conditional logic and structured problem decomposition are the two elements that most closely associate with game design.

Conditional logic is a concept we understand as programmers. It generally involves an if/than statement. Young children who have never coded before also understand conditional logic, because it's written as part of a game: In order to defeat Boss X, you have to have Item Z in your inventory. In order to access the "Air" level in Zelda, you have to have completed the "Water" level. If you don't, the game will not let you win. Children know this instinctively, but in creating the games themselves programmers have to formalize these rules for conditional logic. Those rules are IMO what makes it a game in the first place.

Structured problem decomposition is another major aspect in game development. How does a game designer represent the "hero's journey" as a problem or series of problems to be solved in the game. Further, the individual problem will likely have several aspects that must be further decomposed. This process goes on and on until the detail is simple enough to be represented in code, before it is reassembled back to its original, complex status. The idea of systematically breaking down a complex problem to smaller pieces, and from them into individual aspects is a key part of game design.

Many of the earlier blogs addressed that playing games is clearly conducive to CT, but were hesitant about developing games as furthering CT. If we take the computer out of the equation, and simply look at elementary school recess, we will find many of the elements at play there as well. Conditional logic is about following the rules (which are sometimes quite complex and can be made up on the spot). Systematic processing of information happens in any recess game with multiple players moving around (four square, tag, tetherball, dodgeball) and abstractions and pattern generalizations happens quite often too (Deciding which set of people to attack in Red Rover, to strategizing for sports.)

I think there are many ways to address computational thinking in games, especially in creating games, as long as we remember that CT is a way of thinking, a means to an end rather than an end of itself.  

Huang - Board games are fun (and how game design supports computational thinking)

To refer back to Grover & Pea’s 9 elements of computational thinking, the two aspects most strongly or easily supported through making and playing games are “efficiency and performance constraints” and “debugging and systematic error detection”.

As illustrated by the case study on Jorge creating a variation of Metal Slug, there is a large difference between playing and making video games (Peppler & Kafai 2007). While playing video games allows for interaction with interfaces and various game design activities, it is through designing these interfaces and games that one recognizes the difficulties and challenges. Just as teaching and designing lesson plans affords a more in depth understanding of the material, programming and designing games allows for a deeper analysis of the inner workings of interfaces. Understanding the code and algorithms that are in place behind games gives students the chance to explore efficiency and performance constraints. This is often missed while kids play games, as the seamless shifts in character movement and scene transitions seem to come naturally. However, programming affords the opportunity to examine how those movements and transitions appear so seamless.

The other element of computational thinking that I think is very strongly supported by making and playing games is debugging and systematic error detection. When creating programs, one of the really important aspects to remember is that the computer is only designed to do what you tell it to. This is a concept that I think children might struggle with at first. However, designing games is one of those areas where students may have an easier time understanding this concept. Kids usually come to the computer with an idea of what they want to happen in the game, and this knowledge helps them in the debugging process. They come with an idea, attempt to write code to implement this in the program, and then do a trial run. When this doesn’t quite work the way they want, they return to the code, then run another trial run. This cycle of error detection and debugging comes naturally when designing games and thus is one of the most easily supported aspects of computational thinking.

On a slightly related note, I love the game Pandemic and love that there are people like Berland & Lee that perform studies on why Pandemic is an awesome game (besides the fact that it is a lot of fun). It’s interesting that we all play games, and yet don’t realize how much we are actually learning from playing them.

Sheikh - Striking the balance, Computational Practice and Algorithms

From the readings this week, Kafai’s point of view on Computational Thinking to Computational Practice is the one which particularly resonates with my ideas of how computation could be empowering in different settings.

“Computational participation involves solving problems, designing systems and understanding human behaviour, in the context of computing.”

One of my aims is to b able to understand how to create learner centric problem solving environments - because they can change the whole outlook of programming in education.

However, one struggling idea is how to create such customised environments, which strike the right mix of flexibility to have a rich game design experience, and whether such an experience is even possible without having strong background knowledge/skills to take on the challenge, as discussed by Peppler et al.

A question that I’d like to ask is, what are our end goals when stressing on programming? Efficiency? Accuracy? What Kafai deems these goals leading to boredom, are in fact among the primary goals of coders that I’m familiar with. How do we make them less boring? Or can we come up with ways to code which primarily focus on goals other than these? It also made me reflect on my personal goals of developing a better understanding of the hybrid of education, entrepreneurship and technology. And what would be the right proportion of each to create ideas which are powerful and self-sustaining.

Another observation I made was of the feeling that a child gets knowing that he/she has created something - and how it boosts their confidence. Our experience as a group, helping our student with Scratch was just another example of that.

In our class discussion before we went to the school, we were thinking of ways to execute the first class, when I recalled how when it was my first time learning a language, my professors insisted that we all penned down our algorithm - to help give clarity, structure and organization to the gazillion ideas that we had. And we decided that we would ask our students to sketch a story map, (more like a comic strip), for the communication he planned between the characters in the shadows.

We ended up being amazed at how much the student found it helpful to start with the algorithmic story board, versus jumping into the Scratch code right away. Because he was not only able to think deeply about each frame of the conversation he was trying to build, he was also able to recognize the connections between the frames - which background is consistent in two frames, when does it need to be different, which sound would be more suitable for which frame, what color scheme would he prefer to use, and in which  frames would he prefer the characters to communicate with actual words vs facial expressions and body language. He went back and forth to check his story board for coherence, in terms facial expressions, body language, and positioning of characters, just the we do when checking for gaps in the code.

This experience has made me consider the readings we have read and the discussions we have had in the past about enabling the teachers to transition into the computational thinking mode of curriculum and whether building this thinking with a focus on an algorithmic view, as the base, would work well or not.

Hasan, Games and Computational Thinking

It was very interesting to read the paper of Berland et al. (2011) which explored how complex computational thinking takes place while playing games. This may indicate to the reasons why different social cultures try to discover new games and retain for years. This may also help to understand why some students would rather like playing games than studying. Maybe it's because games could connect better with the needs of growing up in meaningful ways (i.e. Constructionism). For strategy games certainly the need of mastering the computational thinking is apparent. May be for other games it is not so much. But to me it seemed playing games could certainly target students into the practice of all kinds of CT concepts and practices.

As reviewed in the paper of Kafai et al. (2015) we can see how making games exposes students into much deeper practice of computational thinking. More interestingly it was demonstrated that making games for the community is far more effective in terms of learning than making in isolation. I really liked the idea of extending into “Computational Participation” from “Computational Thinking”. Computational participation certainly empowers students in constructionist approach by giving them more meaning for what they are doing and engaging them in more personal way.

Now to identify few aspects of Computational Thinking which are potentially most strongly or easily supported through making and playing games, I would like to take Weintrop’s definition of CT (Weintrop et al. 2016) as I found that to be more detailed and easier to refer to in the trial of identifying a particular practice into one of CT practices. In reference to that definition, I think the two broad categories that are both most strongly and easily supported are “Computation problem solving practices” and “System thinking practices”. To talk about making games, when one tries doing that hey essentially need to choose a plot. That plot may include many types of real life systems and some imaginaries inspired from the reals. For any of them it is a necessary step to model the target plot computationally to represent to its gamers. This modeling process may involve practices from other categories of the Weintrop’s definition such as “Modeling & Simulation Practices” but one must go through the practices such as “Preparing problems for computational solutions” & “Choosing effective computational tools” from the broad category “Computation problem solving practices”.

Most games are compound systems involving many subsystems which themselves are made of other systems. For example a character may have systems such as movement controller, collision controller etc. which may also depend on other systems such as a generic physics engine. In most times a game is made iteratively and thinking of the game systems in modular fashion and using the facility of reusing a module to develop higher level modules is necessary. For example after developing the movement module the same module could be reused for other characters moving with the same laws. To develop such systems of systems, skills of using practices such as “Creating computational abstraction” and “Developing modular computational solutions” are necessary. One thing I would like to note that a student may not have much skill on such practices but along the way of making games these skills would inevitably grow up. The other practices in the same category would in the same way be automatically covered by students on the process of making games. Same is for the practices under the category “Systems Thinking Practices”.

It may be hard to imagine how the practices listed under the category “Data Practices” are accounted, but they may be when optimizing game experience or debugging. In another way they may be incurred in very useful way is when Computational Participation happens. It is one thing to make a game and another to make the gamers like that. I think the latter involves significant effort involving the data practices of CT and also the domain knowledges. I do not like to think that young students are not capable of building complex systems which may be used for social causes in fact it is just that they are not given the opportunity of doing that.

As for students making games and sharing to others to experience helps them to involve in learning more deeply, cannot they gain the same benefit when they share their work even if they do not make games rather may make a simulation of a system or may even make an interactive narrative story about a system? YouTube is not a site of games but still it is one of the top accessed website which contains only non-interactive materials. Many would like to watch a video instead of reading if they find it on YouTube. The idea of letting students build for the younger students and getting feedback seemed really interesting to me. For Computational Participation to be effective when students build something, the target user could in fact be very crucial. It is not much useful to build something for one’s own self but it could be very effective to build for the junior students who might be really helped by the built materials for both the builder and the user.

Eid Carol- Computational Thinking as a Social Practice

Positing that computational thinking is a social practice and calling for reframing the concept to “computational participation” lead me to further consider the parameters of the learning environment that we are trying to foster at University School of Nashville.

As a matter of fact, we are currently considering developing a toolkit to scaffold the process of “debugging” to our students as it seems that they might not intuitively recognize its value in developing a working code or be able to approach this skill successfully.  Nevertheless, this week’s articles lead me to think of additional ways in which we could scaffold the learning environment. For instance, how could we design for “peer pedagogy and apprenticeship” in our activities to support students in developing their computational skills and prevent them from giving up when they hit walls in coding and design? As a matter of fact, ill-conceived learning environments could promote the development of student identities that constrain the learning that could happen.

“[S]tudents’ sense of confidence with digital technology is inextricably tied to their own personal identities. Whether an activity taps into these identities and allows for personal expression plays no small role in whether a child will be attracted and persist with any such activity” (Kafai & Burke, 2015, p. 325).

This paragraph greatly resonated with me since one of the participants in our devised activity told me something along the following lines: “I am just bad at developing video games. I tried it before and it just didn’t work.” His words made me think of how early coding experiences can actually shape one’s perception of his/her potential in this domain. Consequently, making sure that the environments we design are rich enough with scaffolds that promote success in achieving the task is not a trivial issue.

               Since all of the participants last week were males, I wonder how we will be further challenged in our tasks when female participants (hopefully) join the class this week. Paying attention to how participants of different genders and ethnicities are positioned in the interactions that occur as well as to the repertoire of identities that our activities afford would be critical to the students' ability in developing computational skills. Looking forward to the next phases and let me know if you have any thoughts on this!

Hutchins - Game Design as a Tool for Computational Thinking Development

Going into this week’s readings I was inspired. During our first experience with a student utilizing our group’s literature idea for Scratch our plan made a slight change as a means of inspiring our student to create a new storyline for a character typically “in the shadows.” This change involved making the storyline a game. The normally hidden character would become the hero of a game and would communicate with other characters that did not have a larger voice in the main novel. The biggest hesitation with this change for me at the time was – would this change affect our ability to capture a literature concept that we wanted to teach via the Scratch project?

Based on our previous readings and class discussions, the following concepts have been associated with computational thinking: abstraction, decomposition, debugging, redundancy, data processing, modeling and simulation, and more (Wing, 2006; Weintrop et al, 2016). Wing, in her phrase-coining 2006 paper summarized computational thinking as “taking an approach to solving problems, designing systems, and understanding behavior that draws on concepts fundamental to computing.” I do not have significant experience in game design, but I play a mean game of Risk – so it was easy for me to associate the playing of a game with computational thinking concepts described previously, including: data processing, analyzing strengths and weaknesses of opponents (understanding behavior), modeling and simulation, etc.

One of the most utilized computational thinking concepts in game making seems to be debugging.  While many discussed the influence game making has on improving coding abilities (Kafai & Burke, 2015, noted that “youth making games used the most variables, loops, and if-statements in their program [compared to videos and stories]”), debugging games also enhances students usage of other computational thinking tools. For instance, in order to manage how a sprite moves through a side-scrolling game (example - Super Mario Bros), a student needs to analyze the sprite’s interactions with other sprites and its environment and make adjustments where needed.  In the Resnick TedTalk, debugging of a program allowed for a student to realize that he would need a to keep track of a score and, with teacher support, a variable was introduced to his game.

Unfortunately, the readings didn’t help resolve my hesitation from last week, so I ask anyone who is reading this – do you think the focus on game development in literature will take away from or potentially improve the goal of character development in our literature Scratch project? 

Fai—Making/Playing Games and Computational Thinking

Many readings we've read so far suggest that game making lends itself to learning computational thinking. Because games are interactive—you don't know what exactly is going to happen in the game until someone plays it—creating games requires using lots of conditional logic, compared to, say, music videos whose script is determined in exact details by the creators. The activity of making games entails many opportunities to learn to use those programming concepts.

While we know that making games affords opportunities to learn programming / computational thinking, we don't know was much about what kinds of games and what kinds of game-making afford new ways of participating in programming. This is important when we think about computational participation. If we are using games which have certain cultural meanings and associations, we need to think about how to broaden those meanings and associations so that more people can learn programming through making games. 

In terms of learning content through making games, readings suggest that a typical approach is to make games that teach certain content / concepts. I think that is a great way to make student thinking visible, so that students can discuss and elaborate on their thinking. I also wonder about another approach: content is used in the game mechanics. This is in part what the science group wants to be able to do with the white blood cell games. Rather than making a game that teaches someone about white blood cells, how white blood cell works informs the game mechanics. While this seems like a trivial distinction, I wonder whether research findings that when you ask children to make a game that teaches such and such to younger kids, they can only think of multiple choices or direct instruction. These two approaches many orient students to different relationships between the content and the game mechanics.

Doherty - Computational thinking in board games

Berland and Lee research five categories of computational thinking in their article on playing Pandemic. Those categories are: conditional logic, distributed processing, debugging, simulation and algorithm building. Comparing these to the list of commonly accepted facets of computational thinking in Grover and Pea’s work from last week, we have:

Berland & Lee	Grover & Pea
Conditional logic	Conditional logic
Distributed processing	Parallel thinking Systematic processing of information
Debugging	Debugging (and systematic error detection)
Simulation	Abstractions and pattern generalizations
Algorithm building

I’m wondering if Berland & Lee were conservative with what they looked for and whether or not you can find all other listed facets of computational thinking (Grover & Pea) in Pandemic or some other tabletop game.

Efficiency and Performance constraints – In programming this refers to elegant solutions that take minimal processing power versus brute force solutions that can eat up a lot of processing power. In game play, especially in Pandemic, it’s about using the most strategic moves in order to progress in the game. In Pandemic, if you do not spend time assessing the whole board and situation, you can make moves that have little to no effect on the game outcome. For example on page 75, in the Alpha group, the players are discussing the next move. John points out a specific desirable move that will enable the players to avoid an outbreak. While Aaron also has a plan, his plan does not take into account the imminent threat of an outbreak. The opposite is also true in the game, there are situations in which it seems like taking the disease cubes away from a city is most useful, but in fact, trading cards in order to cure the disease is more efficient.

Iterative and recursive thinking –Honestly, I’m a little confused at how these are different in computational thinking. So here I’m taking iteration as repetitive act that moves something forward and recursion as a process that depends on an earlier version of itself. At it’s most basic level this is turn taking. In virtually all games, one person takes a turn then so it goes around the circle. In a cooperative game the iterative period is each person playing since they are essentially playing as a multi-brained person. In a non-cooperative competitive game, the iterative period is one turn around the board, it’s the individual person’s turn that let’s their game move forward.  In a similar manner, recursive thinking is critical, the game board changes as you play. How many times have you played a game with a perfect move in mind and then another player royally messes up your plan? You constantly have to revise the plan based on previous moves.

Structured problem decomposition – This is only true in more complicated games where there are a) multiple ways to win, or b) there are multiple goals for the cooperative. In Pandemic you both try to cure the diseases, but you also have to not lose (it’s so easy to lose…). In a game like Settler’s of Catan or Ascension you can win in multiple ways so you are trying to juggle multiple areas of import. This is a bit different than with computers where you take a big problem, and make it little easier to solve problems, but not so different.  

Symbolic systems and representations – This is the tricky one. I think it both depends on how people think of the game as a whole, modeling it in their head and whether or not the game has a written component. Certainly, I imagine, in some paper-based games this could be true.  But it’s more about communication of ideas, and that happens less in board games since you either can’t communicate, or all communication is done through verbal forms.

Bell - CT and Playing and Making Games

Making games definitely seems like an obvious output from constructionism (i.e. Kafai & Burke, 2015). And making games through programming would definitely support computational thinking and many of its concepts from programming. But some game-making environments don’t use programming. Gamestar Mechanic is something I’ve used with elementary school students to make games. It just involves dragging avatars, enemies, and blocks around to make a Mario-like game. Characters and blocks have different features, like speed, weapons, damage, etc. But it doesn’t actually involve any programming. I would say the main computational thinking practice that something like Gamestar Mechanic supports would be debugging. If there are too many enemies and blocks, there’s no way to win the game, so creators must remove some enemies or use a different avatar with more weapons, an example of finding and fixing errors to work towards the creator’s game design goals. And clearly debugging would be a part of environments that support making games through programming. The extent to which students actually think carefully and systematically about their debugging practices is another issue that probably requires some scaffolding (as our math group found last week with our student). But debugging in general definitely seems to be an aspect of CT that could be supported by different types of game-making environments. 

The Pandemic board game example shows how playing board games, especially collaborative ones that support players discussions solutions out-loud, supports elements of CT (Berland & Lee, 2011). Besides debugging, conditional logic is one that players use a lot to plan for what might come next in the game. “If we do this then that will happen,” or thinking of the reverse, “if we want that to happen then we have to do this.” The authors give an example of a player predicting a Ho Chi Minh card might be next and explaining what would happen if that card is picked. There’s another example on line 12 on page 74 where Patrick says, “if you can give me the two blacks, we can build a research station in black, we could cure black.” Basically, he’s saying if one player does this then the group can cure the black disease. He’s using conditional logic to predict and suggest a strategy in the game. 

From reading the papers for this week, it seems like more research on collaborative games, both board games and digital games (and in the context of playing and making games) is an interesting place open for further research.

I love this quote from Kafai (2016) on page 27: “students need a more expansive menu of computing activities, tools, and materials. Designing authentic applications is an important step in the right direction, but games, stories, and robotics are not the only applications for achieving this goal. We need different materials to expand students’ perspectives and perceptions of computing.”

This kind of points to how I’m thinking about computational thinking as expanding beyond programming. Tools like Scratch are just one way of reaching the goal of teaching CT. But there are lots of different materials and activities we can use to broaden participation in CT; for example, playing games (not just programming games but also playing them) and knitting.