# A Mind for Madness

## Mistakes From My First Game

We’re headed into the #7DRL Challenge. Last post I described what I was going to make, how I was going to make it, and what I hoped to get out of it. Today I want to describe things that were done terribly in my first game that I hope to do better this time.

I’ve seen a few of these posts popping up. They mostly say things like, “I tried to do too much,” or “I tried to put non-essential things in before the core was done.” I don’t want to get into any of those vague issues. I actually want to get into some hardcore implementation errors I made.

I’m going to use the term “game engine,” so I want to make sure people understand what that means in this context. Roughly speaking a game is a finite state machine simulation that either live updates at a certain rate or updates upon user input. The engine refers to the main pieces that loop to make that machine continue.

To big game developers, there’s probably a lot more parts (like preprocessing the 3D animation pipeline, etc), but for my 7DRL it consists of initializing/loading the pixel art and starting statistics, an update loop, and a draw loop. The way the monogame engine works is that the draw loop will attempt to be called at a fixed fps (I’d guess 60 is default, but have never looked it up).

The update loop is always called at that base fps. User input is captured in a queue and then handled in the update loop. For example, if the player presses the up arrow, the update loop catches this by going through a bunch of if statements. One of those will be “if user presses up: increase the y-position by 1″ (actually decrease due to how the screen coordinates go, but let’s not get into that). Then since the draw is independently updated with the most current positions of everything, the avatar will move.

