Category Archives: Week 10

Tear Down the Binary Wall of Worlds

Confession: I’m not the best coder.

Last semester, I had the pleasure (and misfortune) of taking Expressive Computation with Professor LeMasters and while I walked away with nascent computational confidence and a new avenue for creatively expressing myself, coding was more of a tedious task. Prior to joining CCT, I had no experience with computation, let alone with computational thinking. Abstractions seemed foreign to me — and still do, if I can be frank.  However, as Jeannette Wing explained in a more practical way, abstractions are simply artifacts of deblackboxing in which we extract what’s necessary and eliminate the clutter.

Art created using Processing application

Art created using Processing application

Art created using Procession application

Art created using Procession application

Eureka! Examining abstractions in computation is to editing in journalistic language and facilitating social change. Computational thinking centers on the idea of selecting ideal abstractions and drawing connections amongst these layered artifacts. The process of getting a news story is the same. News are happenings through a subjective lens; what may be news for one is irrelevant to another. The measures of what makes a “good” abstraction parallel to what makes a “good” news story, or what contributes to its newsworthiness. Moreover, computational thinking also juxtaposes with the mediation of news: efficiency (how fast? how much space/time? how much power?) and correctness. There is a grammar to computational thinking that syncs with the grammar for journalistic standards. Yet, journalistic standards often steps on its own feet by comprising one measure for another. For example, during the Columbine shootings, local and national media outlets rushed to the mourning Colorado city in a race for first coverage, but wound up twisting the facts. This left many, particularly the families and classmates of slain students, with a sour taste in their mouths about the integrity of media. The practices of news organizations are scrutinized based upon their gauging of efficiency and correctness, just as consumers closely judge and evaluate the manufacturers of their beloved products. Companies circulate surveys within apps to receive feedback from their users about the program’s usability and efficiency. Some end-users may conclude that the app adequately performs its function, but could do so in a quicker way. Their conceptual models don’t match the actual design model, thus new and improved (but still flawed) updates to technology arise. Remember, when Google Chrome and Mozilla Firefox were created as competitors for Internet Explorer.

Computational thinking is not exclusive to the fields of computer science or technology. As we explained last week, these worlds are not detached from the humanities. The very concepts we take away from computational thinking — planning, learning, scheduling (as Wing’s text explains) — are the basis for social movements. Pseudo-coding and implementing plans before executing a code was the same approach civil rights groups like SNCC and SCLC used to create social change in the South. Computational thinking is about finding the Achilles heel or the problematic source within a system and solving it with the intent of preventing redundancies from reoccurring.

With the practicality of marrying computational thinking with social change, I wonder why such concepts are guarded or excluded from other disciplines. Computers, computation and computational thinking are preceded by basic human interactions and behavior. The way we interact with other actors within a sociotechnical system is the same way in which software and hardware interact. Why don’t these areas of study share the same terrain in academic settings until the collegiate level? (FYI: I would have loved to make this connection at least in middle school.)  Professor LeMasters discussed his involvement with President Obama’s My Brother’s Keeper initiative last year and has even facilitated workshops in Maryland to bridge the gap between adolescents and the daunting world of computation. It’s disheartening to compare standardized test scores in the math and science category amongst genders and races. My experience with math and science was a frustrating one — I did well in both fields, but I was better with words, not numbers; my grades and SAT scores were proof of that. The language around STEM creates a threatening vortex, especially for those unfamiliar with or intimidated by mathematical thinking and engineering concepts. Fortunately, more and more initiatives are budding in which the glass ceiling of computer science and technology are being shattered, opening opportunities for Black students, women and other minorities such as Verizon’s #PotentialOfUs campaign and GUWWC here on the Hilltop.

After completing LeMasters’ course and navigating through this week’s Codecademy assignment, I realized that there is greater value in being well-versed in code. The specificity and form required for coding may be cumbersome, but it’s about the bigger picture. It’s about setting personal goals and accomplishing them. Computing allows me to take pride in the little successes on my way to a bigger objective. More importantly, computation is certainly not an exclusive club, where you either are or you aren’t. You don’t have to be a middle-aged White man to qualify as a master of coding or computational thinking. Thankfully, the binary buck stops here.

CT VS. Programming

I’ve dabbled a bit in learning Java language before via Processing. Readings from this week expanded the foundation of programing and provided us sufficient reasons why we should learn coding. In the video, Wing  also explained why computation mattersShe points to real world examples where machine learning in the sciences has produced results never available to us before. CT allows such data mining to be efficient; it allows efficiency in time, in storage space, and in processing power. Because of CT’s efficiency, these complex, vast projects could be processed by human.

