Technologies of Text, Spring 2018

Station Eleven, Day 1

2018-04-10T00:00:00+00:00

Choose one of the following passages from Station Eleven. Reflect on its themes in relation to another specific section from the first sections of the book (up to page 115).

1. Really, all of the very short chapter 6, but specifically from page 32:

No more Internet. No more social media, no more scrolling through litanies of dreams and nervous hopes and photographs of lunches, cries for help and expressions of contentment and relationship-status updates with heart icons whole or broken, plans to meet up later, please, complaints, desires, pictures of babies dressed as bears or peppers for Halloween. No more reading and commenting on the lives of others, and in so doing, feeling slightly less alone in the room. No more avatars.

2. From page 115:

Some towns, as I was saying, some towns are like this one, where they want to talk about what happened, about the past. Other towns, discussion of the past is discouraged. We went to a place once where the children didn’t know the world had ever been different, although you’d think all the rusted-out automobiles and telephone wires would give them a clue. Some towns are easier to visit than others. Some places have elected mayors or they’re run by elected committees. Sometimes a cult takes over, and those towns are the most dangerous.

3. From page 105:

In the next image, Dr. Eleven holds the note in his hand as he stands on the outcropping of rock, the little dog by his boots. His thoughts: The first sentence of the assassin’s note rang true: we were not meant for this world. I returned to my city, to my shattered life and damaged home, to my loneliness, and tried to forget the sweetness of life on Earth. To long, also melodramatic. She erases it, and writes in soft pencil: I stood looking over my damaged home and tried to forget the sweetness of life on Earth.

Electronic Texts

2018-04-06T00:00:00+00:00

Fieldbook Prompt

We began this semester working with historical, analogue textual technologies. In the past few weeks we’ve moved into the digital space, working with code in the R programming language. While we often talk about computers as if they are immaterial—talking about “the cloud” for instance—they are every bit as physical as manuscripts and printing presses. Recently the “internet of things” has made this reality more palpable, linking the internet to objects from speakers to light bulbs to refrigerators.

Often discussions of “electronic texts” center on screens: ebooks or online reading experiments. There’s much of interest in those text, but today we’ll be exploring electronic texts in another key by creating paper circuits. We’ll be using conductive copper tape, coin cell batteries, LEDs, and sticker circuits to design and create texts that light up and respond to basic kinds of input. Were we taking things a step farther, we could even get programmable circuits that would allow us to integrate code & paper art even more fully, but our work today will hopefully enrich your ideas about how text and electronics might come together to make artistic works.

At the beginning of class I’ll show you a few samples I’ve made. But unlike the other labs this semester, I’m pretty new to paper circuits myself, and excited about exploring them and learning alongside you! Here are some resources you might consult today as you experiment:

Jie Qi’s Circuit Sticker Sketchbook.
- And for some real inspiration, see also Jie Qi’s Flickr feed for ideas.
Jessica Henricks, “Simple Paper Circuit”
“Paper Circuits for Makerspaces”
“Paper Circuits” from Exploratorium

And there are many, many more ideas online. Let’s get going!

Fieldbook Prompt

Let’s keep things open. Respond to this lab as you will.

Lab 8

2018-03-31T00:00:00+00:00

R Markdown

library(tidyverse)
library(tidytext)
library(gutenbergr)

In the code block above I loaded different libraries, which are essentially databses that we pull from as we prepare to load and run the commands and prompts below. As you can see, I started off with the three tick marks and an r in brackets, then ended with three tick marks as well. Those tick marks and the r in brackets indicate that I want to start a code block. R automatically creates a code block when I do that, and makes the code block grey so I can more clearly see what I’m working with.

If I do not know what something is, I can go to the console (below) and then input ?(function/command), which will then show up to the window to the right in “Help.” So for example, if I look up tidyverse, it says:

“tidyverse: Easily Install and Load the ‘Tidyverse’ …. Description… The ‘tidyverse’ is a set of packages that work in harmony because they share common data representations and ‘API’ design. This package is designed to make it easy to install and load multiple ‘tidyverse’ packages in a single step.”

So basically, it means it’s a collection of packages that help R run better because it’s compatible with a range of different functions.

Tidytext, when I looked it up, said it “provides functions and supporting data sets to allow conversion of text to and from tidy formats, and to switch seamlessly between tidy tools and existing text mining packages.”

And then finally, the gutenbergr library indicates to pull from the Gutenberg library, which has the data encoded into R coding and thus allows us to search and download public domain texts that are in the Gutenberg database. This includes both tools for downloading books, in addition to a complete dataset of Project Gutenberg metadata that can be used to find words of interest.