All of this goes on forever unless something causes the big game engine loop to break (e.g. “if player health <= 0: break"). This brings me to my first error. I thought that because my game was turn-based, i.e. nothing on the screen would move or update until the player pressed a key, I didn't have to separate the update logic from the draw logic and I didn’t have to call either until the queue caught new user input.

This is a pretty big error. This meant that my entire engine stalled until the player pressed a key. It didn't cause any issues in the game per say, but it is very bad form. You need at least one moving part, some people would say two, at all times. What if you wanted to implement something that relied on real time and not just game time? What if you wanted to have a resting animation for the sprite? The ways in which this limits the creator are endless, and it is sort of hard to see until you make the mistake yourself and try to expand the game.

Also, keeping the draw and update loop separate is very important when graphics are involved. For example, if you have a lot of processing power needed to render your 3D animations, then you might need to drop frames to prevent lag. If the loops were tied together, then the game engine itself will experience lag and maybe even miss user input. If they are separate, the animation loop is free to lag without the rest of the engine lagging.

My next set of mistakes were object-oriented ones. My hierarchy of objects was poorly designed. Actually, there was no hierarchy. This caused excessive amounts of repeated code. The player had a position, health, attack damage, attack method, takeDamage method, and so on. The enemies did, too. I should have made a superclass with those attributes and methods from which both could inherit.

A related mistake was that I broke encapsulation … a lot. Because I had all these separate objects that needed to know about all the other objects and alter them, I kept passing all these raw values around and changing them. This is very bad, and caused many headaches when something went wrong. A few times I had trouble tracking down how a particular value changed in an incorrect way, because everything had permission to change everything.

I should have made a well-planned, clean hierarchy, and then let the main engine handle making all of the updates and changes that needed to happen.

The last thing I want to talk about is a little subtle. The object-oriented approach at first glance seems well suited for this type of finite state machine. You have a bunch of instances of enemies, each have a bunch of attributes, and the changing of these is essentially the game.

For a small scale project this is fine. What you will find as your game gets more and more diverse is that your hierarchies will get out of control. If you subclass every time there is a split, you will end up with insane code: new Character.Enemy.EnemiesThatFly.FireEnemy.NoMagicSkills….

I know you're thinking that these were just poorly chosen subclasses. It is an art to balance when to subclass. Many of these could be combined, and then leave an attribute null or unused when that particular enemy doesn't use the attribute. But remember, we're talking about a large scale game with lots of diversity.

It is a simple application of the pigeonhole principle that your unused attributes will also get out of control if you don’t subclass enough. This isn't good either. There is simply no way to create a set of well-balanced classes in a pure hierarchy once the attribute size gets large enough.

There is another way! It is called an Entity Component System (ECS). Instead of thinking in terms of objects, think in terms of the components. One component might be health. So you pull this out into a struct or class that has the health attributes and methods (not to mention, if you make your components structs of integers, you can work on the stack which will speed up CPU time rather than allocating on the heap with those classes).

Now everything in the entire game is an Entity, and you make an Entity Interface to interact with these components. Usually people will tag each Entity upon creation with a unique ID. This turns the game machine from updating a bunch of abstract, separate instances of classes to something more like updating a database.

Not only does this provide a cleaner approach from a coding standpoint, but it also makes many things easier. For example, in an RPG, maybe you have an ice spell that only affects flying enemies that are fire based (see subclass issues example above). It could be hard to find these if you've been instantiating them in the level at random and just have a big array of instances of enemies.

With the ECS framework you can query all Entities where the flying and fire based components are set to True. Or maybe you have a weapon which damages the wings of a flying enemy and it no longer possesses the special qualities of a flying enemy. Would you take the same enemy and create a whole new instance of a whole new class to do that? It would no longer be the "same" enemy in the code.

Again. This is really subtle, and probably is hard to tell why it works better from just thinking about it. You have to try the other way first to see what a pain it is to realize why the ECS framework simplifies this.

Since the 7DRL is under such tight time pressure, I'm not going to try a whole new coding framework for the first time during it. But I think I'll try to implement a hybrid OO/ECS approach whenever some obvious component jumps out at me.

Starting Saturday, you can expect this blog to turn into a Dev Log of the game. Hope to see you there.

## 7DRL Pre-Challenge Post

I’ll be blogging about my progress in the 7DRL Challenge, but I don’t want to waste time during that week posting all the stuff in this post which can be done now. If you don’t recall what a roguelike is why you should play them, see these posts: Why Play Roguelikes? and Thoughts on Permadeath. If you are interested in this challenge, there is still time to pull it together! The week is March 7-15.

Where I’m Starting:

Part of the rules of the 7DRL Challenge allows you to use generic pre-existing graphics/algorithms/game engines/etc. To be fair to the finished game, you should cite these sources. Here’s what I’m starting from (for why, see the sections below).

I’m building the game in C# through the XNA/Monogame framework and using a module called RogueSharp designed for making roguelikes in C#. The main use will be data storage and drawing of the level. For a generic template to start from, I’ve gone through this tutorial. My game will take this sample game and (radically) modify it.

See the section Core Idea for how I plan to build my own map generation if there is time. If there is not time, RogueSharp also has a built in algorithm I will use. As for graphics, I’ve spent some time playing with pixel art and learning to do animation in Monogame.

I will redo every one of these during the 7DRL week, but I needed some practice so that I wasn’t going in both learning to do pixel art and creating the sprites on top of programming the whole game. This seems fair, because anyone that has done any art for a previous game will go in with more experience than the couple weeks of practice I got from this.

Mechanics:

My game will be a traditional grid based movement (only up, down, left, right) and turn based (the enemies don’t move until you do).

I’m choosing to make the game a variant on the “One HP Model.” A pure one HP mechanic says that everything in the game has one hit before they die. This includes you. This makes the game similar to a game of chess. If you move a piece to where another piece is, this “attacks” and the other piece dies.

This turns the game into one of strategic positioning. As more and more enemies appear with various movement patterns, you must figure out places to stand where you will not be killed and a good order to kill the enemies.

Each game will basically be a sequence of increasingly difficult, randomly generated puzzles to solve (so it is completely different every time). Part of the initial fun is that you must work out what the AI movement patterns are for each type of enemy.

I will use a variant on this model that allows certain items to increase your health which will allow you to take two hits (I probably won’t go above two though to keep the pressure on). Also, most enemies will have more than one HP, but various weapons will still let you kill them with one hit. The details have yet to be worked out.

Core Idea:

The core story idea is Theseus in the labyrinth who must find his way to the center to kill the Minotaur. I would like to implement a system where backtracking is impossible. In modern interpretations of the labyrinth, the surrounding area constantly changes. This seems like an interesting procedural generation problem and adds a layer of difficulty to the gameplay since you can’t just leave something laying around to go back for.

I want there to be a punishment for running instead of “solving the puzzle” and killing all the enemies, but I also want the game to be winnable if you do this a few times. This will be a delicate balance that may not get worked out in a week. One easy punishment is to have a basic leveling system.

If you don’t kill the enemies, you don’t get the experience to level up and get stronger. This means that maybe later you need to hit some enemy a few more times making the strategy more complicated. The labyrinth design will also help balance this by not allowing the player to skip something too hard until they are stronger to go back to it.

I also want there to be time pressure. The game would become too easy if you could indefinitely re-position until you get a line of enemies to take out one at a time. There will not be a “hunger clock,” but I won’t spoil how this will be done right now.

What I Hope to Get From 7DRL:

I made a 7DRL before (well, it wasn’t done during the 7DRL or over the course of 7 days, but it is similar in size and scope). I built all the algorithms, data management, procedural generation, game engine, and everything from scratch. I did this to learn how all these pieces worked and interacted together.

I’m proud of the end result, but it isn’t very pretty. I used standard ASCII characters for graphics and made lots of stuff way too slow and clunky. I used python and pygame to do it. This caused lots of distribution issues because of dependencies and python versions.

Because I’ve done the inner workings before, this time I want to focus on some other aspects. I have no problem relying on a pre-built engine (monogame plus the tutorial), pre-built algorithms (RogueSharp), and so on. I want to get graphics, animation, and sound into the game. These are all things that were wholly neglected last time.

Rough Plan:

Day 1: Get a level displayed, redraw some sprites and get those displayed. Best case scenario, I can move through the level and once I’ve cleared the enemies I trigger the win condition.

Day 2: Solve the labyrinth procedural generation problem (i.e. put in multiple “levels”).

Day 3: Items, armor, weapons.

Day 4: Put in the rest of the enemies and start tweaking movement patterns.

Day 5: Catch up on days 1-4. If there is time, make a start screen, win screen, lose screen. Play for balance issues.

Day 6: Sound + animation.

Day 7: Debug + balance.

Most days I’ll try to update progress on this blog. On Day 5, I’ll probably want other play testers if you are interested in giving feedback.

## On Modern Censorship

I don’t want to wade into the heavy politics of things like GamerGate, MetalGate, and so on, but those movements certainly got me thinking about these issues a few months ago. A few days ago, I read a New York Times article about twitter shaming people out of their careers over basically nothing. This brought some clarity to my thoughts on the issue.

I’ll try to keep examples abstract, at the cost of readability, to not spur the wrath of either side. I haven’t done a post on ethics in a while, and this is an interesting and difficult subject.

First, let me say there are clear cases where censorship is good. For example, children should not be allowed to watch pornography (of course, there could be a dispute over the age where this becomes blurry, but everyone has an age where it is too young). There are also clear cases where censorship is bad. For example, a group of concerned Christian parents succeeds in a petition to ban Harry Potter from their children’s school.

Many arguments about censorship boil down to this question of societal harm. To start our thought experiment, let’s get rid of that complication and assume that whatever work is in question is fine. In other words, we will assume that censorship is bad in the sense that the marketplace of ideas should be free. If something offends you, then don’t engage with it. You shouldn’t go out of your way to make it so no one can engage with it.

In the recent controversies, there has been an underlying meta-dialogue that goes something like this:

Person A: If you don’t like the sexism/racism/homophobia/etc (SRHE) in this game/book/movie/etc (GBME), then don’t get the media. Stop trying to censor it so that I can’t engage with it. I happen to enjoy it.

Person B: I’m not trying to censor anything. I’m just raising social awareness as to the SRHE. It is through media that these types of things are perpetuated, and the first step to lessen this is to raise awareness.

What made this issue so difficult for me is that I understand both points of view. Person A is reiterating the idea that if you don’t like something, then don’t engage with it. There is no need to ruin it for everyone else. It is also hard to argue with Person B if they are sincere. Maybe they agree that censorship is bad, but they want to raise awareness as to why they don’t like the media in question.

The main point of this post is to present a thought experiment where Person B is clearly in the wrong. The reason to do this is that I think the discussion often misses a vital point: in our modern age of twitter storms and online petitions, Person B can commit what might be called “negligent censorship.” Just like in law, negligence is not an excuse that absolves you of the ethical consequences of censoring something.

Thought experiment: Small Company starts making its GBME. In order to fund the project, they get the support of Large Company that is well-known for its progressive values. In the age of the internet, news of this new GBME circulates early.

Person B happens to be a prominent blogger and notices some SRHE in the GBME. Note, for the purposes of this discussion, it doesn’t really matter whether the SRHE is real or imagined (though, full disclosure, I personally believe that people whose job it is to sniff out SRHE in media tend to exaggerate [possibly subconsciously] SRHE to find it where it maybe doesn’t really exist).

Let’s make this very clear cut. Person B knows that they can throw their weight around enough to get a big enough twitter storm to scare the Large Company backer out of funding the Small Company’s project. Person B does this, and sure enough, the project collapses and never gets finished or released.

This is clear censorship. Person B acted with the intent to squash the GBME. Sadly, Person B can still claim the nobler argument given earlier, and it is hard to argue against that. I think this is part of what infuriates Person A so much. You can’t prove their interior motivation was malicious.

But I think you don’t need to. Now let’s assume Person B does all of this with the good-natured intention of merely “raising awareness.” The same outcome occurs. Your intent shouldn’t matter, because your actions led to the censorship (and also hurt the livelihood of some people which has its own set of moral issues).

If you write something false about someone that leads to their harm, even if you didn’t realize it, you can still be charged with libel. Negligence is not an excuse. I’m not saying it is a crime to do what Person B did (for example, the SRHE may actually be there so the statements Person B made were true). I’m only making an analogy for thinking about negligence.

You can claim you only were trying to raise awareness, but I claim that you are ethically still responsible. This is especially true now that we’ve seen this happen in real life many times. If Person B is an adult, they should know writing such things often has this effect.

To summarize, if you find yourself on Person B’s side a lot, try to get inside the head of Small Company for a second. Whether intended or not, Person B caused their collapse. It is not an excuse to say Small Company should have been more sensitive to the SRHE in their GBME if they wanted to stay afloat.

This is blaming the victim. If Large Company said upfront they wouldn’t back the project if Small Company made their proposed GBME, it would be Small Company’s fault for taking the risk. If a group of people who don’t agree with the content of the GBME cause it to collapse, it is (possibly negligent) censorship.

Under our assumption that censorship is bad, I think Person B has serious ethical issues and Person A is clearly in the right. The problem is that in real life, Person B tries to absolve their wrong by implicitly appealing to a utilitarian argument.

A (non-malicious) Person B will truly believe that the short term harm of censoring is outbalanced by the long-term good of fighting SRHE. If the evidence was perfectly clear about the causation/correlation between SRHE in mass media and real life, Person B would have a pretty good ethical argument for their position.

What makes this such a contested issue is that we are in some middle ground. There is correlation, which may or may not be significant. But who knows about causation. Maybe it is the other way around. The SRHE in society is coming out in art, because it is present in society: not the other way around that Person B claims.

This is why, even though, with my progressive values, I am highly sympathetic to the arguments and sentiments of Person B, I have to side with Person A most of the time. Person B has a moral responsibility to make sure they raise awareness in a way that does not accidentally lead to censorship. This has become an almost impossible task with our scandal obsessed social media.

For the debates to calm down a bit, I think side B has to understand side A a bit better. I think most people on side A understand the concerns of side B, but they just don’t buy the argument. Many prominent speakers on side B dismiss side A as a bunch of immature white boys who don’t understand their media has SRHE in it. Side B needs to realize that there is a complicated ethical argument against their side, even if it rarely gets articulated.

I’m obviously not calling for self-censorship (which is always the catch-22 of speaking about these issues), but being a public figure comes with certain responsibilities. Here are the types of things I think a prominent writer on SRHE issues should think more critically about before writing:

1. Do I influence a lot of people’s opinion about SRHE topics? For example, having 200K twitter followers might count here.
2. Do my readers expect me to point out SRHE in GBME on a regular basis? If so, you might be biased towards finding it. Ask someone familiar with the GBME whether you are taking clips or quotes out of context to strengthen your claims before making a public accusation.
3. Are my words merely bringing awareness to an issue, or am I also making a call to action to censor the GBME?

## The Stack of Pitch Class Sets

I know it’s been a while since I’ve talked about either of these topics, but I’ve always been meaning to point something funny out. I thought I might formally work it out and write it up to submit to a music theory journal, but no one would probably accept it anyway. So I’ll sketch the idea now. Back here I talked about stacks as a useful way to generalize what we mean by a “space.” Back here I talked about the math behind the idea of pitch class sets.

I know Mazzola wrote a whole book on using topos theory in music, but I’ve never dug into it very deeply. I fully admit this is probably just a special case of something from that book. But it’s always useful to work out special cases.

Recall that a pitch set (or chord) is just converting notes to numbers: 0 is C, 1 is C#, 2 is D, etc. A given collection of pitches can be expressed in a more useful notation when there isn’t a key we’re working in. For example, a C major chord is (047).

A pitch class set is then saying that there are collections of these we want to consider to be the same. For one, our choice of 0 is completely arbitrary. We could have set 0 is A, and we should get the same theory. This amounts to identifying all pitch sets that are the same after translation.

We also want to identify sets that are the same after inversion. In the previous post on this topic, I showed that if we label the vertices of a dodecagon, this amounts to a reflection symmetry. The reflections together with the translations generate the dihedral group ${D_{12}}$, so we are secretly letting ${D_{12}}$ act on the set of all tuples of numbers 0 to 11, where each number only appears once and without loss of generality we can assume they are in increasing order.

Thus a pitch class set is just an equivalence class of a chord under this group action. It is not the direction I want this post to go, but given such a class, there is always a unique representative that is usually called the “prime form” (basically the most “compact” representative starting with 0).

Here’s where we get to the part I never really worked out. The set of all “chords” should have some sort of useful topology on it. For example, (0123) should be related to (0124), because they are the same chord except for one note. I don’t think doing something obvious like defining a distance based on the coordinates works. If you try to construct the lattice of open sets by hand based on your intuition, a definition might become more obvious. Call this space of chords ${X}$.

Now we have a space with a group action on it. One might want to merely form the quotient space ${X \rightarrow X/G}$. This will be 24 to 1 at most points, but it will also forget which chords were fixed by elements of the group. Part of the “theory” in music theory is to remember that information. This is why I propose making the quotient stack ${[X/G]}$. It seems like an overly complicated thing to do, but here’s what you gain.

You now have a “space” whose points are the pitch class sets. If that class contains 24 distinct chords, then the point is an “honest” point with no extra information. The fiber of the quotient map contains the 24 chords, and you get to each of them by acting by the elements of ${D_{12}}$ (i.e. it is a torsor under ${D_{12}}$). Now consider something like the pitch class set [0,2,4,6,8,10]. The fiber of the quotient map only contains ${2}$ elements: (02468T) and (13579E). The stack will tag these points with ${D_6}$, which is the subgroup of symmetries which send this chord to itself.

Now that I’ve drawn this, I can see that many of you will be skeptical about the simplicity. Think of it this way. The bottom thing is the space I’m describing. Each point in the space is tagged with the prime form representative together with the subgroup of symmetries that preserve the class. That’s pretty simple. Yet it remembers all of the complicated music theory of the top thing! If the topology was defined well, then studying this space may even lead to insights on how symmetries of classes are related to each other. Let me know if anyone has seen anything like this before.

## On Barthes’s “Introduction to the Structural Analysis of Narratives”

I feel I may have been a little unfair in choosing “From Work to Text” last post. In the same collection of essays, Image – Music – Text, is a much better introduction to what Barthes is known for: (post-)structuralism.

Recall that structuralism began back in the very early 1900’s (maybe even very late 1800’s) with linguists like Saussure. Barthes begins the essay by recalling this work. They studied the idealized structure of language and pointed out how this ideal linguistics may be different than actual usage. This gave a systematic way to go about studying it which was still important.

If you’ve ever tried to read any structuralism, then you know that it is full of jargon. The most important words to know are parole vs langue and signifier vs signified. Langue refers to the idealized language we study and parole to the use of language in everyday life. Signifier means the word itself (i.e. the collection of sounds or scribbles on the page) and signified is what the word refers to.

Barthes wrote this essay in the 70’s, so linguistic structuralism had essentially died at this point due to people like Derrida and Chomsky. But Barthes mostly brings up Saussure as an analogy to what he wants to do. Narratives are also composed of chunks which can be identified, and they are structured in a meaningful way which can be studied.

Barthes identifies three main levels of description for a narrative: function, action, and narration. He uses “function” for the smallest unit of a narrative, because it is to consist of things like Chekhov’s gun. One unit might be the reference of a rifle on the wall. The rifle will function later in the story.

Barthes finds that identifying the functional units becomes increasingly more complicated the more you think about it. For one, he makes an assumption I don’t quite agree with to make things easier: art has no noise. If the author refers to a red sweater, the detail is not just meaningless noise, it must have some significance. If you want a rule of thumb, the functional units will be roughly each sentence unless there is strong reason to divide the sentence or include two.

These units come in two types: functions and indices. We already pointed out that function means the unit serves a function in the narrative like the gun example. An index unit integrates more diffuse information like the atmosphere. To understand the meaning of this type of unit one must move to a higher level of description (action or narration).

He then goes on to classify functional units even further into four functions: nuclei, catalysts, indices, and informants. These are what they sound like. The nuclei form the core of the story in the sense that deleting one fundamentally alters the story; a catalysts makes an event happen; indices we described already; and informants identify a location in time and place for the narrative.

Barthes then goes on to describe ways in which these units can interact. For example, the catalysts act on various nuclei. If this interests you, read the essay, but it may be a useful exercise to think about it yourself.

He calls a logical succession of nuclei bound together in some way, a “sequence.” For example, a short sequence of three functional units could be: hand held out, hand shaken, hand released. This small sequence might sit in a larger “meeting sequence”: approach, halt, hand shake, sit.

The next level of description was action. In a narrative, each actor/character belongs to a sphere of action. There are relatively few spheres per narrative (compared to functional units), and these can be classified. He gives a brief historical summary of people’s attempts to do this, but we’ll skip that for the sake of space.

The important thing is to not confuse short, trivial actions, which are functional units, with large scale “actants” between the characters. The classification comes in three main types: communication, desire/quest, and ordeal.

Barthes’s explanation of the last level of description, narration, becomes characteristically vague, because he turns to the classic problem of reader/writer interaction. There is, of course, clear evidence of the narrator in a narration (the fact that the words are there at all!). It turns out, there is just as much evidence of a reader, but these are more subtle.

For example, if a narrator says that his friend Susie owns the coffee shop, this is presumably not to remind himself of a fact he already knows. It exists on the assumption that the reader does not know, and hence shows there must be a reader. He goes on to describe types of narration, which I’ve discussed here.

One of the main points of the narrative level is to integrate the lower levels into a coherent whole. He calls this integration whereas the other fundamental process is called segmentation. He goes on to describe how functional distortion of these units can have meaning. For example, the unit of shaking hands can be interrupted by a sequence of thoughts. It is one unit which has been distorted and segmented for a reason.

He gives some more examples of segmentation and integration, but that is the main idea of the essay. I think it is far better and more useful than “From Work to Text.” Although structuralism and post-structuralism were major academic movements, I feel, like Sontag, that a lot more popular criticism can make use of structural analysis.

## On Barthes’s “From Work to Text”

Roland Barthes was a prolific and important academic literary critic in the mid 20th century. He published many books, but his most famous are probably S/Z, Mythologies, and Image – Music – Text. The essay “From Work to Text” comes from this last book.

I thought I’d continue from Sontag into Barthes, since he was mentioned in the last post. She was one of the main academics to introduce him to the U.S. Unfortunately, I’ve always found him quite difficult to read. To me, his academic style (or at least the translation of it) makes it difficult to tell whether there is serious content in what he is saying or if he hides behind the abstraction.

“From Work to Text” starts from the idea that in modern critical theory we use the “capital T” Text in a different way than the “work” of literature. The way in which he teases out the difference is through a sequence of numbered comparisons. I warn you. This is going to get strange.

The Text cannot be put into strict categories and genres. A work can. The Text subverts classification. A work can be seen, but the Text demonstrates. The work is physical (i.e. a book), but the Text is language and non-physical. The Text is always paradoxical.

A work is symbolic and to be interpreted. The Text “practices the infinite deferment of the signified.” In this sense, the Text is radically symbolic, because its language never ends unlike the limited symbols of a work. The Text is plural in the sense of transcending all interpretation, not because it is ambiguous, but because of its inherently infinite nature.

There is no origin of the Text which sits in a seamless relation to all other texts. Sources and influences are a myth with the Text unlike a work which sits in an ordered string of influence. In other words, there is a relation between author and work. The Text comes into being through The Author, but the difference between reading and writing is abolished in the Text.

One plays the Text rather than reads it so that there is a collaboration. Still, no matter how we try we can never fully articulate what the Text is.

On the one hand, I get what he is saying. The essay is an attempt to explain what he sees as the difference in usage by a particular academic community. The problem is that I can’t tell if it is serious or if it is meant as some sort of hyperbole to make fun of the academics which try so hard to distinguish these things. To me it reads as academic satire, but from what I’ve seen elsewhere, this is to be taken seriously.

Except for the over-the-top parts, it does a fair job at teasing out the intended difference and many people summarize the distinction he makes as coming from seven places: method, genre, signs, plurality, filiation, reading, and pleasure. When put in this way, it is easier to see that he tries to tease out the difference between “high literary art” and “low popular fiction,” a debate that is notoriously difficult to this day.

I’m curious if anyone else has had better luck with understanding the Barthes hype.

## On Sontag’s “Against Interpretation”

I meant to do this a while ago as a contrast after the series on Hirsch’s Validity in Interpretation. If you are unfamiliar, Susan Sontag was a well-known cultural critic and essayist (among other things). She started publishing in the mid 60’s and continued all the way into the 2000’s. “Against Interpretation” was published in 1966.

The context here is interesting. Hirsch reacted to the New Criticism as somehow being too loose. You could make anything mean anything through a close reading. He wanted only certain narrow, well-justified interpretations to be valid. In “Against Interpretation” Sontag also reacts to the New Criticism, but in the opposite direction: the whole idea of interpretation is wrong-headed.

She begins by lamenting for a time when we weren’t so inundated with theory. She argues that we’ve become too obsessed with content. We tend to approach a work of art ready to interpret and extract its content. We start pulling out symbols and translating these into some meaning before we even have a chance to experience the work.

Art is supposed to be messy, complicated, and uncomfortable at times. The act of interpretation clears out the mess, simplifies it, and makes it comfortable. We often feel an overwhelming urge that works of art must be about something. How often do you hear, “I’ve heard of that book. What is it about?”

It is even possible that the artist intended certain objects to be interpreted as symbols, but the meaning is not what gives art its merit. Abstract art tries to be all form and no content in order to resist the destruction of interpretation. But artists shouldn’t have to flee from interpreters in order to escape.

In the seventh section of the essay, Sontag makes a startling prediction. “The fact that films have not been overrun by interpreters is in part due simply to the newness of cinema as an art.” I think from our vantage point, 50 years later, we can say she was correct. Open any newspaper or go to a film blog or find an academic journal of film studies. Cinema gets dissected through interpretation as much as any other art form.

She ends the essay with a solution to this problem of over-interpretation. Commentary and criticism are both possible and necessary. We need to switch from our obsession with content and talk more about form. She points to Barthes and others for people who have given solid formal analysis. We could also try to “reveal the sensuous surface of art without mucking about in it.” We can focus on description rather than on what you think the description means.

When we interpret, we take the sensory experience for granted. The purpose of art is to be experienced, not over-analyzed. “Our task is to cut back content so that we can see the thing at all.” The goal of criticism should be to make works of art more real to us. “The function of criticism should be to show how it is what it is, even that it is what it is, rather than to show what it means.”

Now that I’ve summarized the essay, I’ll comment on it. I think this is in some sense an overreaction or maybe even a straw man argument. For example, Hirsch, who values the author’s intent, would probably say that if the author intended for the work to be a purely visceral experience with no excess symbolism in it, then to read that symbolism in it would be an invalid interpretation.

More specifically, genre matters. Some genres call for detailed, complicated interpretation and some call for no interpretation. Sontag’s essay seems to call for a complete rejection of interpretation whereas the other side seems to argue that if you want to interpret, then here are some tools for it.

Maybe this is the 50 year gap, but I don’t know anyone that calls for always interpreting all the time. Even the most analytic of critics would admit that it is perfectly valid to just experience a work sometimes. So I guess I’m somewhat confused at what this essay is really arguing against.

On the other hand, I fully agree that we often over-analyze and reach for interpretations without first experiencing a work. I absolutely hate the question: what is that about? Romance novels can be about something. A TV sitcom can be about something (or in a particularly famous case about nothing). Essays can be about something. Great art stops being art if you try to reduce it to some five sentence plot line. The thing that it is about is not the thing that makes it worth experiencing.