However, I am still struggling to understand the relationship between programming and CT. Jeanette Wing clarifies that computational thinking is not equivalent to programming:

Computation Thinking is “A way that humans, not computers, think. Computational thinking is a way humans solve problems; it is not trying to get humans to think like computers. Computers are dull and boring; humans are clever and imaginative.”

Yet my own experiences with programming definitely feel like an exercise in thinking like a computer. When experimenting and learning this language, the salient feature is that users need to set up global variables at the very beginning of every work, so the following logic will add bricks on the foundation. However, normal human thinking would start from the goals they would like to accomplish. The fundamental structure projects “stack” in language, which is a useful way to keep track of the sub-networks. Similar to the trays metaphor, when running programs, computer will trace back to the global variable settings and run “void setup” and then run “void draw”. Just as Evans described, “We use a stack of nodes to keep track of the sub-networks as they are entered. The top of the stack represents the next node to process. At each step, we pop the node off the stack and follow a transition from that node.” Different from other mathematical process, commands wrote in “draw loop” run as infinite loops.

As Prof. Irvine mentioned “Program instructions are ‘read’ and executed in a linear path (serial processing); that is, processing requires a strict logical and physical synchronized time sequence. ‘Parallel Processing’ must sum up separate serial processes at synced time states.” The indefinitely running feature of draw loop in Processing is intrinsically bonded to the purpose of the software, which is to build electronic art and visual design communities. By infinitely running some variation, the process generates some patterns. As a rookie in Processing, I often accidentally made something interesting and when I scrutinize the “mistake”, I can learn how to appreciate the logic behind it. The fascinating part and aesthetic value of generative art is not the work itself, but also the code, the creative process.

Although experimenting is not the efficient way to work with programing, I think the the essence of CT is thinking creatively about varies possible solutions that could be realized via machine/software. Therefore, the experimenting experience could be used as a learning tool. After all, people can only be highly familiar with the language then could possibly know what  they could accomplish or what should be their goals.

I agree with Wing that CT should be a pervasive part of education, but I’m more skeptical of her proposition that CT can be practiced without programming, or saying people who are not competent and familiar with programming could truly understand CT.


Python, ANT, Performatives, and Computational Thinking

In (partially) learning Python, I was reminded of Latour’s network of human actors and nonhuman actants. Programming languages enable an ongoing communication between humans and objects, objects and objects, and humans and humans. Through the use of Python, one can execute commands to the computer and receive results, the various softwares can send commands to other softwares, and one can communicate to others who are also proficient in the programming language. In addition, one can specify the intended audience (human or machine) through the use of particular symbols. For instance, the three opening and closing quotation marks (“””) ensure that the computer will not read certain sections of the code; however, other programmers can read these sections in order to better understand the author’s choices or how the code functions.

While using Python and reading the articles for this week, it occurred to me that programming languages consist entirely of performatives, in the linguistic sense of the term. A performative occurs when what the speaker says correlates exactly with what she does. For instance, if I were to say “I promise to learn to code,” I am also doing exactly that: promising to learn to code. In this way, language not only says or explains or details or means, but also performs actions. Programming languages appear designed in such a way that every utterance is also a performance. As Prof. Irvine remarks, bits include “not only data (numbers that mean things) but executable instructions (numbers that do things)” (4).

While the Python exercises assisted in understanding some of the concepts of the reading, they did not convince me of the benefits of applying computational theory to all aspects of the world and existence. For instance, Wing discusses how “computational thinking will have become ingrained in everyone’s lives when words like algorithm and precondition are part of everyone’s vocabulary” (34), and she seems to suggest that the adoption of these new(er) metaphorical understandings will be an improvement. So far, I am not entirely convinced. Why should we think of the choice between lines at a supermarket as “performance modeling for multi-server systems”? What is gained through the application of this new(er) metaphor set? We’ve discussed before the danger of the “mobile army of metaphors,” the way in which “truth” results in a metaphor losing its metaphoricity. However, none of the theorists for this week appear to treat these metaphors critically (or even to acknowledge their existence as metaphors). How cautious and critical should we be in employing computational metaphors, and what are the boundaries (if there are boundaries) of their usefulness?

Martin Irvine, An Introduction to Computational Concepts (introductory illustrated essay)

Jeannette Wing, “Computational Thinking.” Communications of the ACM 49, no. 3 (March 2006): 33–35.