Notice also that when I’m not in the code blocks, there will still be text in blue, such as the heading right below, Including Plots, and the heading above, R Markdown. That’s because we’re using R Markdown to code this, so the commands for Markdown, such as using the double pound symbols, will create a heading in a Markdown viewer.

Including Plots

You can also embed plots, for example:

melville <- gutenberg_works(author == "Melville, Herman")

View(melville)

Now, in the code block above, I am setting up a variable. Notice again how I created the code block with the tick marks and the r in blacks. I start off by naming the variable whatever I want to be. In this case, I made it melville.

Then, I assign a function to the variable by doing this <- __. So in this case, the function is gutenberg_works(author == “Melville, Herman”). This function pulls from the gutenberg database and looks at all the works with the author Herman Melville. After that, I choose the function “View”, and then insert the variable melville, to invoke a data viewer for the variable I just created. So, a table will pop up with the gutenberg id assigned to the text and its corresponding title name. In other words, a table will pop up with all the available texts in the gutenberg database that are encoded with r. This allows us to see what texts are available for us to work with.

bartleby <- gutenberg_download(11231, meta_fields = c("title", "author"))

View(bartleby)

Now, for the code block above, we’re setting another variable. This one is a bit more complicated, but there’s really nothing to worry about. The variable name, as you can see, is called bartleby. Any guesses as to why that’s so? If you guessed that its because we’ll be working with and setting a variable for the metadata for “Bartleby”” from the gutenbergr library, you’re exactly right!

