Modern philosophical anthropology can trace its genesis to early Enlightenment attempts to reconcile the naturalistic insight that humans are conditioned by history and nature with their status as ‘self-governing’ subjects. Although this project is associated with a post-Kantian idealist and hermeneutic tradition, the problem of reconciling nature with autonomy has not gone unaddressed in the post-war analytic tradition. Anglo-American writers like Sellars, Davidson, Dennett, McDowell and Brandom have made subtle attempts to account for the distinctiveness of human culture and agency while accommodating graded Darwinian commitments to explaining its emergence from pre-linguistic forms of representation or action.
Ray Brassier’s recent talk on Wilfrid Sellars’ account of language games ‘How to Train an Animal that Makes Inferences: Sellars on Rules and Regularities’ illustrates one strain of this Darwinian rationalism. According to this picture, non-rational beings may have adaptive responses to bits of their environments, but cognitively rational agents can have refined and well articulated thoughts about them. Cognitive rationality according to this view supervenes on practical rationality – a capacity to learn and apply public standards of conduct or warranted assertion.
For example, vervet monkeys will emit a distinct alarm call in response to the sighting of a leopard (‘a loud barking’) to the sound elicited by the sight of an eagle. The leopard alarm elicits a scramble to the ‘thinner branches’ of nearby trees (leopards being cats) whereas an eagle alarm causes a scramble under bushes where the vervets are safe from an aerial attack (Deacon 1997, 56).
These signals can be glossed in terms of their function in adaptively salient situations. However, according to the Sellarsian model of functional semantics which Brassier sets out, human sentences and thoughts don’t get their meaning by being coupled with specific environmental inputs and outputs in this way but only via inferential relations to other sentences and a class of rules which connect language to its outside: language entry rules (governing transitions from perceptions to observation statements) and language departure rules (governing transitions from beliefs/sentences to actions). It is our socially transmitted grasp of inferential norms and the rules for getting into and getting out of a language-game which constitute these links and thus meaning and thought itself.
Depending on a speaker’s knowledge state, the English sentence ‘The king is dead’ could license a vast range of inferences from the formal existential generalization ‘Something is dead’ to a range of material inferences such as ‘there is a new King and it is Pete’ or ‘Mission accomplished!’ and could, likewise, occur in response to a vast range of perceptions (seeing an obituary in a newspaper, observing the mistless speculum above the mouth of the expired monarch or a flat line on an oscilloscope, etc.). The dispositions that ground the inferential linkages between sentences and extra-linguistic events are highly complex. Finally, as Brassier emphasizes in his presentation, full linguistic competence includes the capacity to draw metalinguistic inferences about the linguistic utterances and inscriptions of an object language OL in a metalanguage ML (ML being a part of OL in natural languages).
According to Sellars, to ‘grasp’ the meaning of a term in a language is to have understood its position in this inferential economy rather than to stand in some non-natural relation to an abstract entity (Sellars 1974, 430). The capacity for rational thought, is likewise, a capacity for discursive thought insofar as unvocalized thoughts have the same inferential roles as sentences. This is no more problematic than ‘oder’ in German and ‘or’ in English being equifunctional since inferential roles are substrate neutral.
As Brassier says, this model of linguistic understanding is appealing to naturalists so far as it treats discursive thinking as an embodied competence or ‘know how’ rather some mysterious capacity for grasping abstract entities (Sellars 1954).
It also gives formal expression to the difference between animal signaling and human language. The adaptive role of a trait like the vervet alarm depends on its utility in a particular environmental context. The inferential role of a sentence is holistic since it depends on the inferential roles of all other sentences or words in a language. There is thus no way to map the selected function of a detection or signaling system onto an inferential role. Brassier argues that the distinction between evolved functions and rationally articulated inferential affiliations conceptually demarcates the objective order of things and the rational order of concepts.
Pressure can be applied to Sellars’ account without relinquishing its naturalistic insights, however. For example, once we allow that linguistic knowledge consists largely in grasping material inferences – those expressing domain-specific understanding – a principled distinction between semantic knowledge and knowledge of the world is difficult to enforce, as Donald Davidson has argued on independent grounds. A Davidsonian radical interpreter who wishes to interpret an alien language L from scratch might represent the inferential roles of the sentences of L in a recursive truth theory à la Tarksi but getting to this point would require the interpreter to have a large body of true beliefs about the features of the world that the utterances of L describe – e.g. the behaviour of colour predicates or the mechanical properties of liquids. If the knowledge of a successful radical interpreter of L is a model for the understanding of a competent speaker in L, then grasping meanings cannot be a matter of grasping intra-linguistic relationships alone.
Even the possessor of a semantic theory which works reliably over the community of L-speakers will confront refractory utterances in which the speaker might be construed as uttering nonsense, untruths, or, like Joyce and Mrs Malaprop, iterating words in ways not covered in the theory! In those cases she needs to decide whether to revise her theory or treat these cases as degenerate. It should be obvious that there could be no purely linguistic rules which determined how to proceed here since the problem is to determine what language OLj is being spoken by framing one’s metalanguage (the theory T for Lj) to fit the empirical facts. If the predicament of the radical interpreter is a model for the predicament of the ordinary speaker of a language, then we will regularly be in the position of having to figure out meanings that are not prescribed by shared rules.
Slavoj Zizek’s challenge in the Q&A session following Brassier’s talk exemplifies this situation nicely. He cites the following exchange between Ewan McGregor and Tara Fitzgerald’s characters in Brassed Off (the two characters are standing outside Fitzgerald’s house at night):
Fitzgerald: “Would you like to come in for a coffee”?
McGregor: “There is a problem. I don’t drink coffee”?
Fitzgerald: “I haven’t got any coffee”
Reading this armed with books of community-wide semantic and pragmatic theory alone would be idiotic. One needs to grasp standard usage sufficiently to know that the conventions are being joked to get the implicature of “I haven’t got any coffee.” But the ‘prior theory’ of English is just an input to interpretation. It does not afford a rule that assures a correct reading. If this kind of situation recurs in human social intercourse then there better be more to our ability to ken than our grasp of a prior set of inferential roles.
Languages as stable systems of conventions or rules shared between interlocutors need not exist for such interpretation to be possible (Davidson 1984, 14). Speakers may use words and different ways without communication being impossible. Even radical differences in usage need not forestall communication as along as they have the wit and luck to arrive at good passing interpretations of each another. It follows that language cannot be a kind of translucent glass which stands between human thinkers and an inhuman world. As Frank Farrell has observed, if the ontologically deflationary theories of thinkers like Davidson or Derrida are on the right track neither thought nor language can have the requisite “hardness” to stand between us and things in this way (Farrell 1996).
If so, Brassier’s conception of thought as an internally related ‘symbolic economy’ distinct from nature is unhelpful. Admittedly it provides an initially bracing way of understanding realism as a commitment to some radical difference between the non-conceptual world of transcendent nature and the immanent space of ‘reasons’. However, such invocations of radical otherness depend on a reification of something that is transcended by the Other and there are independent grounds for holding that this gives us a misleading account of the nature of both.
Davidson, Donald (1984). Communication and convention. Synthese 59 (1):3 – 17.
Davidson, Donald (1986). ‘A Nice Derangement of Epitaphs’, in Ernest LePore (ed.) Truth and Interpretation: Perspectives on the Philosophy of Donald Davidson (Oxford: Blackwell).
Farrell, Frank (1996). Subjectivity, Realism and Postmodernism: The Recovery of the World in Recent Philosophy ( Cambridge University Press).
Deacon, T. (1997). The symbolic species: The co-evolution of language and the human brain. London: Penguin
Sellars, Wilfrid (1954). Some reflections on language games. Philosophy of Science 21 (3):204-228.
Sellars, Wilfrid (1974). Meaning as functional classification. Synthese 27 (3-4):417 – 437.
On Thursday January 12, 6 pm I’m leading a discussion of Charles Stross’ Accelerando at the Extra-Curricular Reading Group in Bristol’s Spike Island Galleries. Free copies in various formats can be obtained here
Accelerando is perhaps the purest distillation of future shock in modern English prose, a comic extrapolation of life during a 21st Century technological singularity. Stross’ text gleefully tackles posthumanism, prospects for machine intelligence, post-scarcity economics, the mutability of identity, the implications of “cyborg embodiment”, the future of “life”, and our relationship to (furred/non-furred) non-humans.
The novel’s conceptual range and density may also be challenging for readers less familiar with modern SF or philosophical posthumanism. So I’ve included links to some wikis and other resources for navigating Accelerando below. Happy reading.
The Novel
Accelerando Technical Companion
Charles Stross’ diary entry on Accelerando
‘The Singularity is Here’ by Steven Shaviro considers Accelerando and Marxist critique of the commodity form. Read it here.
Anyone wondering what a ‘timing channel attack on the computational ultrastructure of space-time’ involves (Acc, 14, 147, 213)? This is for you!
Discussion of Aieneko and kitten uploads.
Some Key Philosophical Ideas
The Extended Mind (David Chalmers and Andy Clark’s classic paper arguing that some of our mental processes occur outside our bodies)
and Cyborgs (Donna Haraway’s cyber-feminist tract ‘A Cyborg Manifesto’)
David Roden, ‘Posthumanism and the Disconnection Thesis’ Disconnection_NEW7
(Forthcoming in The Singularity Hypothesis: A Scientific and Philosophical Assessment, Amnon Eden, Johnny Søraker, Jim Moor, and Eric Steinhart (eds.), Springer Frontiers Collection.)
Mind Uploading
Anders Sandberg discusses the ethics of mind uploading (Sandberg talks about some of the hypothetical scenarios narrated in Accelerando in this video interview)
Mind Uploading and Functionalism in Philosophy of Mind
Click tags for related discussions on this blog.
Reviews
‘Rights for Lobsters’ (Socialist Review)
The Internet Review of Science Fiction
Here’s the java code for jDelta: a sequencing object for the MAX MSP software environment that I wrote a few years ago. JDelta stores note pitch, note duration, velocity and note delta times. It plays back each note according to its delta time with respect to preceding notes in a sequence. The neat thing is that probability of each stored note event, its transposition, velocity and its length can all be manipulated via the PD arrays (notePD, etc.). So the stored sequence is a seed from which variable sequences can be generated on the fly.
This code is designed to be used in MAX MSP 5 (should be compatible with 6 but I haven’t tried it). Currently, the clock source is MaxClock. Similarly, there are other expressions here peculiar to code written for the max environment such as the ‘DeclarInlets’ statements which determine the number of inputs and outputs from the graphical max object. There are a lot of methods but their purpose has been documented as as far as I’m able. An example of a piece recorded using JDelta as a looping device is for my Ring Modulated Piano improvisation here.
Anyway, feel free to tinker around. I think a better programmer than me ought to be able to adapt this to work much more smoothly and maybe to load sequences from midi files (!).
An example of the MAX interface I use with jDelta is given with the link to RM piano.
***************************************************************************************************************************
import com.cycling74.max.*;
import java.util.HashMap;
import java.util.Random;
import java.io.*;
public class jDelta extends MaxObject
{
private HashMap <Integer, Integer> indexTable;
//To pair pitches with indices//
private HashMap <Integer, Double> timeTable;
//to pair pitches with relevant onset times//
private int min;
private int max;
private int index;
// Index for array assigns. Incremented with note on’s//
private int count;
// Count outputs note data, cycling through arrays//
private Random generator;
// instance variable representing random number generator//
private double onTime;
// holds time of note on//
private double masterDuration;
//Field to hold target duration value from external source
private boolean wrap;
//If wrap ‘true’ then sequence length is maintained at a constant duration
private boolean Sticky;
// keeps Max at last value to allow update at same sequence length//
private double lastDelta;
// holds value that is added to final delta time to increase length between end and beginning of sequence//
private double offTime;
// holds time of note ff//
private double noteDuration;
// holds noteDuration//
private double deltaTime;
// holds time beteween note on’s//
private double r;
// holds next random value//
private int [] pBank;
private int [] velBank;
private double [] ndBank;
private double [] deltaBank;
// Arrays storing pitch, velocity and note duration//
private int arraySize;
// Pass Banksize argument to arraySize for determining step time//
private int [] transBank;
private int [] velChangeBank;
// Arrays storing tranpose and velocity change data //
private double [] notePD;
// Stores doubles representing probability of note event//
private double [] transPD;
//Stores doubles representing probability of transpose event//
private double [] velChangePD;
//Stores doubles representing probability of velocity change event//
//
private double [] tempoBank;
// Array to hold tempo values//
private double [] tempoPD;
// array to hold probability of tempo changes//
private MaxClock clock;
private PrintWriter pw;
private int [] pitchBuffer1;
private int [] velBuffer1;
private double [] ndBuffer1;
private double [] deltaBuffer1;
private int [] pitchBuffer2;
private int [] velBuffer2;
private double [] ndBuffer2;
private double [] deltaBuffer2;
private int [] pitchBuffer3;
private int [] velBuffer3;
private double [] ndBuffer3;
private double [] deltaBuffer3;
private int [] pitchBuffer4;
private int [] velBuffer4;
private double [] ndBuffer4;
private double [] deltaBuffer4;
// Buffers for on the fly storage//
private static final String[] INLET_ASSIST = new String[]{
“inlet 1 help”
};
private static final String[] OUTLET_ASSIST = new String[]{
“outlet 1 help”
};
// variables for zip method//
// Minimum index of array to which zip applies//
int zipMin;
// Maximum index of array to which zip applies//
int zipMax;
// Number of steps by which indexed values are moved//
int zipAdd;
/** Creates a new instance of jDelta */
public jDelta(int bankSize)
{
declareInlets(new int[]{DataTypes.ALL, DataTypes.ALL, DataTypes.ALL });
declareOutlets(new int[]{DataTypes.ALL, DataTypes.ALL, DataTypes.ALL, DataTypes.ALL, DataTypes.ALL,
DataTypes.ALL, DataTypes.ALL, DataTypes.ALL, DataTypes.ALL, DataTypes.ALL, DataTypes.ALL });
setInletAssist(INLET_ASSIST);
setOutletAssist(OUTLET_ASSIST);
this.Sticky = false;
this.wrap = false;
this.masterDuration = 2000.0;
//initialise masterDuration to something!//
this.indexTable = new HashMap<Integer, Integer> ();
this.timeTable = new HashMap<Integer, Double> ();
this.min = 1;
this.count = 1;
this.onTime = 0.0;
this.index = 0;
this.lastDelta = 0.0;
this.arraySize = bankSize;
this.clock = new MaxClock(new Callback(this, “Play”));
this.pBank = new int [ bankSize ] ;
this.velBank = new int [ bankSize] ;
this.ndBank = new double [ bankSize] ;
this.deltaBank = new double [ bankSize];
this.transBank = new int [ bankSize];
this.velChangeBank = new int [ bankSize];
this.tempoBank = new double [bankSize];
//set all tempo values to 1 by default//
for (int i = 0; i < bankSize; i++)
{
tempoBank[i] = 1.0;
}
this.tempoPD = new double [bankSize];
this.notePD = new double [ bankSize];
this.transPD = new double [ bankSize];
this.velChangePD = new double [ bankSize];
this.generator = new Random();
this.pBank[0] = 60;
this.velBank[0] = 0;
this.ndBank[0] = 0.0;
this.deltaBank[0] = 0.0;
pitchBuffer1 = new int [bankSize];
velBuffer1 = new int [bankSize];;
ndBuffer1 = new double [bankSize];
deltaBuffer1 = new double [bankSize];
pitchBuffer2 = new int [bankSize];
velBuffer2 = new int [bankSize];;
ndBuffer2 = new double [bankSize];
deltaBuffer2 = new double [bankSize];
pitchBuffer3 = new int [bankSize];
velBuffer3 = new int [bankSize];;
ndBuffer3 = new double [bankSize];
deltaBuffer3 = new double [bankSize];
pitchBuffer4 = new int [bankSize];
velBuffer4 = new int [bankSize];;
ndBuffer4 = new double [bankSize];
deltaBuffer4 = new double [bankSize];
}
public void Reset()
{
index = 0;
count = 1;
}
public void giveMin(int intMin)
{
min = intMin;
count = intMin;
outlet(4, count);
}
public void giveMax(int intMax)
{
max = intMax;
outlet(4, max);
}
public void getWrapValue(int anInt)
{
// Determines whether wrap applies. Inputting 1 turns on wrap
if (anInt == 1)
{
wrap = true;
outlet(10, 1);
;}
else
{
wrap = false;
outlet(10, 0);
}
}
public void Sticky(int anInt)
{
// Determines whether wrap applies. Inputting 1 turns on wrap
if (anInt == 1)
{
Sticky = true;
outlet(10, 1);
;}
else
{
Sticky = false;
outlet(10, 0);
}
}
public double giveFinalDelta(double aDouble)
{
lastDelta = aDouble;
return lastDelta;
}
public void setFinalDelta(double aDouble)
{
lastDelta = aDouble;
}
public void getDuration()
{
double durationSum = 0.0;
for(int i = min; i <= max ;i++)
{
durationSum = durationSum + deltaBank[i];
}
outlet (8, min);
outlet(9, max);
outlet(6, durationSum);
}
public double returnDuration()
{
double durationSum = 0.0;
for(int i = 0; i <= max ;i++)
{
durationSum = durationSum + deltaBank[i];
}
return durationSum;
}
public double getRunningDur()
{
double durationSum = 0.0;
for(int i = min; i <= (index-1) ;i++)
{
durationSum = durationSum + deltaBank[i];
}
outlet(11, durationSum);
return durationSum;
}
// Get running total of durations prior to the duration to be entered into deltaBank//
public void getMasterDuration(double aDouble)
{
masterDuration = aDouble;
outlet(6, masterDuration);
}
public void Start()
{
clock.delay(0.0);
}
public void Stop()
{
clock.unset();
count = 1;
}
// Determines pitch, velocity, note duration and delta time for a given array index//
public void list (int [] aList)
{
if (getInlet() == 0)
{
if ( aList[1] != 0)
// If a note on…//
{
deltaTime = (clock.getTime() – onTime);
// Calculate deltaTime by substracting last onTime from current time. On first note onTime is
//initialised to zero
onTime = clock.getTime();
// update onTime//
if(wrap == false)
{
deltaBank[index] = deltaTime;
//Sends delta to index associated with previous note – prior to incrementing index
if (index < (pBank.length – 1))
{index = index + 1;}
else
{index = 0;}
// note on increments index if less than array length and zeros it otherwise//
outlet(4, index);
if(Sticky == false)
{max = index;}
outlet(9, max);
pBank[index] = aList[0];
velBank[index] = aList[1];
// Assigns pitch and velocity//
this.indexTable.put( aList[0], index);
this.timeTable.put( aList[0], onTime);
//associates current index and current time with the input pitch//
}
else
//If Wrap is enabled…
{
if (! (!((getRunningDur() + deltaTime) < masterDuration)&& !(index == 0)))
// If the delta time plus sequence length is less than desired duration or index = 0 it can be safely added to deltaBank//
{
deltaBank[index] = deltaTime;
//Sends delta to index associated with previous note – prior to incrementing index
if (index < (pBank.length – 1))
{index = index + 1;}
else
{index = 0;}
outlet(4, index);
max = index;
outlet(9, max);
// note on increments index if less than array length and zeros it otherwise//
pBank[index] = aList[0];
velBank[index] = aList[1];
// Assigns pitch and velocity//
this.indexTable.put( aList[0], index);
this.timeTable.put( aList[0], onTime);
//associates current index and current time with the input pitch//
}
}
}
else
// If a note off…//
{
offTime = clock.getTime();
//records time of note off//
noteDuration = (offTime – this.timeTable.get( aList[0]));
// calculates note duration by subtracting time of note on for the same pitch, retrieved from the
//hashtable
ndBank[this.indexTable.get( aList[0])] = noteDuration;
this.timeTable.remove( aList[0]);
this.indexTable.remove( aList[0]);
//removes mappings//
}
}
if (getInlet() == 1)
{
if(aList[0] == 3)
{
for (int i = 1; i < aList.length; i++)
{transBank[i] = aList[i];}
}
if(aList[0] == 4)
{
for (int i = 1; i < aList.length; i++)
velChangeBank[i] = aList[i];
}
}
}
public void Export () throws IOException
{
String fileName = MaxSystem.saveAsDialog(“Save As”, “Filename”);
DataOutputStream os = new DataOutputStream(new FileOutputStream(fileName));
for(int i = 0; i < pBank.length; i++)
{
os.writeInt(pBank[i]);
}
for(int i = 0; i < velBank.length; i++)
{
os.writeInt(velBank[i]);
}
for(int i = 0; i < ndBank.length; i++)
{
os.writeDouble(ndBank[i]);
}
for(int i = 0; i < pBank.length; i++)
{
os.writeDouble(deltaBank[i]);
}
os.writeInt(min);
os.writeInt(max);
os.writeInt(index);
os.close();
}
//Import with dialog//
public void Import() throws IOException
{
String fileName = MaxSystem.openDialog(“Open File”);
outlet(10, fileName);
DataInputStream is = new DataInputStream(new FileInputStream(fileName));
for(int i = 0; i < pBank.length; i++)
{
pBank[i] = is.readInt();
}
for(int i = 0; i < velBank.length; i++)
{
velBank[i] = is.readInt();
}
for(int i = 0; i < ndBank.length; i++)
{
ndBank[i] = is.readDouble();
}
for(int i = 0; i < deltaBank.length; i++)
{
deltaBank[i] = is.readDouble();
}
min = is.readInt();
max = is.readInt();
index = is.readInt();
is.close();
if(wrap)
{
// If wrap is enabled reduce number of sequence steps (max) to fit within duration. Final duration added on play//
while((returnDuration() > masterDuration) && max > 1)
{
max = max – 1;
}
}
outlet(4, index);
outlet(8, min);
outlet(9, max);
}
//Import with prepend to fileName//
public void Insert(String fileName) throws IOException
{
fileName = “/Applications/Max5/patches/delta clips/” + fileName;
File f = new File(fileName);
outlet(10, fileName);
DataInputStream is = new DataInputStream(new FileInputStream(f));
for(int i = 0; i < pBank.length; i++)
{
pBank[i] = is.readInt();
}
for(int i = 0; i < velBank.length; i++)
{
velBank[i] = is.readInt();
}
for(int i = 0; i < ndBank.length; i++)
{
ndBank[i] = is.readDouble();
}
for(int i = 0; i < deltaBank.length; i++)
{
deltaBank[i] = is.readDouble();
}
min = is.readInt();
max = is.readInt();
index = is.readInt();
is.close();
if(wrap)
{
// If wrap is enabled reduce number of sequence steps (max) to fit within duration. Final duration added on play//
while((returnDuration() > masterDuration) && max > 1)
{
max = max – 1;
}
}
outlet(4, index);
outlet(8, min);
outlet(9, max);
}
public void write()throws FileNotFoundException
{
String fileName;
fileName = MaxSystem.saveAsDialog(“Save As”, “Filename”);
pw = new PrintWriter(fileName);
for(int i = 0; i < pBank.length; i++)
{
pw.print(pBank[i]);
}
for(int i = 0; i < velBank.length; i++)
{
pw.print(velBank[i]);
}
for(int i = 0; i < velBank.length; i++)
{
pw.print(ndBank[i]);
}
for(int i = 0; i < deltaBank.length; i++)
{
pw.print(deltaBank[i]);
}
pw.close();
}
public void list(double [] list)
{
if (getInlet() == 1)
{
if(list[0] == 0.0)
{
for (int i = 1; i < list.length ; i++)
{notePD[i] = list[i]/100.0;}
}
if(list[0] == 1.0)
{
for (int i = 1; i <list.length; i++)
{transPD[i] = list[i]/100.0;}
}
if(list[0] == 2.0)
{
for (int i = 1; i <list.length; i++)
{velChangePD[i] = list[i]/100.0;}
}
if(list[0] == 3.0)
{
for (int i = 1; i <list.length; i++)
{tempoBank[i] = list[i]/100.0;}
}
if(list[0] == 4.0)
{
for (int i = 1; i <list.length; i++)
{tempoPD[i] = list[i]/100.0;}
}
}
}
public void beatOut(int i, int p, int v, double nd)
{
if ( r < notePD[i])
{
outlet(0,p);
outlet(1,v);
outlet(2, nd);
}
outlet(5, count);
}
public void Play()
{
double delayTime = 200.0;
if (wrap == false)
{this.deltaBank[max] = (this.ndBank[max] + lastDelta);}
//Final delay is defaulted as equal to final note duration when lastDelta = 0.//
else
setFinalDelta(masterDuration – getRunningDur());
{this.deltaBank[max] = lastDelta;}
getDuration();
// If Wrap is on, then the last delta is set at the difference between the running dur prior to max and the desired duration. Just need to ensure differnce always pos//
this.r = generator.nextDouble();
outlet(3, r);
int p = pBank [count];
int v = velBank [count];
double nd = ndBank [count] ;
// assign array values to local variables
if(r < transPD[count])
{p = pBank[count] + transBank[count];}
if(r < velChangePD[count])
{v = velBank[count] + velChangeBank[count];}
beatOut(count, p, v, nd);
if( r < tempoPD[count])
{
delayTime = (deltaBank[count]*tempoBank[count]);
}
else
{
delayTime = deltaBank[count];
}
clock.delay(delayTime);
if (count < max)
{
r = generator.nextDouble();
count = count + 1;
}
else
{
count = min;
}
}
protected void notifyDeleted()
{
clock.release();
post(“Feck”);
}
}
Alan Moore’s graphic novel Watchmen (filmed back in 2009 by Zack Snyder) is an anti- superhero tale about super anti-heroes. Some of these ‘costumed adventurers’ are obsessives driven by the thrill of dressing up and breaking heads; others are co-opted by political interests or have shadowy agendas of their own. The Watchman known as ‘The Comedian’ is an amoral killer on a fat CIA remittance. The only one with actual superpowers, the glowing blue god Dr Manhattan, casually maintains US nuclear Hegemony, but sees humanity as a lower order of being than the inert desert of Mars.
Watchmen honours superhero tradition by sheathing these vigilantes in improbable tights and by culminating in a desperate battle to prevent a maniac killing lots of Americans. Here, though, the balletic combat is futile. As snippets of broadcast TV testify, the Americans are long dead before the first blow lands, and the architect of the plan, Ozymandias – AKA the ‘Worlds Smartest Man’ – is just a Watchman with a self-prescribed remit to usher in an era of global peace.
Ozymandias informs his fellow Watchmen that he has saved the world from nuclear annihilation by gulling the US and USSR into uniting against an illusory alien menace (the story is set in an alternative 1980′s during Nixon’s third term). To simulate this threat convincingly, though, he has had to kill half the population of New York with a vile artificial life form.
Ozymandias seems like an obvious candidate for villain (This is a comic book after all). Yet whether this is so, turns on the solution to the classic philosophical problem of ‘dirty hands’.
Ozymandias’ provides a consequentialist argument for his actions. Pure consequentialists believe that actions must be judged according to the value of their outcomes. Thus if the murder of a million New Yorkers is preferable to the death of billions in a nuclear war, it is better to murder a million New Yorkers.
Once they learn that nothing can prevent the deaths, all but one of the Watchmen agree they are ‘morally checkmated’.
Only Rorschach – so-called for the mutating inkblot concealing his face – contests this. He holds that some actions are intrinsically wrong and must be condemned irrespective of any beneficial outcomes they may produce (the philosophical term for this position is deontological ethics).
Who’s right?
Let’s assume for that Ozymandias is factually correct in believing that humanity would have been destroyed had he not acted. This is the kind of thing we might expect the World’s Smartest Man to know. But Ozymandias has committed murder on the scale of a Hitler or a Pol Pot. Surely, his actions are wrong, no matter what?
So is Rorschach right?
Well, if he is, then Ozymandias should be killed or punished and the plot revealed. But Rorschach’s insistence seems wrong-headed. As Dr Manhattan points out ‘Exposing this plot, we destroy any chance of peace, dooming the Earth to worse destruction’.
Moore reinforces this impression by portraying Rorschach as a moral fanatic obsessed with punishment for its own sake. Ozymandias, by contrast, appears reasonable and genuinely pained by the deaths he has caused. So we seem confronted with four alternatives.
Either:
Ozymandias is right to sacrifice millions to save billions.
Or Rorschach is right.
Or they are both wrong.
Or they are both right.
The last possibility can be discounted if their positions are genuine contraries. However, there is another way of interpreting these moral claims. In his famous work, The Prince, Nicolo Machiavelli argued that canons of moral right have little place in politics. When deciding the future of a state (or a planet), we should be prepared to commit evil acts to secure the paramount goal of political order.
Machiavelli’s position is a kind of consequentialism. However, he does not claim that conventionally evil acts cease to be bad when performed for worthy political ends. If judged according to the principles of public morality they are necessary and bear testimony to the prowess of a Prince (or a Superhero). But they’re still wrong according to the standards of personal morality.
Thus, adopting Machiavelli’s position, we can regard Ozymandias as having performed a very ‘dirty’ but necessary act. Both his position and Rorschach’s can then be affirmed on different grounds. Is this a satisfactory resolution of the dilemma? One could object that any claim that an act is politically necessary must involve an appeal to moral grounds if it is not to be merely cynical – and Ozymandias, unlike the Comedian, is no cynic. Thus it remains troublingly uncertain whether this anti-superhero tale contains a genuine super-villain.
© The Open University 2011, all rights reserved
More Open University Philosophy @
OpenLearn: Introducing Philosophy
References: Alan Moore and Dave Gibbon, Watchmen, New York: DC Comics, 1987. Zack Snyder, Watchmen (2009).
There’s an instructive debate going on between Graham Harman at Object Oriented Philosophy (henceforth OOO) and Levi Bryant over at Larval Subjects (henceforth LS) about whether Derrida’s work is serviceable for realism. OOO is emphatic: not only is Derrida not a ‘plug and play’ realist, his work has no realist application at all. Unlike Heidegger – whose account of withdrawal can be given a realist spin in Object-Oriented circles – Derrida’s position is not amenable to realist use or even to creative abuse. Here’s OOO:
I think it’s simply madness to call Derrida a realist. His entire argument makes sense only by identifying realism with onto-theology and hence with parousia/presence. He reads the concept of substance as the foot soldier of onto-theology. His critique of the proper is a very frank critique of realism. His theory of the trace is another anti-realist maneuver, not a realist one since that would open the door, in his view, to the “transcendental signified.”
There’s obvious textual support for OOO’s position. Derrida does claim in Of Grammatology that infrastructures like trace and différance provide a condition of possibility for presence and ‘onto-theological’ thinking without being presences or grounding entities themselves. Indeed, for Derrida, they provide the invisible underside or ‘tain’ of all thought, reflection or representation.
The term Différance, like its cognate infrastructural markers ‘trace’ and ‘supplement’ and ‘iterability’, is an economical allusion to structures of negation, co-involvement and co-implication within general textuality. Textuality, for Derrida, should not be identified with language. A text, according to Derrida, is any structure that can be characterized by such operations and relationships. For example, any text will have to consist of elements that are minimally repeatable: ‘A sign which would take place but “once” would not be a sign: a purely idiomatic sign would not be a sign’ (SP, 50) Language is the paradigm of this, but Derrida argues that even the neural memory trace within Freud’s prototype theory of neural networks has to be reactivatable to do its job – though each reactivation alters the relative amenability to stimulation that differentiates it from other memory traces (WD). Derrida’s analysis of the neural trace in ‘Freud and the Scene of Writing’ meanwhile refers to his earlier analysis of Husserl’s account of temporal awareness. Again, this requires any ‘now’ to be implicated with a retained past while potentiating a not yet determinate, novel future. Thus as Derrida claims in ‘Signature Event Context’ structures like spacing, trace and iterability are invariants. They extend to all representation, to all experience (LI 10).
Derrida’s claim about general textuality may all seem like an excessively subtle way of saying that meaning and content cannot be instantiated in formless pap. However, the infrastructural account has the virtue of extreme generality. It is something very much like a textual ontology – even if JD never conceded this.
Enter LS who makes the central point that iterability (one of the textual infrastructures) requires that entities cannot be dissolved into their relations. Since he is an object-oriented philosopher he frames this as a claim about objects: ‘For Derrida, it seems, any object can be severed from its relations to other objects.’ This is important because Derrida is usually cast as an arch-holist. But it is obvious to anyone who reads him carefully that this is not the case. LS is alluding, of course, to passages such as following one from ‘Signature Event Context’:
Every sign, linguistic or nonlinguistic, spoken or written (in the usual sense of this opposition), in a small or large unit, can be cited, put between quotation marks: in so doing it can break with every given context, engendering an infinity of new contexts in a manner that is absolutely illimitable . . . This citationality, this duplication or duplicity, this iterability of the mark is neither an accident nor an anomaly, it is that (normal/abnormal) without which a mark could not even have a function called ‘normal’ (LI, p. 12).
So while Derrida may not be a realist, it is clear that he cannot be a holist. No text is exhausted by its passing affiliations. This also means that Derrida cannot be a relativist since relativism requires relativization to some constraining super-context. Iterability says, in effect, that there is no super-context: all contexts are fragile and open. ‘Mass’ may play a different role in Newton to the role it plays in Einstein (for whom there is both relativistic and proper mass) but this does not mean that the two terms are just their respective theoretical roles. Can this point be generalized to get us something like realism? Well, we need to ask: ‘Realism with respect to what?’ Both LS and OOO use the idiom of things or objects. So if LS is right and iterability requires that things be reusable from context to context and Derrida is committed to iterability, then Derrida is committed to things. Ergo, he’s a realist about objects. But OOO is probably right to insist that Derrida’s no thing fan.
However, it may be that Derrida has ontological commitments to things other than things. An iteration like my quotation/mention of ‘if’ in this sentence is an event. For texts (in the general sense) to work there need to be events that are both differentiated and repeatable. What makes this further ‘if’ a token of the same type as this ‘if’ is not its instantiation of a common signifying essence but its iterability. So Derrida is committed to events and he’s committed to relations of repetition between event instances. This means that he’s committed to repeatable events, of course. But there are different models of repetition. Here’s Nelson Goodman: ‘
Repetition as well as identification is relative to organization. A world may be unmanageably heterogeneous or unbearably monotonous according to how events are sorted into kinds (WWW, 9).
THIS is relativism: repetition is relative to organizing scheme. But it’s clear that Derridean repetition cannot be scheme-relative in this sense because that would limit iteration to super-contexts and iteration is ‘absolutely illimitable’. So, as I argued long ago in RQRR, we have to say that Derridean repetition is real repetition. Since repetition occurs to events, these must be structurally repeatable. Derridean events are repeatable particulars, however, not abstract events of the kind posited by Ronald Chisholm. So Derrida is a) not a relativist and b) he is ontologically committed to repeatable particular events and their repetitions. So Derrida is a realist with regard to events and their repetition. However, these occurrences are realized they occur independently of organizing schemes or concepts. They are mind-independent, then, insofar as their occurrence does not depend on the constitutive activity of subjects and language users.
Abbreviations:
Derrida:
LI Limited Inc., Samuel Weber and Jeffrey Mehlman (trans.),
(1977; Evanston Ill.: Northwestern University Press, 1988).
OG Of Grammatology, Gayatri Chakravorty Spivak (trans.),
(London: Johns Hopkins University Press, 1976).
SP Speech and Phenomena, David Allison (trans.),
(Evanston Ill.: Northwestern University Press, 1973).
WD Writing and Difference, Alan Bass (trans.),
(1967; London: Routledge and Kegan Paul, 1978).
Others:
WWW Nelson Goodman, Ways of World Making (Indianapolis: Hacket, 1978).
RQRR, David Roden, ‘Radical Quotation and Real Repetition’, Ratio (new series) XVII 2 June 2004, 191-206.
Thanks to Leon Niemoczynski at After Nature for providing a link to this valuable resource.
In “The Trace of Time and the Death of Life: Bergson, Heidegger, Derrida” Martin Hägglund gives a brilliantly clear exposition of Derrida’s trace as a relationship that undermines both the continuity and punctate discreteness of time and poses an “arche-materiality” of time against a vitalistic/continuist conception of temporality.
The trace-structure is the minimal form of any temporality – an inextricable relation to a past that has never been present. Derrida might, on first reading, appear to endorse something like a vitalist or continuist conception of time. He accepts that temporality requires the displacement of temporal event from itself: a series of absolutely independent nows would not be a temporal series, any more than an unrepeatable sign could signify anything.
However, it is not merely the time of consciousness or life: of memory and habit, say. According to Derrida, this displacement is always “inscribed” in some material-spatial medium. E.g. Freud’s purely neurological trace consists of difference in the conduciveness of neural pathways to stimulation – a primary basis for memory which is always repeated differently (iterated) as a result of the causal action on neural tissue of subsequent stimuli.
The synthesis of time cannot be appropriated without spatial support by an immaterial life or subjectivity, or Dasein, etc.Haggelund concludes that this implies an asymmetric dependence of life on matter. The living depends on the non-living but is contingent product of a physical nature characterized by an arche-material temporality. Life, consciousness etc. depends on the material existence of the trace but not vice versa. The trace is (somehow) built into physical reality but it is equally implicit in inorganic or mechanical existence. The zombie-like repetition of the trace is as implicated in the most vivid conscious experience as it is in the evolution of material inorganic structures.
In Splice, Freeze, Stretch and Mutate: Digital rhythm as harbinger of the event Eleni Ikoniadou asks if the manipulation of microsound in granular synthesis reveals a “rhythmic time” below the level of our awareness of temporal succession. More microsound here!
R. Scott Bakker has a polemical post on the strange case of Harman and Metzinger here.
Recent Comments