All about that binary transmission…

Binaries are fundamental to our understanding of the world and our lives. Night and day. Alive and dead. Love and hate. Close and far. Of course we soon realize there’s nuance to these supposed oppositions – that they’re not as simple as they seem. They’re inevitably on some sort of common spectrum – time, state of a living organism, emotion, physical (or metaphorical) distance. Distinguishing between these seemingly complete, holistic states is useful for our understanding. It can be especially useful when we need to decide whether to take action or not (eg. fight/run, buy/sell).

The readings this week gave me new insight into why these oppositions are so useful – especially Hillis’s description of how important restoring logic is for designing a consistently functional system. He writes “…the implementation technology must produce perfect outputs from imperfect inputs, nipping small errors in the bud.” His description of the hydraulic computer also clarified for me the famous Bateman quote, “a difference that makes a difference.” These differences are what create meaning and are a fundamental part of how we comprehend our existence. In order for them to accomplish that, they must be definitive – on or off, right or left, or we can’t perceive them.

The main thing the Code Academy exercises demonstrated for me (and I admit I didn’t finish the tutorial) was what I believe Wing is referring to when she talks about layers of abstraction. The various tools for analyzing (eg. length) and manipulating (eg. uppercase) different types of input offer insight into how these different inputs relate to one another and to the broader system. This also relates (I think?) to the distinction between meaning and doing made by George Dyson in the description of the von Neumann project in Dr. Irvine’s introduction.

This is similar to the way our minds are capable of storing different dimensions of information – we can understand the function of an object, its size, and its color and keep those classes of information clear so that if we encountered a different object of the same function but a different size and color, we could tell that the difference was in those categories. Similarly, with these broader categories of binaries, we examine the difference to understand something new, but we are aware, at least on some level, of the fact that other aspects of what we’re comparing (eg. hair, skin, and diapers in the case of the babies above) are the same.

Dr. Irvine writes in his introduction, “Human cognition is both massively parallel and has many simultaneous states, many not even at the threshold of awareness.” Binaries help us make sense of our world by allowing us to hold all these different states at once, but they also fit into an organizing, dare I say unifying structure. The lightbulb can be on or off, but either way it is a lightbulb.

I found myself thinking a lot as I was reading this week about the binary of analog and digital. Humans are capable of perceiving both nuance and distinction. Evans (p. 11) suggests this complexity when he writes about how color translates to computing: “There are arguably infinitely many different colors, corresponding to different wavelengths of visible light. Since the colors are continuous and not discrete, there is no way to map each color to a unique, finite bit sequence. On the other hand, the human eye and brain have limits. We cannot actually perceive infinitely many different colors; at some point the wavelengths are close enough that we cannot distinguish them. Ability to distinguish colors varies, but most humans can perceive only a few million different colors.”

I wonder if a connection can be made between this digital/analog binary and Debray’s concept of transmission/communication. Debray writes about passing information through time, in effect representing a difference in a sustainable way. Communication may be anything we perceive, so that the sound of the wind in the grass may mean one thing to me and another to you. But if I want to capture something about what the wind in the grass meant to me, I’ll have to make some decisions about how to represent it so others can perceive something similar. Can we think of the transmission as the message we want to encode and must therefore render definitively rather than leaving it up to interpretation?

Computational Thinking Versus Doing Research

This week’s materials focus on computational thinking and why it’s beneficial to us. So I kept asking myself: Why do we need computational thinking? As for me, I had a hard time trying to figure out how to ask research questions and how to write high quality research paper. I think there’s something about computational thinking that are paralleled with research processes.

Both Daniel Hills and Jeannette Wing mentioned that computational thinking is about hierarchy, thinking at multiple levels of abstraction. I think it is also true for how to boiling down a research question. Research questions are not answered simply. Usually we need to boil down the major question into different little answerable questions and link every one of them logically to answer the major one. Today Professor Tinkcom talked about how to do academic writing to different audiences (as a guest lecture, new content this year, and I am a TA so I was there.) He said that academic writing is about problem solving and it always start with questions that you genuinely want to know. He also mentioned how to work on each part of your writing and how to finally put them together. I think the process of breaking down and then synthesize is just like the level of abstraction in computational thinking. For example, when programming with Python, you want to find out how much positive words, neutral words, and negative words are there in one article. Like what professor Irvine said, computation always starts with functions, not with physical technologies. So now the question is “find out the words”. It’s something conceptual we want to do. So next we want to ask ourselves: what does it mean by positive/neutral/negative? There are many resources we can refer to online sentiment words dictionaries computer scientists build that categorize every English word into three categories: positive words, neutral words, and negative words. Then we might think, recognizing a word to be positive/neutral/negative is subjective and varies according to different contexts. So how can we use the static sentiment words dictionaries? Well, we can do some adaptation to the dictionary. Then we run Python program to compare each word in the article with the dictionary to get the result about the percentage of positive/neutral/negative words. Also, when we write Python scripts, there are many symbols we need to define as well.