In the previous code block (lines 38-42), we looked up the list of works by Melville. Since we looked up their r code, we were also able to see the works’ ID numbers. For “Bartleby, The Scrivener”, it was 11231. So, for the variable, I created a commanded gutenberg_download(work ID #). In addition to that, I instructed that I wanted the data (and thus text) for the title and author to be shown as well in the data chart.

I should mention that the little green arrow in the top right hand corner of the text block (the one that looks like a ‘play’ button) has a useful function. It means to run the whole block of code, in order. Another way to do that is to just put my cursor on a certain line, then press command (or option) and then enter.

Thus, when I run the whole code block, it will load the entire text of “Bartleby, the Scrivener.” The c stands for combine, which combines the values / functions into a vector or list. So in this case, we combine and include title and author into the list. As a result, this information ends up becoming very repetitive (the text ID # on every single line, in addition to the title and author), but I think that when we do more complicated commands that deal with multiple texts and perhaps even authors at once, it will make perfect sense to have the information for each of the columns. That is especially relevant if we will be analyzing and comparing/contrast differences between works of an author, works of more than one author, things like word and phrase trends during certain time periods, etc. This segues perfectly to the next code block.

words <- bartleby %>%
  unnest_tokens(word,text) %>%
  anti_join(stop_words) %>%
  count(word,sort = TRUE) %>%
  ungroup

View(words)

I mentioned above that the green arrow runs the whole code block in order, and that doing command/option + enter while putting my cursor on the specific line will run just that line of code. The cursor + command enter line is much more useful in the code block above. Notice the weird text that’s after several of the lines. It looks like this %>%. That’s called a pipe, and it connects the separate line of code. It tells the program where a line of code stops and where another one ends. Just putting enter will not do anything, since its only for aethetic purposes and the program will not treat it something like a new line because of an enter. An easy way to remember and make sense of this is to think about real pipes, which connect things like water fountains and sinks. The pipe will allow water to flow into the machine, then allows water to drain/flush back out. In the same way, the pipe command will tell the program, “Hey, here’s a new line of code, which means this code is ending. So don’t combine the two lines together.”

As I mentioned above, the line of code are separate lines for aesthetic purposes. I could just make the code block all one line with the pipes in between, but its just easier on my eyes to see which lines of code I’m working with.

Now, for the coding itself. We make another variable, this time, called words. I use a previous line of code, bartleby, which was in the previous code block. The the entire text for Bartleby, as you remember. Then, the pipe. So onto the next line.

The next line has something that includes unnest_tokens and(word,text). When I look up what that does (going to console, and typing in ?unnest_tokens…), then it will say in Help that unnest_tokens “splits a column into tokens using the tokenizers package, splitting the table into one-token-per-row.”

So what does that mean? From my understanding, that command is going to split and basically parse/examine the string of data we have from the tidytext library (which we loaded way above at the beginning), and the unit by which we do that are “word (words)”. Remember that we’re making words the variable, and that a previous variable (bartleby) is the variable for that. And then of course bartleby is the variable we set as the entire text of Bartleby. It’s a lot of layering, I know. But that fits in well with the idea of a continually flowing stream that flows through connected pipes. So, the pipe indicates that we should look at the next line.

This next line includes something about anti_join and stop_words. First, we must know what stop_words are. Stop words are words that don’t really have an assigned meaning to them. So for example, a lot of particles of speech like “a, an, the” do not have a meaning within themselves. So, we don’t want to include those in our commands, because who gives a hoot about the usage and frequency of those words? That’s not what we’re going for.

So, what are we going for? Remember that we’re working with the variable words. After parsing the data (each word, essentially) for Bartleby (the variable and the whole text iself), we’re now taking out the stop_words from that comprehensive Bartleby variable. Why are we doing this? Let’s take a look at the next line.

This next line is saying something about count. We’re counting the words (again, in Bartleby, excluding the stop words). I’m not quite certain what that TRUE is there for, but I think it menans to only list (sort) the words that hold true for the previous commands and lines of code. So, we’re only going to be listing the counts (frequencies) for the words in Bartleby that are not stop words. And we did that by pulling from the gutenbergr database, after looking at all the works by Melville. Phew.

Now, I’m not quite sure what that ungroup does, but when I looked it up, it said that “Most data operations are done on groups defined by variables. group_by() takes an existing tbl and converts it into a grouped tbl where operations are performed “by group”. ungroup() removes grouping.”

That had me scratching my head, but I think that means that we’re looking at all the different variables in here as separate. Yes, they build off each other and are nested within each other, but perhaps ungrouping clarifies the distinction between those variables and clarifies to the program that we’re looking at them separately, despite them being so nested within each other. Ovbiously, I’m just speculating, and I’m not sure if what I’m saying is the most logical thing, but I thought it wouldn’t hurt to at least say what I think it means.

Analysis and Reflection

And now, for the analysis and reflection of this whole experience.

This was initially such a frustrating assignment. I was dismayed the first time we started working with R. I had a lot of my mind, and then having to suddenly figure out this new language and programming to complete the next couple of labs sounded really daunting. I was quite discouraged at first, even though I was well aware by my classmates’ round eyes and sticky notes on their laptops that I was far from being the only one who was confused. I remembered back to when I was working with Markdown and thinking that was difficult. Oh my, how I long to be just working in Markdown again. I thought that Markdown was just working with plain, plain text and coding, but now I see that even Markdown still has a lot of presets and things like that in place. Something about seeing my code immediately transform visually made me a lot more sure of myself, while with R, I have to explain a lot of things to myself and do a lot of trial and error (not to mension several questions to David and Professor Cordell) to make sure that I have the basic idea of the coding and what means what. Something about having to have the perfect code to even see if I did it right when I run it makes it a bit more frusting. But then, when I think about it, I also had to do much the same for Markdown, its just that I could see my changes a lot quicker and really visualize if I did the right thing. For example, if I wanted to insert a picture in Markdown, I could toy around with the brackets and link just a little bit to get that picture in there, since I do remember the basics that I need to name the link for the picture and then do something with the brackets. So I guess its a different sort of visualization where I really have to be more conscientious about each step.

Now, this reminded me of something way at the beginning of Sydney Padua’s “The Thrilling Adventures of Lovelace and Babbage.” Its actually in the section that real and isn’t the alternate reality/world/progression of the real story. In that section, we see Lovelace at a party where Babbage is talking about his difference engine. He says on page 20-21,

“…. and I conceived that arithmetical calculations of great complexity can be effected by mechanical means! Observe the wheels they will produce a series of numbers according to one law. It is impossible, from its very structure, for the machine to produce any other number. We may predict the engine will continue on this series, without althernation, for eternity. But AHA - the mathematicians amongst you will perceive an unexpected result! How is this possible? How mnay machinery, without intervention, produce a variation? Another axis, hitherto hidden, has been brought into operation!”

What I got from this is what according to the laws of the logical world, a is always supposed to lead to b. That is when Babbage says “according to one law… it is impossible.. for the machine to produce any other number.” So basically, a cannot lead to c. It just can’t, and that will always be the case (“we may predict the engine will continue…. for eternity”). But then, Babbage says somethign about an unexpected result, since “another axis once hidden is now brought into play.”

I thought that that quote was a perfect analogy for how Markdown code builds off each other. Within the context of this lab, the various variables built off each other. When we worked with the first variable, things seemed very binary, yes and no, this is that. But then when we introduced other variables in and built them off each other, then we were able to create more complex results and get what we wanted. So, at first, there was no just one way to see how many of each words were in Bartleby. There was just no one line of code to do that. (“Observe the wheels they will produce a series of numbers according to one law. It is impossible, from its very structure, for the machine to produce any other number.”) But then when we built off variables, and kept doing that, we were able to get a result that once seemed impossible. The nestedness and the charactization of building off each other (and how the pipes also signify the code builds off each other = “Another axis, hitherto hidden, has been brought into operation!”) What once seemed impossible is now possible because we built off each the code, because one thing led to another, and to another, and to this result that seemed impossible. So, after all, a can equal and lead to c, or even d or e (you get the idea!) because a -> b -> c -> d, a -> d, a = d.

But we should also think of R coding in general.

Every time I looked up a code online, it would always mention who developed the line of code. And when were were working with the poetry bots today, and when David was guiding us through a lab, both Professor Cordell and David mentioned that they came up with coding themselves. So that just goes to show how coding and commands themselves are also new laws and rules in the world of R, just like how the rules and laws in the case of this lab were the variables and how they built off each other. And now, we can build off different lines of code and connect them together to achieve so so much. There are endless possibilies! Actually, Lady Lovelace’s response to Babbage’s quote above perfectly fits this idea of unlimited possibilities. She says on page 22,

“It can tabulate accurately and to an unlimited extent all series whose general term is comprised by the formula (complicated math equation, lets not bother with trying to input it, please.)!!! Indeed, ALL other series which are capable of tabulation by the method of differences!!”

To which Babbage responds, “Exactly!”

We’ve worked with tables before, yes? Of course we have! The variables for this whole lab were all organized in tables! And if we build off what I just said about R coding commands that are being written and invented all the time, and variables building off each other, this really emphasizes how there’s unlimited possibilities with R coding. We will always be building off other’s work, always using different variables within those commands, and at this point, a can more than equal e, a can equal z!

What else can a equal?

Lady Lovelace says on page 26, “Indeed, we may consider the engine as the material and mechanical representative of analysis! Such a science of operations has its own truth and logic… a process which alters the relation of two or more things… any process it might act upon other things besides number…. the bounds of arithemetic have been overstepped!”

So a can more can equal z. a can equal another dimension (the bounds… overstepped). a can equal 1, a can equal ㅂ (a korean syllable).. a can equal anything!!

Before I go, I would like to point out that Lady Lovelace seems to be defining this exact infiniteness and greater purpose of R and coding and variables on page 27.

“In enabling mechanism to combine together general symbols in sucessions of unlimited variety and extent (R code and variables building off each other!!) … a uniting link is established between the operations of matter and the abstract mental processes of the most abstract branch of mathematical science! (two wholly unrelated fields can explain each other –> you could start off somewhere and end up with a result that seems completely infeasible with where you started off with!). The engine could analyze all subjects in the universe! A new, a vast, and powerful language is developed for the future use of analysis, in which to wield its truths! Almost a political science (and we started off with math!)”

Just looking at the illustration above the quote on page 27 demonstrates the infinite possibilites. And all that is because the difference engine facitilied this new political science language that is somehow removed and somehow so connected to math from the difference engine.

In the same way, R can facilitate infinite possibilities, it can create poems to tweet to Twitter, it can create cool and colorful graphs and charts, all because its a language that builds off each other and in the process, is translated to something else that transforms…

Happy coding!

Note that the echo = FALSE parameter was added to the code chunk to prevent printing of the R code that generated the plot.

Lab 8

2018-03-27T00:00:00+00:00

Set up

library(tidyverse)
library(tidytext)
library(gutenbergr)

Interesting Code

cage <- gutenberg_download(1144, meta_fields = c("title", "author"))

This line of code is the first time I’ve used code to make a table. In other languages, whenever we want to represent table we’ll just make a 2-D array, which is a list of lists, or we’ll make a dictionary which is a data structure made of key-value pairs. However, as the lab progresses I begin to see the flexibility of R tables and how adaptable it is.

The next section talk about the wide range of functions R has. R being a weakly typed language where you don’t have to declare the type of a variable, it is very convenient to reassign variables and change the contents. Looking at this code below

words <- cage %>% 
  unnest_tokens(word, text) %>%
  count(word, sort = TRUE) %>%
  ungroup

it is exactly the same thing as

# re-declaring cage variable in case cage gets mutated in the code above
cage2 <- gutenberg_download(1144, meta_fields = c("title", "author"))
words2 <- unnest_tokens(cage2, word, text)
words2 <- count(words2, word, sort = TRUE)
words2 <- ungroup(words2)

# test if words is the same as words2
print(all.equal(words2, words))

I have used pipes before, though the symbol for piping is

instead of %>%. I wanted to understand how the functions take the table as inputs so I looked up the functions in the R documentation and found the parameters each function takes. The documentation shows that all the functions above, unnest_tokens, count, and ungroup, all take a data frame as the first argument.

The Compiler

This made me start thinking about how the compiler, the thing that turns human-readable code into something the machine can read, parses the arguments. How does it know to use the results of the left of the pipe as the input to the right of the pipe? How does it know when there’s a pipe that there won’t be a data frame in the function? I struggled to conceptualize the inner-workings of exactly how the compiler breaks down the code. In Padua’s The Thrilling Adventures of Lovelace and Babbage, the difference machine truly breaks down the action of simple mathematical operations to the most basic steps. The carrying action in basic math was such a complex mechanism in the difference machine that it took Babbage a long time to construct something that completes the task.

Usually a compiler has a parser or sometimes called a tokenizer that breaks down a large string of text into smaller segments usually seperated by spaces and symbols. When we read books we often see words and sentences as one large entity. In fact, it deosn’t mttaer in waht oredr the ltteers in a wrod are, the olny iprmoetnt tihng is taht the frist and lsat ltteer be at the rghit pclae. The rset can be a toatl mses and you can sitll raed it wouthit porbelm. Tihs is bcuseae the huamn mnid deos not raed ervey lteter by istlef, but the wrod as a wlohe (From research done at the University of Cambridge)[https://www.mrc-cbu.cam.ac.uk/people/matt.davis/cmabridge/].

However, compilers and parsers care about the exact spelling of a word. In certain programming languages such as Python, compilers even care about the number of spaces and using tabs versus spaces. Parsers will increment character by character and if the spelling is slightly off, the parser will not recognize the word. If Babbage did create a spellchecker machine, the machine would take a very long time to check a word because the machine would need a list of all the words out there and check the given word to the list to see if the given word exists, if it doesn’t exist then there’s a big chance that there is a typo. But this approach does not take into consideration of valid ngrams and valid sentences. If we scale this approach to have a list of ngrams the runtime of the machine will be quadratic by the size of the ngram which will take a very long time without the technology of modern processors. So if a simple spellchecker is this complicated to create, how did Lovelace even theorize a compiler for code? The intellectual capacity of Ada Lovelace still fascinates me everytime.

The Syntax

As a computer science major, I’ve been introduced to a lot of different languages. When we had the in-class activity of reading the twitter bot code, I didn’t have much trouble understanding what the code is trying to accomplish. However, when I was going through this lab, some of the lines of code puzzled me so much. I remember just sitting there staring at one line of code

ggplot(plot_austen[1:20,], aes(word, count, fill = title)) +
  geom_bar(stat = "identity") +
  labs(x = NULL, y = "Frequent, Significant Words in Jane Austen's Novels") +
  coord_flip()

and being utterly confused. So it’s plotting with a table named plot_austen but it’s a bar graph? Where the x values are null?? NULL? null is nothing? No x values? Then you flip the coordinates? So y is nothing? And you add everything together?

My favorite professor of all time, Professor Olin Shivers, taught me that good code is code that you can reason about. Code is written for humans to read. These are two objectives I keep very close to my heart as a programmer. Just like proofreading in English, programming requires coding reviews by others before a segment of code can be shipped. There are a lot of ways to say something in English and one small tweak can change the entire meaning of the sentence. Similar to code, there are many ways to achieve the goal of the program; however, if other people don’t understand your code or if you don’t know how to explain your code then you won’t be able to reach your audience or scale the code to do something bigger and better.

Documentation

I’ve always been a huge fan of reading up on documentation when I want to find out more about a specific function or if I’m confused about how a function works. So throughout this fieldbook I’ve consulted on the following documents many times.

(R Documentation)[https://www.rdocumentation.org]
(gutenbergr library)[https://cran.r-project.org/web/packages/gutenbergr/gutenbergr.pdf]

Contemporary Connections

2018-03-27T00:00:00+00:00

Column A	Column B
Cambridge Analytica	Sydney Padua, Lovelace & Babbage
Facebook phone tracking	Vikram Chandra, “The Beauty of Code”
Uber self-driving car accident	Annette Vee, “Understanding Computer Programming as Literacy”
Another current tech story

Choose one from column A and one from column B. How does the reading from class help you reflect on the real-world story?

Poetry Bot Prep

2018-03-27T00:00:00+00:00

There are a few things you can do to prepare for next week’s poetry bot lab and ensure we can get started in short order. You’ll need to create a few accounts from which we’ll either be drawing or to which we’ll be adding data:

Sign up for a Wordnik account and then sign up for a Wordnik API Key. Wordnik is an open-source dictionary from which we will be drawing words to fill in our mad libs.
If you want to post to Twitter, you will need to create a new Twitter account for your bot. Think about what kind of bot you want to make and then sign up. Be sure to add a mobile number to the account, as we’ll need that for one the steps later on.
While signed into your new account, visit Twitter’s Application Management site. You will want to Create New App. Fill out the required fields and then click Create Your Twitter Application. Then click on the name of your new app, navigate to Settings, and set your app’s Callback URL should be set to http://127.0.0.1:1410. Then navigate to Permissions, select Read and Write, and save settings. We’ll be getting some essential information from the Keys and Access Tokens menu during our Twitterbot lab.

Computational Reading II

2018-03-27T00:00:00+00:00

Fieldbook Prompt

As we did for Lab #8, I encourage you to experiment with this code in a new RMD file. Copy, paste, adapt, run, revise, run again. Can you import a different genre of literature from Project Gutenberg, for instance, and analyze it in the ways we did for science fiction? See the project’s bookshelves to figure out what you would substitute in the code to do this. Can you experiment with the paramenters of the code in other places: look at a different sentiment, for instance, or change the number of topics in your topic model? Ultimately, your fieldbook should think through the potential (and potential pitfalls) of these sorts of computational text analysis. What new possibilities do methods such as sentiment analysis or topic modeling open, and what aspects of the texts they are used to study are obscured by such methods? Finally, what other patterns might you be interested in tracing across a large collection of books? For this last question, don’t worry about whether you know how to code such an analysis—instead, focus on what you would want to do if you had the requisite familiarity with programming.

Lab 8

2018-03-27T00:00:00+00:00

Computational Reading I

Even though it is a relatively simple feature, I was very much drawn to the

  select(text,title)%>%
  filter(text != "")%>%
  na.omit()

bit of code we worked with in class. Of course, in its form above it will not do anything, so inspired by the end of The Thrilling Adventures of Lovelace and Babbage I also wrote this little bit of code to pull in Alice’s Adventures in Wonderland for the feature to actually work.

library(tidytext)
library(tidyverse)
library(gutenbergr)

alice <- gutenberg_download(11, meta_fields=c("title","author"))

alice <- alice %>%
  select(text)%>%
  filter(text != "")%>%
  na.omit()

View(alice)

Looking at the variable ‘alice’, most people would identify it as Alice’s Adventures in Wonderland without issue, but in reality this particular form of it is a different novel. Alice’s Adventures in Wonderland is a completely different story without its specific formatting and John Tenniel’s illustrations. Part of the reason I like the function I picked is because it seems so simple, like it is only making a text easier for formatting, but it realistically does more than that. I hate to continually reference ‘the medium being the message,’ but this is an instance where, when aesthetic features are removed, the reaction to the text becomes different. Like George Eliot’s book that was not actually George Eliot’s book in The Thrilling Adventures of Lovelace and Babbage, the text is treated as an object of analysis to be ripped apart and put back together again.

On the one hand, that is distressing for a lover of literature. It seems blasphemous to have such disregard for the structure of the novel and to treat the spacing and stylistic flairs as unimportant. But on the other hand, is that not what literary analysis generally does? Will not (most) every literature professor tell their students to disregard the author’s intention and treat the text as their own to rip apart and reassemble in the way they find meaningful? Is that not essentially what an essay is, a blend of original information polluted with external input?

Thinking of it that way, it is interesting to interpret the type of textual analysis we did in this lab as somewhat like literary composition. In a way, it is reminiscent of a grossly simplified type of erasure poetry. The author of the code filters out the words in the book that do not contribute to their storyline, similar to how an author of erasure poetry filters through what is already there to create something entirely new.

Similarly, generating ngrams is poetic in a way, reminiscent of Ernest Hemingway’s ( almost certainly misattributed ) six word memoirs. Though ngrams’ use for finding the reproductions of texts in newspapers in the 19th century was mentioned during the lab, as a self contained unit each ngram either tells its own story or hints at part of one. It creates a somewhat beautiful relationship between literature and programming that is particularly striking when thinking of how programming and literature fields have been separated in the past several years.

This distinction need not exist, though. Historically, some of the best programmers have not distanced themselves from creative fields. As Sydney Padua writes about towards the end of The Thrilling Adventures of Lovelace and Babbage, both Ada Lovelace and William Rowan Hamilton were interested in poetry, and even though it may not have been ‘good,’ literature quality is subjective, and the point is that this separation between computers and literature has been drawn in nonsensically somewhere along the way.

Code is much more similar to literature than it might initially appear, and thinking about it as such is important for multiple reasons. Of course, it is useful for breaking down social barriers and helping to eliminate somewhat elitist attitudes that, realistically, have appeared on both sides of the technology/humanities schism. But also artistic expression has been shown to have a noticeable psychological impact when dealing with mental health issues, as well as simply improving work function. Coders today are some of the most stressed employees on the planet, constantly getting burnt out, and allowing for more creativity could (could, not necessarily would) help with those issues.

Looking at how code and literature are related is good, but it can also be beneficial to think of how code could learn from, or be inspired by, literature. I know no more code than what we have learned in this class, but there is still the potential for coding to change if it is looked at as something creative, rather than strictly an input to create an output. It is impossible to predict the future, but it is always fun to think about how the technology of programming will change as it becomes more accessible. And who knows, maybe one day people will be writing their poems in code.

Reading, Writing, and/or Coding

2018-03-20T00:00:00+00:00

Writing in Code (AKA Coding)

Often, when we think about coding, or the act of writing code, the idea of writing often gets lost in translation. The term “writing” is reserved for putting pen to paper, or even hand to keyboard, while coding is…well…coding. It is often considered an entirely different process, and in many, it is. But like language, code, even the bits of it that are numbers or symbols, needs to be written. The ways in which code is, and is not, like a writing system is a topic worth deeper exploration. Code is, at its core, built on language; but, that language is not necessarily built on an alphabet. Often, it is comprised more of symbols than it is of letters. Sometimes, its even built through a hand-held hole-puncher.

R (u kidding me?)

Working through the in-class Computational Reading lab was interesting, at its best moments, but mostly infuriating. I like to think that I’m relatively tech-savvy - I know how to write and read basic HTML, can maneuver my way through some Adobe products, and keep up on all things IoT-related. Jumping into R, however, was like playing a whole new ballgame. I actually had a much easier time reading the printed out Mystery Code in class than I did reading the code intermingled with text during the lab through RStudio.

My lowest point in the lab came from this tiny, but powerful, few lines of code:

cage$text

Whichever “run” button I clicked, rather than running the code to read the entirety of In the Cage in the console, to my dismay, ran the code up in the actual writing area of my window. I still have yet to figure out how to make it go away, and thus, am forced to scroll through a few hundred lines of Henry James to read the latter half of the lab lesson. I’ll fix it, eventually.

There were more ups than downs, however, particularly surrounding our conversation on words and mapping their frequency in a text using code. Particularly, this fragment of code about Jane Austen:

book_words <- austen %>%
  unnest_tokens(word, text) %>%
  count(title, word, sort = TRUE) %>%
  rename(count = n)
  
total_words <- book_words %>%  
  group_by(title) %>%
  summarize(total=sum(count))

book_words <- left_join(book_words, total_words)

Running this code and seeing the way that words were operationalized was illuminating. Words are data, much in the same way that code is data (and, in the same way that words are code, though not necessarily vice versa). With a few lines of key phrasing and carefully-written code, the most popular words of Austen’s fiction can be streamlined into consumable, traceable data.

The idea that words are data, and data can be coded, is nothing new. Like the way 19th century newspapers are run through OCR programs to copy the paper printed text onto a computer so it can be stored, searched, found, and archived is incredibly similar to what the code above was able to accomplish with Austen’s full repertoire of novels. By turning the individual words into data, literature takes on a new life form: “unnest_tokens” is like command + F on crack. We can find things we didn’t even know we were looking for buried in the text, or rather in the data of the text, and illuminated by the code.

Words as Code, Code as Holes

In Chapter 5 of Gleick’s The Information titled “A Nervous System for the Earth,” he explains the history of the telegraph. But, more importantly, the way that the telegraph contributed to the history of writing in code.

“…So code books became phrase books. Their object was a sort of packing of messages into capsules, impenetrable to prying eyes and suitable for transmission. And of course, at the recipient’s end, for unpacking (155).”

While the code Gelick is talking about is more in the realm of cryptographers than in the world of programming, the idea of packing messages into capsules that are hard to read by an untrained eye is a vital common thread. Code like R or HTML is a language, built on grammar and syntax and slang, that can be learned and understood, much in the same way that code phrases like “gmlt” (Give my love to) or “ymir” (Your message is received) are codes built on the language of the time, meant to be understood only by those who were trained to read them. In this way, cryptographers of the late 19th century were coders in the very essence of the word. Code books helped to encourage and enable an unprecedented code literacy.

In RStudio, we can take a bit of code, encapsulated by the {r} / at its beginning and end, write in a language only those taught how to read and understand it can decipher fully, and click a button to “read” the code and transmit its message into something bigger than itself. The lines of cryptography and programming, in this sense, heavily overlap.

In the same way that cryptographers could assign meaning to the variables of code that were being written, so, too, can programmers assign meaning to their code with written processes:

cage <- data_frame(text=read_file("http://www.gutenberg.org/cache/epub/1144/pg1144.txt"))

Though the name of the variable is inherently arbitrary, it still holds a great amount of importance - it’s how we assign data, and therefore meaning, even if only temporarily. Making meaning out of letters, phrases, symbols, and their various combinations, is the driving idea behind how code is read. When we create a variable, we create meaning.

As I mentioned earlier, not all of coding language is built on an alphabetized language like the code of telegraphy. Sometimes, it is built on - or, rather, in - the holes of punch cards.

One of my favorite pages of Padua’s The Thrilling Adventures of Lovelace and Babbage comes on page 90. Here, the author explains the idea behind the Analytical Engine’s use of punch cards to run its program. Number Cards, Variable Cards, and Operational Cards - these punch cards made of carefully places holes were the data and the code “written” to enable the machine to run. Each type of card holds a particular function, much like the way coding phrases such as ‘view’ initiate a particular function within the code. Each function allows the Analytical Engine to operate as a (relatively) well-oiled machine, working together to compute and analyze the data being punched/written/coded/compiled.

In Padua’s Pocket Universe, Lovelace writes her programming code with a Compiler Organ. In this way, the code of the punch cars is composed, rather than written - it is music, rather than language. The 0s and 1s were formed a melody that results in the sweet, sweet sound of mathematical accuracy. Or, when all else fails, a picture of a kitten (80).

Reading Code

One of my favorite bits of code came up during our discussion of creating concordances of texts using code:

austen_words %>% mutate(word2 = lead(word,1)) %>% head

Through mapping Jane Austen’s works, word-by-word, this particular slice of code allows us to read the novel in a new way - we can think about the novel and its use of language in a way that would have required hours of tedious labor without the power of code. When we learn to work with and read code, we can learn to read literature with a new, more analytic lens.

In the case of Lovelace and Babbage, the code of the Analytical Engine was made up of the empty space of a hole punched into cards, created in a particular pattern to hold meaning when ran through the machine. For people in the 19th century communicating via the telegraph, abbreviated letters and numbers in the place of full phrases only held meaning for those who knew the code they had been abbreviated in. And for modern day computer programmers, writing in HTML or CSS requires an in-depth understanding of the way that phrases are used to start certain tasks, to mean certain things, and to produce certain outcomes. No matter how code is written, whether as a language or not, there is an inherent need for literacy that comes with it, both to write it and to understand it.

In the same way that telegraphy coding systems “required prearrangement between sender and recipient,” so, too, does the coding of the Analytical Engine and the programmer (Gleick, 154). The only difference is who - or what - is doing the reading.

Computational Reading I

2018-03-20T00:00:00+00:00

Fieldbook Prompt

Your fieldbook for coding session 8 should be composed in RStudio, as a new RMD file (File —> New File —> R New File -> R Markdown). You should include some of the code you found most interesting/enlightening/infuriating. You can copy and paste from the RMD files we used in class. Make sure you code blocks are separated from your text. They should look like this, but with code in between:

Perhaps you can even try to tweak some of the code blocks to do new things. You can’t break anything. If something goes wrong simply clear the environment (using that broom icon in the Environment pane) and start again. If something goes really wrong, just copy the text from the lab files on Github and paste it into your RMD file. I and our practicum students are all available to help.

Remember that when you run this code you’re not making permanent changes to the actual data on the websites from which you imported it: you’re bringing the data into the R environment where you can experiment and yes, even make mistakes. In your fieldbook, ruminate on the code and its relationship to some of the ideas in our readings, particularly the Padua and Glieck. Start thinking about the relationships among code, writing, and literary analysis.