The thinking process I described above actually is not computation specific. The logical problem solving process exists in many ways of our life. I think what I learned most from reflecting computational thinking is how to logically connect each part of my research to better answer the major question that I raise. Sometimes I read research articles that jump into conclusions or the conclusion is not answering the major question (I think I make the same mistakes too.)

Another thing I think is interesting about computational thinking is that not all programmings and algorithms are dealing with a grand question, instead most of the time, it solves questions that sound like minor and not important. For example, we want to use a program to do math. We all can do math but computers can do it faster, over and over again. Computers are not doing anything that at a very high level of complexity but it’s humans who boil the question down to many sub-questions and use the automaticity feature of computer to tackle problems.

Week 10

Boolean logic relates to the idea of binary, which depends on the idea of a single difference. A difference can be embodied in hardware, by making two ends to a pipe, and therefore introducing binary options in mechanical terms. Understanding the idea of Boolean logic helps us what information really is. Traditionally, “a fact” comes to mind when we think of information, whereas information is really about the difference – the way Gregory Bateson puts it, it is the “difference that makes a difference. ”

As Shannon demonstrated in his master’s thesis, “A Symbolic Analysis of Relay and Switching Circuits,”[1] electricity can also be used to embody the Boolean logic. Irvine describes binary units (bits) as the “interface between logic-mathematics and electronics.” Computation, therefore, builds on our cognition. While the concept of computational thinking is used to describe how humans think in computer science terms, we can go further and describe how computers think in human terms, and mention cognitive coding to describe how computer programs depend on human cognition to begin with. While software depends on human cognition, however, computers are more powerful than humans. We owe computers’ power to their processing capacity and memories.

The more one gets invested in computing, it becomes obvious that a good code is more than a good algorithm. The procissing capacities of computers not only form their power, but also their limitations. A good code should take into consideration the processing power of computer, and be as smart as possible.

Consider the following Python algorithm that multiplies any three input variables:

def functionMultiply(a,b,c):




This algorithm, however, can be improved in the following way:

def functionMultiply(a,b,c):



The concept of computational thinking becomes more tangible once we take into consideration the limitations of computer. Wing eloquently describes this perspective by stating that computational thinking involves: “making trade-offs between time and space and between processing power and storage capacity.”[2]

This quote leads us to think about the elegance in coding design. Less code, less iterations, and rather applying more of algorithm and human intelligence, and relying less on the memory: “It is judging a program not just for correctness and efficiency but for aesthetics, and a system’s design for simplicity and elegance.”[3]

All of the software programs are designed to facilitate human thinking. In Java, the following statement prints a string:

print.out.ln(“Hello World”)

In Matlab, the following code clears the memory:


And finally, considering the following algorithm that I just wrote last week for my homework:

a <- a + theme(axis.ticks =element_blank(),







Even if you are not familiar with the R, Java, or Python, it is intuitively clear that the command “print.out.ln” somehow prints out something, “clc;” is clearing, and in the R code, I was creating something transparent or empty. Therefore, the coding process is eased not only through analogies such as “data sets”, etc., but also through the linguistic analogies with the English language.

What is really deblackboxed, from my perspective, is the way coding and predictive algorithms are altering our online exposure. The content we are formed online have became a means for us to make sense of the world: we consume news, media, entertainment, make buying decisions, and communicate through interfaces. Our interactions with computers, however, are used as data that predictcs the type of content we might be interested in consuming, the type of product we might look for, or to expose us the person that we might have known. Therefore, our online exposure is personalized for us – which brings us to the intersection of capitalism and computation.

[1] Shannon, C. E. (1938). A symbolic analysis of relay and switching circuits.American Institute of Electrical Engineers, Transactions of the57(12), 713-723.

[2] Wing, J. M. (2008). Computational thinking and thinking about computing.Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences366(1881), 3717-3725.

[3] Wing, J. M. (2008). Computational thinking and thinking about computing.Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences366(1881), 3717-3725.