Feminism and Programming Languages

In the scope of my research, feminist programming language is to be built around a non-normative paradigm that represents alternative ways of abstracting. The intent is to encourage and allow new ways of thinking about problems such that we can code using a feminist ideology. 

To succinctly sum up my research thus far I will outline the decomposition of my question below:

The idea came about while discussing normative and feminist subject object theory. I realized that object oriented programmed reifies normative subject object theory. This led me to wonder what a feminist programming language would look like, one that might allow you to create entanglements (Karen Barad Posthumanist Performativity).

I realized that to program in a feminist way, one would ideally want to use a feminist programming language. So what is a feminist programming language? Well I took a look at the major programming paradigms, the following are the four main groups a programming language can fall into: imperative, functional, object-oriented, and logic. I decided to explore feminist logic such that a feminist programming language could be derived.

I am currently exploring feminist critiques of logic in hopes of outlining a working framework for the creation of a feminist programming language.

If this is something you are interested in and would like to give me some feedback on I would truly appreciate it. Thank you for any and all feedback. I would love to open up a dialogue about what I am working on and my approaches to answer my research question. 


NOTE: Hi everyone, I wanted to first say thank you so much for starting such an amazing conversation around this idea. I am currently working on a few different ways to explain this research as I know the text above is full of theoretical ideas from a variety of disciplines with a lot of academic language. 

I look forward to responding to all the comments below, though it may take a bit of time. 

In the mean time, I wrote another blog titled A Feminist && A Programmer explaining why I am interesting in this line of research which is linked below:



Oh my gosh yes this is

Oh my gosh yes this is awesome.

For the longest time, I've been thinking about programming languages as a computer-human interaction problem: the purpose of a language is to make its features (affordances) obvious to its users.

However, the problem is that as domininant programming paradigms emerge, new languages encode these paradigms in their languages. For example, C was highly procedural without much support of object oriented programming. When object oriented programming emerged and became popular, C++ incorporated into an evolution of C and the Java language was created to *enforce* that paradigm on the premise that it would improve the code. What I find curious is how many people go out of their way to "beat" Java's enforcement to program in their own style.

We, as programmers, despite claiming that our field is "objective" have very subjective values that are entrenched in our discourse of programming language, particularly when it comes to the impossible-to-define term of "elegance". Walk into a language war and listen to nerds argue about their favorite languages and still believe that their views are "objective".

An excellent paper to read on this topic for anyone interested is Seymour Papert and Sherry Turkles "Epistemelogical Pluralism and the Reevaluation of the Concrete."

If at all possible, I strongly encourage you to attend SIGCSE (the symposium on computer science education) being held in Atlanta in March. Student registration is around $75, and it would connect you with some awesome people who may be able to help you.

As a closing note, my current direction of research is actually in studying how people use programming languages and how different styles emerge. I'm more interested in the outliers than the common paths... what ways are languages used that would be considered "unusual" from those in the know? Let me know if you'd like to chat sometime.

Arielle Schlesinger

Absolutely! The visceral

Absolutely! The visceral response trained programmers have to code that is not "elegant" is undeniable. If code were so neutral and objective it’s hard to imagine why or how someone would come about such an extreme reaction. I think a lot of interesting information gets ignored under the guise of neutrality and objectivity. 

I look forward to reading this paper, thank you so much for the recommendation. Batya Freidman and Helen Nissenbaum paper "Bias in Computer Systems" does a great job of defining value as part of a material--"objective"--thing. Which lends itself to the the idea of programming languages as an computer-human interaction problem.

Your research sounds fascinating. I would definitely appreciate some input and would love to hear more about what you do. Thank you so much. 


What does this mean?

So, I'm a computer scientist (and an associate of Barry's), and while I don't really understand the critical theory behind this idea, I think this research could have a lot of great benefits for programming language theory and CS education. But, I do have a lot of questions.

First, since I don't understand the critical theory: what exactly is a "a non-normative paradigm" in a programming context? Also, what is "feminist logic?" Does it oppose the laws of identity, non-contradiction, or excluded middle, or is there a more subtle difference?

Following on from that, how deep do you think the differences between existing languages and a feminist language would be? Is this an issue primarily with the data model (type system, objects [with behavior] vs. structures [without behavior], mutability, etc.), the paradigm of execution (functional vs. imperative vs. logic, etc.), or with something even more fundamental, such as the underlying mathematics or the hardware on which they operate?

Finally, what end do you see a feminist language serving, and where do you think it would best be applied? Do you see it as primarily being of academic/research interest, as an alternative form of expression/instruction, or do you think that this could affect (in a beneficial way) programming in general, even in industry? I know that this is very early in the research stages, so this question might not have any answers yet.

Arielle Schlesinger

Fair questions.

Let's start from the top. 

A non-normative paradigm would be something that does not reinforce normative realizations of what a programming language is. That is to say, not whatever paradigms (OOP, functional, logic, etc) and programming languages you would consider standard (Java, C++, Ruby, Python, to list a few). The ideas is that the standard, normative, concepts reinforce the values and ideologies of societies standards. Currently, there exist projects built in response to normative programming languages and standard computer science, check out mezangelle for an example. In many ways this falls under the scope of critical code studies, as I am asking questions about the cultural, social impact of normal programming constructs. 

What is a feminist logic is a question I’ve spent the past six months thinking about and researching. There are not a lot of women in philosophy, and there are definitely not a lot of feminist philosophers, so I don’t have a good answer for this question. There is great scholarship talking about weather a feminist logic can build off of formal logic or if it has to reject the laws of identity and create something entirely new. There are solid arguments for both camps, personally I’m swayed by the constructive theories that would build onto formal logic through a feminist lens. There exist logics that handle contradiction as part of the system, namely paraconsistent logic. I think this type of logic represents the feminist idea that something can be and not be without being a contradiction, that is a system where the following statement is not explosive: (p && ¬p) == 1.

In many ways the difference between a feminist programming language and a normative programming language would be the ways people go about answer questions with a feminist programming language as well as the types of questions a person would try to answer. I believe there is a stark contrast in these two different ideologies. If you get a chance to read the Karen Barad article I mention above it speaks of non-normative subject object relationships theorized as entanglements. Entanglements exist in stark contrast to the values and structures of OOP. While I think there are issues that could be explored with the mathematics and the machines, this is not where my interests are focused. In part, because I am hoping to uncover something constructive through my research. And when math and computer systems are already so pervasive and useful, calling for their death by fire hardly seems advantageous. Though the rabbit hole that is epistemology and mathematics is fascinating if you ever want to jump in (did we create math or uncover it, what does that difference mean, will we ever know?). There have been successful ternary machines (Knuth himself commented on the potential of balanced ternary), this could be an extremely worthwhile pursuit for someone as it gets into interesting questions about identity, I have just chosen to look at this idea from a different perspective. 

So, as for the last set of questions, you may have heard of the Sapri-Whorf Hypothesis. It was developed by anthropologists and posits that language affects perception of it’s speaker and thus shapes understandings and thought. There is good evidence to support this hypothesis. So if the hypothesis stands, we can say that programming languages constraint the way we see and understand a given problem. I think this observation has vast importance and as such I would like to see a feminist programming language serving programming in general, in addition to academia and new forms of expression. But since the research is in such an early stage, only time will tell.


Fair answers.

So, I read the Barad article, and some other articles regarding para-consistent logic, and I think I now have a better idea of where this project stands. I am decidedly not a post-structuralist (which it appears makes me a distinct minority on this site), and I don't necessarily believe that Barad's paper applies as a description of our world, but I do think it reflects established problems in designing programming data models.

Object-oriented programming has always been a lie, in some sense: the terminology used to explain object orientation (especially in 100-level CS courses) implies a simulation of the real world, where objects have state and behavior. It then proceeds to create ChessPieces and place them on a ChessBoard, and give the ChessPieces a getRank() and a getFile() method. What this "simulation" approach to OO ignores is the nature of objects' state: a physical chess piece's rank and file isn't a property of the chess piece itself (at least, as an encapsulated object), it's a property of the chess piece's relationship to the chessboard.

OO is ill-suited for modeling this sort of relational state. Objects can hold references to other objects, but the semantics of the relationship are almost identical to those of the pointers of old: bidirectional relationships, or relationships that contain additional state, are difficult to model, and they require extensive bookkeeping by the programmer to remain in a consistent state. As a result, knowledge about the state of a system is frequently spread throughout the constitutent parts of the system. One either deals with having to write the chains of method calls and indirections required to update the state consistently, or one ends up with the "flyweight" pattern, where all the information is held in one "mega-class" and the objects merely serve as keys into its dictionary of information, lacking the behavior which is supposed to characterize OO.

This problem isn't inherent to only simulationist notions of OO, but is even present in OO scenarios which intend to be models only of concepts within a computer: the relational data model, for example. SQL databases are built on the relationships between objects based on matching rows with each other via foreign keys. There is no way to model this in the OO world with both bidirectional access and guaranteed consistency. Suppose we have a Stores table and a Products table, and corresponding Store and Product object classes: in order to access the Store that sells a Product from the Product, and to access a list of a Store's Products from the Store, we must maintain a pointer on the Product and a list of pointers on the Store, and take special care to ensure that any changes to the pointers on either model are reflected on the other. Furthermore, it is difficult to deal with subsets of the relationships: a query, "Store, what are all of your purple Products?" is easy to formulate in SQL, but difficult in an OO model.

A related issue is known as the "expression problem:" the best explanation of this is on the C2 wiki at http://c2.com/cgi/wiki?ExpressionProblem, but it too deals with the idea that tracking such relational or environmental information is difficult, even within the design of a program, and OO's failure to solve the expression problem is linked to its desire that all functionality be bound specifically to one type of data.

While I don't fully understand Barad's philosophy of "agential reality," the concepts presented within based on the interactions between matter suggest that a feminist programming language (well, at least one operating from this perspective) would be especially well-equipped to deal with the sort of relational and environmental state that OO (and even functional programming) fails at.

If you're interested in this as a potential application, I recommend reading about the Inform 7 programming environment for interactive fiction: it is designed as a simulation, and treats the relationships between entities in the game world as a first-class mechanism, providing rich syntax for manipulating and querying them. It also separates the code of the game from the objects, instead choosing to have "rules" which are applied at the appropriate time based on all of the parties involved in an event.

The Clojure programming language would also be worth investigating, primarily for its philosophy on data and functions. Clojure does not deal quite as effectively with relationships, but its ideas about state, mutability, and their effects on concurrency (which oppose OO's concepts of such) are increasingly becoming accepted. In addition, its protocols and multimethods provide one solution to the expression problem.

Regarding the Sapir-Whorf hypothesis, I have heard of it, but I think Deutscher in Through the Language Glass presents a more accurate alternative hypothesis: languages do not prevent us from expressing a particular thought, or thinking about a certain concept (alternately, it is possible to express all thoughts in all languages, even if you have to make up a vocabulary word to do so), but they do influence our perception by influencing what we must habitually consider in order to construct correct phrases. He gives numerous examples of this idea, including languages where all directions are absolute compass directions (therefore requiring one to have a sense of their absolute position at all times) and languages where one's knowledge of an action (whether they witnessed it, whether they inferred it, whether they heard about it from someone else) is conjugated with the verb, and using the incorrect suffix is considered lying.

I think this viewpoint also applies (arguably, even more strongly) to programming languages. As per the Church-Turing thesis, there is no program which cannot be expressed in any language, but the language can make it very awkward to do so. (For example, attempting to use functional "map"- and "reduce"-style operations in Java requires numerous anonymous classes, with all the attendant boilerplate. By contrast, languages designed to support functional programming make the syntax for defining a new function almost invisible.) They also influence strongly what the programmer considers when designing the program: in Java, for example, the predominant concern is limiting the disclosure of information or representation outside a particular class.

Finally, I don't have much to say about using an alternative logic as the basis of the language, besides that programmers would probably get very annoyed if there was a value that could execute both the "if" and "else" branches of their conditional statement. ;-) I will note that I haven't found many situations where a value being both true and false would be very useful, but that could be a side effect of the way I am framing the problems. If you would like examples of alternative logics in programs, take a look at SQL's trivalent logic (true, false, null), and Perl 6's "junctions" (which I think are most relevant to the idea of multiple truth states for a given condition).

Arielle Schlesinger

Well Said

I completely understand what you’re saying about OO. I think that is a really interesting point and there is a lot of potential in the comparison of OO with the relational data model. I hadn’t thought about Barad’s work in this regard, and I think this is a really rich area to look into. A huge part of my research is stemming from the idea that values and biases are perpetuated within technology, focusing my attention on computer systems and code. If values are perpetuated by code, how do we think about values in the creation of and use of code in a more explicit way. It will be particularly interesting to see how relational data model relates to Barad’s work with values in mind. 


Inform 7 has been brought to my attention and I definitely think there is a lot of potential through this environment. The fact that so many people have this come to mind makes it particularly significant. I'm really looking forward to exploring the IF world more. 


I’ll have to look into Through the Language Glass, I think this definitely reinforces what I am talking about. And something people who have used programming languages from different paradigms know to be true. I’ve always been fascinated by languages that define directions or time in a restricted way. I think there are really interested analogies to be observed here.


The Church-Turing thesis is of a lot of interest to me because under this notion if there is a feminist programming language, then anything one would want to write in this language can already be written in another language (though not necessarily with ease). I think this has the potential to have very interesting implications about what one could do with a programming language when values/biases are thought about in a more outright sense. 


The more research I do, the more interested I am in pursuing ideas that are not in direct need of a feminist logic. There is a lot of interesting research that has been done on logic and feminism, Andrea Nye and Val Plumwood in particular come to mind. I really want to see where feminist values and effective executable code can meet!


Thank you so much for all these different resources. I really appreciate your insights and questions!


Ternary logic and beyond

Whilst researching the differences between dialectic and empathic resoning I came across the Indian traditions whereby things aren't one, or the other, or even something else. Instead there are seven states of conditioned predication within which one tries to forumlate arguments, known as the Syādvāda:

syād-asti—in some ways, it is,
syād-nāsti—in some ways, it is not,
syād-asti-nāsti—in some ways, it is, and it is not,
syād-asti-avaktavyaḥ—in some ways, it is, and it is indescribable,
syād-nāsti-avaktavyaḥ—in some ways, it is not, and it is indescribable,
syād-asti-nāsti-avaktavyaḥ—in some ways, it is, it is not, and it is indescribable,
syād-avaktavyaḥ—in some ways, it is indescribable.

More info can be found here: http://en.wikipedia.org/wiki/Saptabhangi#Sy.C4.81dv.C4.81da but I found it within the context of http://en.wikipedia.org/wiki/Dialectic#Indian_forms_of_dialectic


Logic programming languages

Logic programming languages use a fragment of logic which is already constructive and (some would say) paraconsistent.  They were made this way for practical reasons of computability rather than philosophical motives, but it strikes me as something of an issue for your project that a feminist programming language may already be out there, unnoticed by both feminists and by the men who created it.  On the other hand, logic programming is a very constrained space in which most of what we think of as logic (the excluded middle, proof by contradiction, etc.) just doesn't work, so you could read some meaning into the fact that only a feminist-style logic works at all.  

I don't know that anyone has followed up on Mascellani's lead about actively incorporating inconsistent information into logic programming (see, for example, http://www.lip.uns.edu.ar/cmsra/mascellani.pdf), but he is not the only one to have suggested this general approach.  Sadly, logic programming languages are not a popular class of programming languages, so the prospects for coming up with your own (slight) variant on logic programming are pretty good.  But the options will be constrained; you may not be able to do everything you think should be done.

I'm not familiar with the entanglements you mentioned, but if that's particularly important for your project, you may want to look into relational programming languages instead.  They're closely related to logic programming languages.

Arielle Schlesinger

Room enough for two (or more)

I think it is constructive to think about why there would be a hard distinction between computability and philosophical motives now. Particularly as computers have come so far from the ENIAC days where there was barely space for the desired functionality. That being said, if current programming languages have feminist ideologies embedded in them, this would not pose a problem for this project. In part because of the plurality of feminism, the plurality of programming languages, and the power of intentionality.

Feminism is a purposeful movement; to have socially and academically feminist ideas is something people come to. So if something were to have analogous properties to feminist ideas though not explicitly feminist, these ideas would have been developed intentionally from a different philosophical standpoint. Many later comments point to Interactive Fiction communities and languages like inform7 as an example with potentially interesting consequences. However, if you have examples of accidental feminism in computer science that you could share that’d be great.

Thanks for including the article regarding logic programming and paraconsistent logic.


You might be up to something

Hi Arielle,

That's very interesting and you might be up to something. The tricky thing is that the bottom line of coding is about logics and abstract thinking. There's been some research that shows women are more likely to prefer a given programming language over another. However, the often mentioned paper "Gender and programming achievement in a CSCL environment" found that gender does not affect programming performance and the study of Moraine Valley community found no correlation between gender and choice of programming language. These studies are available here and here.

If you check Bruckman et al's study you'll see they reported that girls spend more time than boys communicating with others in the CSCL environment and that boys are more likely to have prior programming experience and spend more time programming on average. I also remember Sherry Turkle's early work at the MIT when she studied children's interaction with the LISP language. IIRC, she found that girls are alienated by the way K-12 education presents programming to them. Turkle commented on this either on The Second Self or Life on the Screen. Can't really remember which one.


Arielle Schlesinger

Hi Marco,I'm glad you're

Hi Marco,

I'm glad you're interested, I am excited by the poential of this project. I think an important point is I am not trying to make claims about ability to programming as related to gender. I do not ascribe ability and/or interests to essentialisms, be they about gender identity or any other forms of identity.

I love that there is research showing gender does not inhibit ability when it comes to programming and logical thinking, thank you so much for sharing the links that establish this.

I explain more about what feminism means to me, especially in terms of how it relates to computer science and programming here: http://www.hastac.org/blogs/ari-schlesinger/2013/12/13/feminist-programmer#comment-23026

Turkle has contributed and created so much rich content, thanks so much for mentioning this scholarship!




Objects with "Agency"

This article started quite the discussion in our lab! Thanks for the interesting thoughts!

As a programmer, it's difficult for me to reject the axiomatic falsehood of (p & !p) = false, and my brain isn't ready to think about it. However, we came up with an interesting discussion based on our (incomplete) understanding of normative subject-object theory:

Have you ever heard of games called "MUSHes", or a particularly popular instance of a MUSH called "LambdaMoo"? A MOO/MUSH is a multi-user, text based adventure game where the world is designed and programmed from the inside by the players themselves. Basically, everything that exists in the world is an object and has properties, which - on the surface - makes it look like an object oriented program. You, as a player, are allowed to make new objects, but other people in the world are not permitted to change your objects except in ways that you explicitly permit, and you can never prohibit another object from performing an action. Therefore, you have a world of objects where a sense of mutual consent is enforced by the environment.

My understanding of subject-object theory is as follows: Subjects act and objects are acted upon. If we define the world as a collection of interactions between objects, we are considering people and other sentient beings as "objects" when they should be treated as something more.

MUSHes reconcile this in an interesting way by extending the object-oriented paradigm with an additional constraint: "all things are objects, but some objects have agency" (people, in this abstraction, are objects with agency). So here is my hypothesis:

A feminist programming language is a language that respects the agency of objects, acting upon them only upon mutual consent.

There is an interesting quality of such a language that follows from this definition: unlike most languages where anything is possible (Turing Completeness), in this language, some things are decidedly NOT possible. This has interesting analogues to reality: "just because something is possible does not mean you should do it".

What are your thoughts?


Intriguing topic!

This question (of what a feminist, anti-racist, accessible programming language might look like) is of deep interest to me, and I'm glad to learn that you're exploring the issue.
Turkle and Papert's article on "Epistemological Pluralism," mentioned above, is a great starting place to think about this question. One concern I have with that work, though, is that it runs the risk of affirming a binary conception of gendered ways of thinking, i.e. that boys and girls think in different ways, even if some boys happen to 'think like girls' or vice versa. This seems like precarious terrain, especially in light of the continued prevalence of gender-essentialist beliefs as a justification for why women are underrepresented in tech — which shifts the blame away from the virulent misogyny that runs through much of the tech world.
Another useful point of comparison might be Zach Blas's "transCoder," which is described as a "Queer Programming Anti-Language." This is an artwork that draws upon Butler, Halberstam, Haraway, and other theorists to imagine what a queer "API" might look like.
By design, Blas's anti-language is not actually executable. I confess that my excitement about the work was diminished somewhat when I realized I couldn't actually run it. Of course, that is part of the point (a "disidentification" with functionality, to use the late José Muñoz's term); however, I still believe that the construction of a programming language informed by (intersectional) feminism, queer (of color) theory, critical race theory, and disability studies is a worthwhile experiment that has not yet been undertaken.
A few other things to look into might be the small variety of programming languages that are based on languages other than English, of which there are some examples here. This speaks to the Sapir-Whorf hypothesis issues you raise.
And this "computational model of knitting," which shows how knitting (an activity often thought of as "feminine") can be thought of as a medium for computation.
...aaaand I was going to suggest you look at Tara McPherson's work on Scalar for a look at feminist software design, but now I realize that Jacqueline Wernimont has already been gathering a bibliography that addresses many of the same points. Heh. Well, at least the knitting and anti-colonial elements are new! I hope this helps, and look forward to hearing more about what you come up with.
Arielle Schlesinger

Thank you so much for your

Thank you so much for your interest and the great links! I have spent a great deal of time with the information you point to, definitely plenty to think about. I am really excited to keep exploring this project. So many great interesting ideas have already been brought to light because of these conversations. 


I don't quite get it

first of all, unsure about what you mean by a normative Language and unsure why one not being normative is Useful. You seem to mean not committed to one paradigm These days, much convergence is happening, so I suspect To some extent, most languages are becoming less normative? For example, many object oriented languages now Have lambda functional notation Also, I think to program in a feminist way, one could presume, One might avoid terminology that has bad connotations like "master/slave" But I'm confused why a new language is needed for that I don't think you should say your language is "feminist" Or that feminists should use it but you can say, it was Inspired by feminism which is ok i do think you are smart, your thesis looks challenging but Ultimately, you should try to sell it on being "useful" in some way Will it make my job easier to use it? Feminists can be pragmatic Too. Can you start by clarifying

Melody Jue

Queer programming language/Zach Blas

Of related interest is Zach Blas' work on a queer programming language.


"Queer Technologies is an organization that produces critical applications, tools, and situations for queer technological agency, interventions, and sociality. By re-imaging a technology designed for queer use, Queer Technologies critiques the heteronormative, capitalist, militarized underpinnings of technological architectures, design, and functionality. Queer Technologies includes, transCoder, a queer programming anti-language;ENgenderingGenderChangers, a “solution” to Gender Adapters’ male/female binary; Gay Bombs, a technical manual manifesto that outlines a “how to” of queer networked activism; and GRID, a mapping application that tracks QT dissemination and infection."


Other connections between language and theory

transCoder was already mentioned, but I wanted to give a shout-out to Galloway and Thacker in 'The Exploit,' who include another non-executable programming language whose name I'm having trouble recalling.

Cathy Davidson
Cathy Davidson

And Juvenile Parodies Abound

There's also a parody/hoax happening on Bitbucket where a simplest redaction of feminism conjoined with fake code is being put up to tempt the naive, I assume, to create a feminist programming language, a la the infamous hoax perpetuated against critical theory long ago.     Caveat emptor.   This is not what Ari Schlesinger's posts (either the original or the follow up) are about.  

I give a lot of talks now at corporations dedicated to technology innovation and, within fifteen minutes, I always hear that the single biggest problem in that world is lack of diversity.   CEOs and CIOs don't see it as a problem for women but a problem for technology:  you cannot create technology for a very diverse world (in every sense) with a homogenous core of developers and managers.   They find it to be a major problem and are funding ways of changing the problem to the tune of billions of dollars a year worldwide.  No one knows what to do but no one in that world is sanguine about the fact that the number of women entering the field of computer science has declined since 1993 when the Mosaic 1.0 browser was released to the general public and the "Information Age" officially began. 

That's a problem.  So is the 9%-14% (the numbers vary depending on what and who you count) representation of women among editors of Wikipedia.   We have a major cultural, social, political, and economic issue here and everyone in the tech world is aware of it.  


Please put the parodies aside, folks.   This is a real, serious issue.  Getting to the root problem is essential in real, practical terms as well as in theoretical terms. Ari Schlesinger is performing a real service to the profession by provoking serious conversation on these matters.  We invite your comments and your disagreements although, as always with HASTAC, we are an open community that promotes difference through thoughtful, civil, engaged, respectful exchange.  Snide parody? Name-calling? Slander? Hoaxes? Trolls?  There's no place for those in a world where there are real and important issues that will benefit from all of us thinking together about how we can do better.

New Blog:

Original Blog:


Not to mention some of the

Not to mention some of the "developers" who created this project impersonated contributions from well-known feminist developers. Props to Github for taking it down so quickly.

Evan Donahue

Failures of binary intelligence

One thing that springs immediately to mind is the long and catastrophic history of attempts to represent knowledge in terms of absolutes. Right from the outset of AI, "knowledge representation" has always been haunted by the fragility of binary logic, and every house built on that logic sooner or later comes tumbling down. Socrates was a man. Odysseus was a man too, but Odysseus was a fictional man. Do we now need to split those categories and say that Socrates was a non-fictional-man? What about Jesus, who may have been real, but was heavily fictionalized? And where the Jove does Tiresias fit into this picture, who by divine curse (blessing?) has been both a man and a woman? new FictionalSometimesMan()? These are open research questions in binary logic based knowledge representations. Instead of building on that logic, I would suggest that the Tiresias variable is exactly the p for which (p && !p) == false must be rejected as a starting point for rational discussion.


Much of the history of programming languages seems to me to be colored by this pattern: an absolute logic is encoded (modern notions of object orientation literally borrow from Platonic forms), it breaks out of the gate as it encounters the vagueries of the "real world," and every degree to which the absolute logic is made less absolute (multiple inheritance? mixins?) restores one degree more flexibility and, ultimately, utility to the system. Probability played this same trick to let modern machine learning techniques address questions unanswerable in a world of strict, deterministic logic. Probability is my personally preferred language for expressing non-absolutes, as I am not familiar with paraconsistent logics.


I think that a modelling logic that spoke less in terms of absolutes and that allowed the Tiresias variable to flow more freely between man/woman and real/fictional based on how it needed to be used would be absolutely killer as a modelling paradigm. Moreover, I bet feminist theory would be right at home thinking about it. In particular, I think that most of the problems presented by programming paradigms are not endemic to programming itself, but are rather produced by the interplay between language and social relations. In other words, just as one does not need to give up English but only reconfigure it, so one does not need to give up the essential mathematical formalisms that make programming programming in order to reconfigure them. A probability can still be binary if it powers a binary classifier and reintroduces absolutism at precisely the place where it should embrace multivalence.


I suspect that the 0s and 1s of binary code are too often a red herring for this kind of work; when programmers think only in terms of higher level linguistic concepts, I suspect it will be those concepts and those concepts only that begin to encode and perpetuate binary thinking. One does not need to give up 1s and 0s to reconfigure binary thinking. Indeed, that is the entire basis of computation: that 1s and 0s can express infinite variation. "False" is an illusion produced by binary thinking; in a binary world, "not man" means "woman." For the Tiresias variable, by contrast, "is man" and "is woman" could both be completely compadible categories for the function knows_what_sex_is_like_for (___)." This seems to be the basis for much confusion, as attempts to talk about revising binary technocultural logic are relegated to the fringe along with tri-state computing and other ideas that don't really have a home in the modern technological mainstream.


At any rate, I like the promise of where this thinking might lead and hope to hear more about it.


"Instead of building on that

"Instead of building on that logic, I would suggest that the Tiresias variable is exactly the p for which (p && !p) == false must be rejected as a starting point for rational discussion."

Does it? I disagree. Your argument only holds if we accept that "man" and "woman" are opposites.


In formal propositional logic, the variable 'p' is a single true or false statement*: Let p be the statement: "Tiresias is a man". This means that (p && !p) is expanded to "((Tiresias is a man) && (Tiresias is not a man))".

"Tiresias is a woman" is a separate logical premise (let's call it 'q').

Therefore ((Tiresias is a man) && (Tiresias is not a man)) can only evaluate to True if we accept the axiom "$PERSON is a man if an only if $PERSON is not a woman." I don't accept that axiom, do you? :)


In my argument against you, I think I'm hitting Ari's point very well. I am making the claim that my model of the Tiresias situation is right and yours is wrong because I claim that you are using the syntax of the language of propositional logic incorrectly. This argument only holds water if we believe in propositional logic - if we reject the language, then my assertion that you are wrong has no standing.

However, in another way, this points to part of what I love about programming. Programming, in my mind, is all about building models. All models are wrong, but some models are useful. Even if I ignore the syntax structure, I would argue on a philosophical level that "Treating P and !P as a question of gender" is a poor way to model the Tiresias situation in any language. Why do you pick that as your abstraction? Why don't you pick variables that make it possible to reconcile the situation in the terms of language's rules? Whose abstraction is right? Is one more right than the other? Does forcing ourselves to conform the question to an arbitrary language miss the point entirely?

Actually it's funny, I feel like trying to talk about logic while relying on logical rules to make my argument is somewhat as frustrating as trying to talk about gender in a gendered language like Spanish or German. :)


Of course, everything I'm saying is inherently biased by my experience in the field, so my own assumptions and biases may not be clear to me, regardless of how much I try to remain cognizant of them.


* Note that in my eyes, requiring that everything in a formal logical argument to be either true or false does not necessarily entail everything in the world being binary. It just means that for things that are not expressable as true or false boolean values, the rules of formal logic can not be applied deterministically to them. I believe that there are statements that can exist without being true or false, but the jury is still out on states that are true and false simultaneously.


various points & references

Hi Ari,
This is a topic I've given a fair amount of thought over the years, and I have a couple of thoughts; some are general points regarding the topic, and a few are specific reactions to points made in your post or earlier comments.
  1. First, I encourage you to think about what problem a "feminist programming language" is supposed to solve. I think it's much less clear than the label might suggest. Is the problem that non-feminist PLs produce non-feminist results? I don't think that's clear. Is it that non-feminist PLs contribute to an anti-feminist engineering culture? I think that may well be true, but that PLs are a small part of a much larger problem and that PLs in this sense are not an especially apposite site for political action. Is it that a feminist PL might encourage more feminist-friendly computing products? Again, this seems possible, but it's not clear that the feminist PL would be the most expedient route to creating those products. Is it a way of critiquing the existing paradigms? That's important--something I engage in actively--but it's not then necessarily an argument for the adoption of a feminist PL other than as a thought experiment. I think Tara McPherson's experience with Scalar shows both the attractiveness of such an approach, but also its relative limitations with regard to spurring on or informing politically-resistant or feminist projects. To take a more general example of a scripting language, HTML has not been developed with much feminist input, but it has been used for a wide range of feminist and anti-racist projects, even if those are just putting texts and discussions on the web.
  2. You dip into the literature on feminism and technology, which is absolutely one of the places one should look for discussion of these topics, although I think it's deeper than the current bibliography suggests. With regard to PLs in particular, I think a big lacuna so far is the discussion of feminist theory in philosophy, particularly with regard to formal logic and mathematics. This has been a thriving topic for a long time, especially in the late 1990s: what would it mean to have a "feminist logic" or a "feminist math"? PLs are more like logic and math than they are like languages (see 4 below), although the voluminous literatures on feminism and language (both philosophical and linguistic) and feminism and writing (ecriture feminin etc.) deserve consultation. I'd particularly recommend Andrea Nye's Words of Power: A Feminist Reading of the History of Logic (Routledge 1990): http://www.amazon.com/Words-Power-Feminist-Reading-Thinking/dp/0415902002/ref=la_B001H6WH2K_1_1?s=books&ie=UTF8&qid=1387126985&sr=1-1 and essays in Falmagne and Haas, eds., Representing Reason: Feminist Theory and Formal Logic (Rowman & Littlefield, reprint 2002): http://www.amazon.com/Representing-Reason-Feminist-Theory-Formal/dp/B007K56N1S
  3. In The Cultural Logic of Computation (specifically Chapter 9, pages 209-215) I talk a bit about the politics inherent in various approaches to building programming languages, with reference to the cultural politics inherent in the thinking behind Object-Oriented Programming. My goal is not to attack OOP, but point out what kind of thinking goes into and supports them. There I talk briefly about two other paradigms, Subject-Oriented Programming (https://en.wikipedia.org/wiki/Subject-oriented_programming) and Aspect-Oriented programming (https://en.wikipedia.org/wiki/Aspect-oriented_programming), which appear to have been developed in part as reactions to the philosophical/conceptual underpinnings of OOP and which answer some of the challenges you've suggested--the "normative subject/object theory" you rightly note feminism has criticized. But it's vital to note that neither has gained the kind of support that OOP has, even among politically resistant projects, raising questions about what such resistant formalisms are supposed to do. Both do more with relations than does OOP, although to say that OOP excludes relations is not, I think, entirely correct. There is at least one effort to develop Relationship-Oriented Programming: http://www.codeproject.com/Articles/298818/Relationship-Oriented-Programming.
  4. It's important to assert something here that only seems to creep in occasionally, but which I will stake my life upon: "programming languages" are not "languages," if by the naked term "language" we mean "human language" (and I'm frankly not sure what else we could mean). The affordances PLs offer, and the use we make of them, are quite different from human languages, and we need quite different analytical tools to approach them.
  5. I mention this in part because of your invocation in comments of the Sapir-Whorf Hypothesis, about which two points.
    1. First, Sapir-Whorf applies to human languages, not PLs, and for a lot of reasons I think it would be hard to make a convincing argument that the hypothesis as it is typically understood would apply to PLs, which is not to say that PLs do not in some sense "constrain the way we see and understand a given problem," but this kind of constraint is quite different from Sapir-Whorf; among other things, many if not most programmers know several languages and approach problems abstractly first, before deciding which PL to code in.
    2. It's not really accurate to say that "there is good evidence to support" the Sapir-Whorf hypothesis. The hypothesis itself has been disambiguated into several different versions (often classified as "strong" and "weak") and it's not clear that even Whorf believed in the "strong" version, and Sapir may not even have believed in the "weak" version (he said different things at different times in his life). All the evidence that linguists have generated has tended to circle around "weak" versions of the hypothesis, so that, for example, certain aspects of temporal perception, or the degree of completedness of action, may be affected, but in general, larger questions of conceptual structure are not constrained by language. There is a pretty good discussion of this on the Wikipedia page on Sapir-Whorf/linguistic relativity, which even contains a brief (and in my opinion somewhat misleading) note at the end about PLs: see https://en.wikipedia.org/wiki/Sapir-Whorf_Hypothesis.
Cathy Davidson

(p && !p) == false Only if "Man" and "Woman" are Opposites

This to me is an incredibly salient point, raised in this conversation by Barry Peddycord and Evan Donaghue: 

"Instead of building on that logic, I would suggest that the Tiresias variable is exactly the p for which (p && !p) == false must be rejected as a starting point for rational discussion."

Does it? I disagree. Your argument only holds if we accept that "man" and "woman" are opposites.


Even the idea of "opposites" is interesting here in this very informed and interesting discussion between Barry and Evan because oppositionality, in real language, can be variable and relative and in code is often fixed as universal, singling out one feature of the object as a universal.  Even leaving out all the politics of gender (the Tiresias factor Evan has so rightly infused into the conversation), "man" and "woman" would be unlikely to be construed as opposites if the third term in the sequence was "tree," for example.    And so forth.  I know that is a more elementary, fundamental problem in propositional and other logics based on Indo-European linguistic structures,  but it is  keenly important to this conversation.   Aside from gender, it is also important to more relational non-Western languages where many features of language itself change depending on the relationship of the person speaking to the person addressed.  I've heard theoretical arguments by some of the world's most important programmers on such things as Japanese and code, Hopi and code, etc.  

I remember old (1990s) conversations about end-user programming and how non-Western programmers would have evolved a different kind of code if they had been central from the beginning.   Ruby (developed by Yukuhiro Matsumoto in the 1990s) notwithstanding, most programming languages are still written by those whose first language is Indo-European in origins or developed from those languages.  And since code builds upon code, these structures prevail and condition how the Web is written. 

In other words, Indo-European and in particular Anglo-European languages make and insist upon binary distinctions at every turn, including when those binaries must exclude other features of the same object that, in fact, are not opposite at all (i.e. human v. tree rather than man v. tree, depending on context).   The way we instatiate binaries as a permanent feature of discourse is partly a difference, going at least back to Socrates, Pythagoras, and Plato (esp the "forms").   Ah, I love this conversation.

I'm so glad your lab of computer programmers is really hashing this out, Barry.  It has been several decades since AI, natural language, machine language were all the topics that kept me awake at night, but the binary structure of code, that embeds a polarized set of cultural assumptions and qualities, continues to haunt me.  

One of the years I lived in Japan I had the great fortune to be included in several conversations with one of the great Sony Lab AI architects of the day.   He and his colleagues included me, mostly as an observer and sounding board, in long discussions of how much Western subject/verb/object language structures, gendered pronouns, tense (literally present, past future), and number (singular and plural) which figure differently in ideogrammatic languages have had an impact on the deepest level of virtually all code and programming languages.   I remember very long, heated discussions about the "one-byte" and "two-byte" data system and web browser issues that were so important in the 1990s.  

Here's a 1999 paper by two Japanese researchers that I just found that makes some reference to those debates:  http://www.wsl.ch/dienstleistungen/publikationen/pdf/3775.pdf ).   Even the most basic fact that Japanese has 8000 characters, too many to be represented in a one-byte system, already deeply influences different ways of organizing data bases, search, and other features.   I don't know if these  conversations ever went anywhere but, at the time, the Sony AI folks were determined to make a kanji-based programming language on the grounds that it would be far more flexible for AI than the Western systems. 

This blog seems simplistic but it points out some of these very deep issues, that include and go beyond gender binaries:  https://groovy.codeplex.com/wikipage?title=Kanji%20meets%20Programming  


I'm sure much of what I've written here is woefully out of date.   I write as much from fascination and nostalgia--it's where I thought my career would lead me, at least from second or third grade on to my undergraduate graduation.   It was only when one of my profs, a woman, a Rhodes Scholar, a student of Quine and great logicians and programmers of the day, was not able to get a job that I switched into English.  I was at a tiny liberal arts college and felt that if Princeton/MIT/Oxford couldn't land you a job in AI as a woman, probably my degree from Elmhurst College wasn't going to let me break the mold.   In this case, gender was a cultural and social factor, not in the code.   But the relationship between the two is more than coincidental.  


Going deeply into these structures on the level of code, might well also help us address what remains one of the deepest problems in the contemporary world of technology:   the lack of diversity (gender and otherwise).   I'm so glad you and your lab took this issue seriously, Barry.   It is an incredibly important area and it is useful to deconstruct the layers and layers of all we do and say to get back to the basics:  What if "Man" and "Woman" are not always, eternally, objectively, structurally opposites?   That's a important and fruitful question.




I think it would be easiest to start your research looking at the classic problems of relational database design, where an integrity constraint written with only almost perfect foresight nonetheless prevents the system from correctly recording someone's name or gender. Nothing about SQL requires that you exclude any type of person from your records, but when a large portion of the language deals with constraints--literal norms--you tend to produce normative databases for the sake of convenience and cleanliness. And it's very useful to do so! It prevents all kinds of bugs.

I found it a bit odd that you listed Python as a normative language. It's still viewed as an upstart in my circles. Not that it isn't a mature language, but there are still a lot of people who think that if you don't have a lengthy compilation process, your language is not suited for Real Programmers. I bring this up because it seems to me that Python's "duck typing" is a way of dealing with some of the problems that object-oriented (especially class-oriented) programming creates. The language does have classes, and it does enforce the boundaries between them, but it is less convenient to check an object's class than it is to check the properties of an object, to ensure it does what you need it to do, irrespective of its class.


A few thoughts on p&&!p

Happening upon this article, my first reaction was "what could a feminist programming language even mean?" which perhaps makes this an interesting mind-expanding topic to consider.  A few thoughts:

I'm still unsure what "non-normative" means here.  You refer to normative paradigms, but I don't think most paradigms are normative in practical languages, they tend to be more descriptive or aspirational. I would think that a normative functional programming language would have to be pure (such as Haskell).  A normative imperative language would be something like assembly where everything is an action.  But almost all practical languages are multi-paradigm.  Programmers may address these paradigms in a moralistic way, even in the context of a multi-paradigm language, but I don't think that perspective has much traction in the design of actual applications.  The moralizing is much more present in blog posts about programming.  But maybe non-normative means more than just a skeptical perspective on paradigms...?

I find the "p and not p" question interesting, and more tractable than it initially seems.  As an example, consider a factorial function: "function fact(n) {return n == 0 ? 1 : n * fact(n-1);}"

If you make the statement "n > 5" is that true?  Most programmers would reject that as an underspecified or invalid claim (for instance, because n is not defined outside fact()), though you could also say it is true depending on how fact() is called, or that it can be true and untrue (since the function is recursive it can be true in some frames and not in others).  There are many questions we can ask that are neither true nor false, not because they are half-true, but because the question is as yet incomplete.

It only takes a small shift in perspective to consider all the many claims that don't resolve well to true or false.  For instance, I've been thinking more about the debuggability of programs, and when I bring up features to make programming languages more debuggable some people reply that we should be writing in safer languages with less bugs - the simplest bug to fix is one that never was allowed to exist. But even if you imagine this is possible, it's a very reductive definition of bug.  In any practical application there are things that are "bugs" that do not represent any formally incorrect aspect of the program, just something where the program formally does exactly what it is supposed to, but what it is "supposed" to do is wrong.

As an example fact(-1) exposes a clear bug, but though fact(100000000) may exhaust your stack it's not clear the program is incorrect. Once you are doing something practical much more subtle examples start to emerge.  For instance, you might imagine a program that doesn't confirm a destructive delete in the UI.  Is that a bug?  Lacking a formal definition of interaction standards it's hard to say.  And such a formal definition is probably impossible to create in a strictly logical manner.  I like to use the most inclusive definition of "bug": code that doesn't do what you want it to do.  There's a lot of "p and not p" aspects to such a definition; you and I may not want the program to do the same thing, our conception of the program or its proper functioning changes over time, or we may have vague concepts that may or may not be possible to implement.

Generally I think the dominant paradigms are dominant because, within their scope, they perform quite well, and describe a sufficient breadth of approaches.  To critique those paradigms on their own terms would only lead to the well-trodden paths we have, the existing network of paradigms that compete within well-defined domains.  It is thinking outside of those domains, not respecting the conventional scopes, where things become more open.  We have a lot of distinctions that are widely agreed upon and obeyed, but I do not believe have to be.  What is program and what is data?  What is data and what is user input?  Why do we separate UI and model?  Why do we treat identifiers as opaque tokens?  Is the call stack the only abstraction we should use for resolving expressions?  (Though logic languages I suppose do not use the call stack.)  Why must all parts of a program be meaningful-aka-effect-execution, except comments which are entirely meaningless?


I'm female, and a feminist,

I'm female, and a feminist, and a professional software developer with years of experience in the field. I also have a very strong background in functional programming languages and programming language design.

I should be the target audience for this post, but I'm not. I haven't the foggiest idea what the author of this post is saying. Literally no idea.

Whatever thoughts are being expressed in this post read like gibberish to those of us who study computer science.

I would like to see the following statement clarified:

"I realized that object oriented programmed reifies normative subject object theory. This led me to wonder what a feminist programming language would look like, one that might allow you to create entanglements"

Developers know what object-oriented programming is. For those who don't, please refer to this layman-friendly description.

They do not know what "normative subject object theory", "feminist programming language", and  "[a language] that might you to create entanglements" even refer to. These are not terms in computer science. Reading the author's suggested paper titled "Karen Barad Posthumanist Performativity" provided no meaningful insight, appeared not have even the minutest relevance to computer science. The author sees a connection which is invisible to the ordinary computer scientist.

I would appreciate a description of these terms in a manner broadly accessible to a layman audience.

"A non-normative paradigm would be something that does not reinforce normative realizations of what a programming language is. That is to say, not whatever paradigms (OOP, functional, logic, etc) and programming languages you would consider standard (Java, C++, Ruby, Python, to list a few). The ideas is that the standard, normative, concepts reinforce the values and ideologies of societies standards."

The phrases "non-normative paradigm" and "normative realizations" are unfamiliar terms, the authors phrasing does not clarify the meaning of these terms.

The statement that that languages "reinforce the values and ideologies of societies standards" is unclear. At best I suppose the author is reiteration the criticism that programming languges use English keywords and grammar, use the America-centric spelling of "Colour" as "Color", and there are too few languages designed to be more accessible to non-English speakers. I'm only guessing, the authors phrasing is unclear.

I would appreciate if the author could identify specific, clearly explained examples of whatever "societies values and ideologies of societies (which society?) standards" in a manner broadly accessible to a layman.

"In many ways the difference between a feminist programming language and a normative programming language would be the ways people go about answer questions with a feminist programming language as well as the types of questions a person would try to answer. I believe there is a stark contrast in these two different ideologies. If you get a chance to read the Karen Barad article I mention above it speaks of non-normative subject object relationships theorized as entanglements. Entanglements exist in stark contrast to the values and structures of OOP. "

I read the Karen Barad article, and I could not distinguish its content from gibberish. It is not accessible to computer scientists, and appears to communicate exactly nothing related to the field.

The author's description of "entanglements" is new to me, and it appears to be an important feature from her hypothetical programming language, but the author does not explain this concept or how its differentiated from OO style or any of the dozens of other programming paradigms.

I would appreciate if the author could provide a description of "an entanglement" in a manner broadly accessible to a layman. I would also appreciate an example of pseudocode demonstrating what an "entangement" is, how one would use it, and what fields of computer science would be interested in a language which supports "entanglements" (e.g. is it useful to general-purpose programmers writing websites? writing game AI? natural language processing? real-time operating systems?).

"There exist logics that handle contradiction as part of the system, namely paraconsistent logic. I think this type of logic represents the feminist idea that something can be and not be without being a contradiction, that is a system where the following statement is not explosive: (p && ¬p) == 1."

As near as I can tell, the author must be referring to one of the subfields of logic programming specifically dealing with fuzzy logic, one of the sub-fields of machine learning related to probabilistic inference. Its hard to tell, because the author does not relate her thoughts on whatever she's studying in the same language used by computer scientists.

I would appreciate if the author could identify, in clear, precise terms the axioms of her "paraconsistent logic", and how it would be used in a real world programming application.

"Regarding the Sapir-Whorf hypothesis, I have heard of it, but I think Deutscher inThrough the Language Glass presents a more accurate alternative hypothesis: languages do not prevent us from expressing a particular thought, or thinking about a certain concept (alternately, it is possible to express all thoughts in all languages, even if you have to make up a vocabulary word to do so), but they do influence our perception by influencing what we must habitually consider in order to construct correct phrases. He gives numerous examples of this idea, including languages where all directions are absolute compass directions (therefore requiring one to have a sense of their absolute position at all times) and languages where one's knowledge of an action (whether they witnessed it, whether they inferred it, whether they heard about it from someone else) is conjugated with the verb, and using the incorrect suffix is considered lying.

I think this viewpoint also applies (arguably, even more strongly) to programming languages. As per the Church-Turing thesis, there is no program which cannot be expressed in any language, but the language can make it very awkward to do so. (For example, attempting to use functional "map"- and "reduce"-style operations in Java requires numerous anonymous classes, with all the attendant boilerplate. By contrast, languages designed to support functional programming make the syntax for defining a new function almost invisible.) They also influence strongly what the programmer considers when designing the program: in Java, for example, the predominant concern is limiting the disclosure of information or representation outside a particular class."

Sounds like the author has independently stumbled on the Blub Paradox, which explains that 1) that a language's programming paradigm influences the stucture, architecture, and manipulation of data in a language. 2) and experts in OO struggle to approach applications written in a non-OO style (e.g. in a functional style). These ideas are not new or novel.

The author is correct any two language which can simulate a Turing machine are Turing-equivalent, but its unclear what connection she sees between this statement and Sapir-Wolfe hypothesis. I'll nitpick the author's comment that "there is no program which cannot be expressed in any language" by directing her to this layman-accessible discussion of non-computable functions

One last comment:

Arielle, please don't interpret my comment as critical of anything you've written. You appear to be highly educated, have some novel idea in your head for a computer programming language, and I don't think you're a crackpot. However your posts are entrenched in highly-technical jargon which is indecipherable to those of us who study computer science.

If you intend to make some contribution to the field computer science, you need to explain yourself in terms familiar to computer scientists. If you coin new terms, you should precisely define them.

If you can clarify any questions above, preferably by showing sample code and use cases in your hypothetical language, I would be most appreciative.


I registered for this website

I registered for this website explicitly to reply to Juliet to say the following - beautifully articulated, and I couldn't agree more. If the original poster is to pursue this line of questioning, particularly within the rigor of academia, more definition and clarification is needed. As a software engineer, I was somewhat alarmed by the language being used in the original document. Juliet did a wonderful job asking for specific elaborations that could clarify things.


Agreed - but also...

I puzzled over this for a while, as well, although I'm not a woman, and have no particular understanding of feminism.

This *seems* a fairly straightforward assault on Aristotelian Logic, whilst simultaneously claiming all Non-Aristotelian logics on behalf of feminism.

If we assume that's the case, then this is not entirely novel. The author might like to check out:


..which whilst being written by a man, approaches the subject from an early-twentieth-century standpoint. Obviously we now also have Quantum Computation. It might be a little too Sophist to suggest that the entanglements which we're looking for might be found there.

Also this:


---- However:

The idea of using these systems to create a programming language which rejects ideas of assignment in favour of connection and perhaps proximity *is* very interesting.

If I was researching this, I'd learn, for instance, Prolog, read all the Korzybski stuff (and Robert Anton Wilson for that matter, that's how I came across it), take a class in Quantum Computation, and then look into Neuroscience for inspiration.

I've been partly inspired by Arielle's article to attempt to create an RPG in which the classic concepts of linked maps, the acquisition of objects and statistics, and so on, are jettisoned in favour of narrative which approaches the subject from a stream-of-consciousness perspective.


It may be that  this article

It may be that  this article was written as a mere thought experiment for Arielle's peers in the various social sciences, not for computer scientists. It does explain the predominance of postmodern social theory jargon over computer science terms, but it also opens a whole new set of questions.


Paraconsistent logics

Paraconsistent logics aren’t something Arielle just made up—logicians have been interested in them for many decades. The problem paraconsistency tries to solve is: How can we reason in the presence of contradictory assumptions? The answer usually involves weakening the axioms until the principle of explosion—that you can derive anything from a contradiction—goes away.


the author does not relate her thoughts on whatever she's studying in the same language used by computer scientists.

As a computer scientist who specialized in programming language theory, I did not find Arielle’s “jargon” indecipherable. It seems to me that, on the computer science side, at least, she knows what she’s talking about. One difficulty inherent to interdisplinary research is that people from one discipline will usually be unfamiliar with the other. It would be good if at some point Arielle could explain the feminist theory aspects of her work in a way more accessible to programmers, and the programming aspects in a way more accessible to people better versed in feminist theory than programming. But that’s a really difficult thing to do, and I wouldn’t expect her to have figured out how in a blog post written early in the project.




Using the language of the audience to convey concepts

I am in favor of considering if what we already know about computer science in some way constrains us from considering equally valid or more promising alternatives.  However, I have difficulty understanding your statement.  I wouldn't call it gibberish, as a previous commenter did, but it does contain a lot of discipline-specific jargon which makes it inaccessible to those who lack familiarity with that field.  Because your work is interdisciplinary, it may be necessary to briefly explain concepts that may be unfamiliar to your audience. 

Perhaps you only wish to communicate with people who also occupy this overlapping space between computer science and social sciences, in which case my criticism can be ignored.  But I think there could be value in writing two descriptions of your work, one aimed at each audience, in order to access what may already be known, but not recognized in the description using undefined terms from another discipline.  I see that some people were able to understand the concepts and suggest programming languages which may have some of the attributes you're interested in, but there are also people like me who are curious about the concept of exploring underlying assumptions in programming languages, but who don't understand what is meant by many of the terms.

My work is also interdisciplinary, and I hope to bring concepts from one field into another field.  There's a lot to be gained by applying ideas outside of the original scope, but I feel that outright rejection is a likely outcome if the work cannot be readily understood by academics in the field being addressed.  Certainly I found myself struggling to understand your topic, and I am perhaps more open to viewing cross-polination as beneficial than many.

Arielle Schlesinger

Fair Point

Hi Ann, 

That is absolutely fair point, I am in the process of creating descriptions for audiences with different backgrounds. I don’t want language to be prohibitive for access to this idea, but as the description above proves, it currently is. 

Thank you so much for your thoughtful suggestion. I’ll be posting explanations from different theoretical frameworks soon!

Thanks again,



The Real World

You might be interested that this web page has been making the rounds on the Internet generating a discussion amongst real world professional software developers.

There is a common opinion that this is a bunch of academic gibberish.

I have been a professional software developer for 30 years so I can tell you that real world software developers don't use any of the terminology on this page written by you or any of the other commenters. Several other developers that I know with over 20 years experience are in agreement.

Businesses write custom software to automate a business process. They don't care about theories, they care about results.

I think your thesis topic is unique and I hope you get a good grade on it. You might want to research the impact of Grace Hopper on software development.

Most of the stuff they teach for college computer degrees is useless in the real world. If you were taught about software development methodologies, that is something you should retain. One fairly popular one if known as Scrum, a type of Agile development methodology.


I'm wondering...

...When you encounter a technical term that you don't understand, do you always decide that it's not worth learning more about and must be completely irrelevant to the real world?


Roland Smith is correct. This

Roland Smith is correct. This article is circulating through dev circles, and the near-unanimous consensus among developers and computer scientists is that this article is indecipherable. The authors jargon is only meaningful in her own mind, but not to her audience of developers and computer scientists. The problem lies with author, not with Roland Smith.

I personally believe it is very presumptuous to dismiss the author's article "post-modern nonsense" as others already have. I want to see what the author can do, I want to see her work speak for itself.

To Arielle Scleisinger

Most discussion I've seen around your article is of the form "I don't understand what this means", meaning you've inadvertantly alienated a large chunk of your audience of laymans and academics with an interest in computer science.

I encourage you to take inspiration from the writing style found in the article titled "Who can name the biggest number". At its heart, this article really summarizes the Church-Turing thesis, with particular emphasis on non-computable functions, explains how non-computable functions reduce to the intractable halting problem; but it addresses the subject with a very breezy, colloquial prose, preferring to tuck away the rigorous mathematical formalisms in footnotes and references to other papers. This style suits blog-style posts very well.

How you choose to write depends on your target audience, or who you feel your target audience ought to be. That said, I believe you should take special care to communicate in clearly defined, meaningful, precise terminology, otherwise whatever valuable insights you contribute will be drowned out by those accusing you of post-modern obscurantism.

Ruby Sinreich


I'm not sure it's fair to assume that Arielle's intended audience is "developers and computer scientists" as you say, Juliet.  If so, she might have posted the inquiry on Slashdot, 4chan, StackExchange, Reddit, or any number of other places (where we are well aware that heated discussion of this post is on-going). HASTAC is a home for interdisciplinary intellectual exploration, and the post is entirely appropriately worded for the community here. 

Cathy Davidson

Postmodernism Or Just Plato?

Hi everyone, This is a very interesting argument--and a recurring one. I personally like to write with enough clarity that non-specialists can read what I write.  However, I know that when I'm specifically writing to a disciplinary audience, I often use terms that I know my audience will understand as a short hand.   Now, there is always a down side to a shorthand:  people assume they know what one another is talking about but often the agreement is superficial, not deep.  One reason propositional logic was developed was precisely to deal with the problem of ambiguity of semantics.  However, as philosophers have argued for centuries, much ambiguity is embodied even within the discrete terms of propositional language, including binaries.  That's where this conversation has been going for several of us, in fact.  p and not p often have much in common. 


The accusation of "jargon" though is often something we sling at others and don't even see in our own group among whom there are commonalities of language (i.e. "jargon" to those outside the group).  And "postmodernism" as a term is itself jargon since it means many things to many readers but people often use it, as in some of this discussion, as if it has one meaning. 

People from one discipline often assume that the jargon of another discipline is meaningless, pretentious, or, if you live in the late 20th or early 21st century, "postmodern" (whatever that means).   Sometimes language is meaningless.  Other times what seems like gibberish can spark, well, two thousand years of a philosophical tradition.  

But what is or is not "gibberish" is also relevant.  And hardly limited to what some folks on Twitter and in blogs are calling "postmodernism."  On that note, I present to you Plato's Parmenides.  Please do not tell me it is postmodern.  It is just plain classical philosophy.  (Even the translation is from the 1890s, by the way).  For your edification, unedited:


But tell me, Zeno, do you not further think that there is an idea of likeness in itself, and another idea of unlikeness, which is the opposite of likeness, and that in these two, you and I and all other things to which we apply the term many, participate-things which participate in likeness become in that degree and manner like; and so far as they participate in unlikeness become in that degree unlike, or both like and unlike in the degree in which they participate in both? And may not all things partake of both opposites, and be both like and unlike, by reason of this participation?-Where is the wonder? Now if a person could prove the absolute like to become unlike, or the absolute unlike to become like, that, in my opinion, would indeed be a wonder; but there is nothing extraordinary, Zeno, in showing that the things which only partake of likeness and unlikeness experience both. Nor, again, if a person were to show that all is one by partaking of one, and at the same time many by partaking of many, would that be very astonishing. But if he were to show me that the absolute one was many, or the absolute many one, I should be truly amazed. And so of all the rest: I should be surprised to hear that the natures or ideas themselves had these opposite qualities; but not if a person wanted to prove of me that I was many and also one. When he wanted to show that I was many he would say that I have a right and a left side, and a front and a back, and an upper and a lower half, for I cannot deny that I partake of multitude; when, on the other hand, he wants to prove that I am one, he will say, that we who are here assembled are seven, and that I am one and partake of the one. In both instances he proves his case. So again, if a person shows that such things as wood, stones, and the like, being many are also one, we admit that he shows the coexistence the one and many, but he does not show that the many are one or the one many; he is uttering not a paradox but a truism. If however, as I just now suggested, some one were to abstract simple notions of like, unlike, one, many, rest, motion, and similar ideas, and then to show that these admit of admixture and separation in themselves, I should be very much astonished. This part of the argument appears to be treated by you, Zeno, in a very spirited manner; but, as I was saying, I should be far more amazed if any one found in the ideas themselves which are apprehended by reason, the same puzzle and entanglement which you have shown to exist in visible objects.


Programming language tools, usability, and authority

If you haven't seen it, you might take a look at the Gidget project: http://gidget.ischool.uw.edu/ (there are links there to three papers on it). The authors produced a compiler that emits error messages that are very different in tone than those in one might call normative compilers. Error messages are typically very authoritative and objective in tone: "Syntax error" is one of the most famously unhelpful ones, and in general, programmers usually write error messages (especially compiler error messages) from an imaginary omniscient point of view, in which the compiler (which is really the personification of the compiler writer) knows everything and any error is always the end-user programmer's fault. Andy Ko and Michael Lee experimented with a compiler whose error messages have a very different personality: they portray the compiler as likeable but a bit naive, and in need of the programmer's help.

I think the distinction between error messages that amount to "you did something wrong, you ignorant buffoon" and error messages that amount to "I, the compiler, am inadequate to the task of understanding your intent" is very important. Certainly for students learning to program, and, I think, even for expert programmers -- as much as professional programmers might like to pretend to be beings of pure logic, I think it's human nature for most people to use the same cognitive tools to approach their relationship with the machine as they would to approach relationships with other people. So it would certainly help if the machine didn't act like a sociopath.

I also think that usable type error messages (and other sorts of error messages) are a very unappreciated area of language design and implementation, and to me it comes down to the question of whether a language designer designs to exclude (to shut out users who aren't socially connected enough to get access to the tacit knowledge needed to learn) or to include (designing a user interface to be welcoming and documenting it well so that outsiders can learn too). To me, this is one aspect of programming language design that directly relates to feminism. I associate poorly-documented, hard-to-use systems that are defended with the tagline "If it was hard to write, it should be hard to understand!" with hierarchy and authoritarianism.

Hope this is of non-zero usefulness! I look forward to seeing more about your work as it progresses. Oh, and if it's not obvious, it appears that a lot of terrified male programmers are reading this blog post and feeling the need to defend their turf. Behind the posturing, there's a big old intellectual void.


Gidget sounds really awesome!

Gidget sounds really awesome! One thing I notice when I work with students is how they react the first time their compiler tells them they made a mistake. Computers ALWAYS put the blame on the user, which I think needs to be addressed. If the user makes a "mistake" because there's a problem with the interface, how DARE the computer blame the user! That was the programmer's fault!

Some take this unnecessarily far, and one of my favorite Linux bloggers took issue with it: http://doctormo.org/2010/08/03/is-this-acceptable/

I've commonly made my error messages utilize the first person ("Whoops! I messed up!"), because I want the user to realize that it's not their fault that my program crashed. Our programs, our computers, and our programming languages should not be so quick to judge users, especially when the programs have no judgment skills of their own.

Pat L

Thinking of issues and so on so forth

Hello! First off, I am a programmer, ex of computer science (Bachelor's).

So now in a discussion of object orientation I believe I have successfully objectified myself. Well done me.

Of course the first sentence isn't really relevant, because we could just work on the basis everyone's views are useful and important and work within this.

I see analysis of the possible analysis of programming languages using feminism as emminently possible and something other fields do. Take for example jurisprudence, which concerns the creation and validity of a system of laws. Day to day legal practice can exist with or without this, but take the example of  murder.

On average, a woman is weaker than a man, so is more likely to require a weapon to kill another person. A man, with the strength to kill another person, can do so, in some cases, without needing a weapon. In English and Welsh law, the obtaining of a weapon is considered premeditation, and is sufficient to mean that the killing is murder rather than manslaughter and so the person convicted would likely be jailed for longer, for what some would read as the same crime.

So you have a justice system, but if you think of what justice is, or might mean, then you don't have a justice system. Feminist jurisprudence is one of many forms of jurisprudence, you could also ask about Marxist programming languages for example. Would this work? You could say, that C, as a bootstrapped language is more anarchic, or possibly marxist as it doesn't rely on another language to work (probably ignoring assembly) (http://en.wikipedia.org/wiki/Bootstrapping_(compilers)) Is bootstrapping as development a political issue? Would a new programming language developed via bootstrapping by less concerned with power structures? A stand alone language is more contained, and so isn't at the mercy or exposed to decisions made elsewhere.

An example in software terms would be that open source software can be written in many ways - it could be written to conform to various coding standards. In doing this, however, it may make it harder to people who don't code in that way or who understand that standard to write for it. As such, you could say the code is less open. Is bad code, per say, more open? I don't know, but I would resist the idea that all developers are aghast by the idea of code which isn't elegant. I've spent the day writing something a non-programmer will need to maintain, and so it is written with that in mind. It is far, far, far from elegant.

As such we could move towards a notion of literacy or structures in which code functions or the areas around code. A modern example is the point raised about about relational databases. Gender could've been summised as M/F, but this would now be considered bad practice (in some schools of thought). 

If we consider feminism as anti-kyriarchy (http://en.wikipedia.org/wiki/Kyriarchy) then a lot of coding ideas such as inheritance, abstraction, public and private functions become involved. Assuming something is related to something is a valid development question. 

A lot of the logic propositions also based on people identify a concept or property. Say if the private keyword didn't mean you can't call this function, but that instead I would not reveal this unless I knew why it was being revealed. You could argue the data triples used in open data / xml are an example of something like this.

You could also say that a person object may not need a gender, so the property could be optional, or the property could exist and an object could chose to have it or not. Lots of options in how you consider this. 

I think there is scope to consider the role programming plays in modern culture though, and happy to help if I can.

Good luck



Jeff Binder

A few thoughts

The backlash against this post makes me really glad to have left computer science for the humanities.  Sure, it's not clear what the ultimate outcome of this project will be—but isn't there some room in the world for thinking things out and seeing where they lead?  It's an awfully impoverished worldview that thinks everything has to have a "business purpose."

Even if this project doesn't result in a programming language that's useful in practice, it will (and already has) generated a fascinating discussion.  I'm looking forward to seeing what you come up with.  And I second the person who recommended looking at logic programming—besides not using the true/false logic of procedural languages, logic languages usually allow you to leave certain aspects of structures undefined, which you might be able to do something interesting with.

A recent book that might be relevant is Paul Livingston's The Politics of Logic: Badiou, Wittgenstein, and the Consequences of Formalism, which challenges the commonplace assumption that formal logic must be apolitical.

You might also enjoy this article about "Gay Marriage: The Database Engineering Perspective:" http://qntm.org/gay


Wow! What a great way to

Wow! What a great way to introduce databases!

This reminds me of a project update from the Diaspora* project - an attempt to create a de-centralized facebook alternative. One developer made a simple change to the database: "Gender is now a text field".


Why would this cause so much controversy from a technical perspective? What benefit do we get from having a social network keep track of our demographics in binary forms - I can understand it for something like a school or something where they want to keep tabs on how many boys and girls graduate as part of their mission for equity, but for a social network, there is no useful functionality gained from this abstraction.

It's just like https://github.com/joyent/libuv/pull/1015 - someone made a pull request to replace a gendered pronoun in a comment... they replaced "he" with "they". Look at how long the discussion goes. Look at how one developer stubbornly reverts the change after someone else makes it.

Software developers, the slashdot crowd, the redditors, the hive mind of 4chan, they see themselves as the last front protecting us from "political correctness gone mad". These people are absolutely and irrationally terrified that a dialogue about gender and equity will somehow censor them from doing what they do. These people with these attitudes are the ones who are making the languages. They make the environments. They tell women "all you have to do is read a tutorial or take a MOOC" to learn the environment. To them, the environment is a purely technical entity, and the act of questioning it nets you ridicule. Women get a x2 ridicule modifier.

Here's a paper called "Patches don't have gender: What is not open in Open Source". It was linked by another blogger commenting on this one. http://nms.sagepub.com/content/14/4/669


The humanities aren't devoid of this behavior either. You haven't escaped it, you're just in an environment where it sounds different.


Feminist Critiques of Object Oriented Programming

There's actually a really useful feminist critique of the epistemological assumptions of object oriented languages in this piece by Cecile Crutzen and Jack Gerrissen from the 90s. I think there's a lot of useful critique that could be done alongside a project like this. Object oriented languages are also fairly complicit in a kind of neoliberal structuring of labor and infrastructure, as Alex Galloway has pointed out. This is all really great stuff!


Ian Horswill


It's totally believable that there would be a feminist critique to be made of traditional PL, but can you give me an example of the kind of issue you're thinking about at the level of code?

PL design is traditionally about trying to let programmers say the things they need to say as conveniently as possible.  So arguments about it take place in the genre of "it's hard to express X in traditional languages, so here's my PL construct Y that let's me say X better,"  where "hard" means something like:

  • You can't express it at all
  • You can express it, but it's it's ugly, counter-intuitive, error-prone, etc.
  • You can express it but it's inefficient enough that no one ever does

One could certainly imagine extending this to "traditional languages push you to express X rather than Y because of bias Z, so here's my PL construct W that undoes that."  But it's very unclear to me from the discussion above what an example of that might look like.

Ian Horswill

Logic, binaries, and programs

Just as a technical matter, I think it’s important to say that classical logic has little or nothing to say about whether things like gender are binary oppositions.   It’s purely a matter of how a given human chooses to formalize it within the logic.
If we choose the most obnoxious possible formalization of gender, we do get a binary opposition.  This is when we model gender as a single predicate, male(X).   So we aren’t even saying that there are two genders, male and female, we’re saying there are two genders, male and not male.  But it’s an active choice to adopt this formalization, not a necessity imposed by the logic.
But if we formalize gender with two predicates, female(X) and male(X), we don’t get a binary opposition by default.  Instead, we have four possible genders: female (and not male), male (and not female), both, and neither.   We only get a binary opposition if we add the additional axioms:
     For all X: not(female(X) and male(X))          // rules out  “both”
     For all X: male(X) or female(X)                      // rule out “neither”
One might complain that female/not female and male/not male are still binary oppositions.  But again, nothing in logic is locking us into that.  It requires some additional axioms, but we could equally well have formalized male and female as continuous values:
     female(chris, 7.5) and male(chris, 7)
meaning that chris has 7.5 units of “femaleness” and 7 units of “maleness”.
To be clear: the point here isn’t that this is a good model of gender; just that even classical logic doesn’t lock you into binary oppositions, apart from the truth/falsity distinction.
In fact, one of the technical problems with formal logic from a knowledge representation standpoint is that it’s so very oblivious to exclusion (binary oppositions and the like) that it’s easy for a program to think that a light switch is simultaneously turned on, turned off, destroyed, and not yet manufactured, all because you didn’t think to tell it that those were mutually exclusive states.
Cathy Davidson

Thanks, Ian. I hope this generates a great conversation

Your formulations are so clear---I'd love to see some of the programmers in this thread take this on.  On the level of propositional logic, and its rules, I hope someone knowledgeable response to the feminist code hypothesis. I'm not qualified to answer.   I just rememeber endless discussions when I lived in Japan and happened to be close to a group of SONY AI programmers who, quite speculatively, were trying to rethink the grounding of propositional logic, that exactl this formulation is where they were thinking a new kind of logic might emerge:

Quoting your post:  "But if we formalize gender with two predicates, female(X) and male(X), we don’t get a binary opposition by default.  Instead, we have four possible genders: female (and not male), male (and not female), both, and neither.   We only get a binary opposition if we add the additional axioms:

     For all X: not(female(X) and male(X))          // rules out  “both”
     For all X: male(X) or female(X)                      // rule out “neither”"
A good friend on Facebook, one of the world's most renowned AI designers, found this whole thread silly.  He didn't say why and was too kind to really trounce anyone, but I'm assuming it was based on the basic principle of propositional logic of the truth/falsity distinction.    You kindly don't dismiss the above thread as  silly (and he was also choosing not to be involved in a conversation that was founded on what he saw as  some  lack of understanding of propositional logic and code).  That said, the kind of speculative conversations of my Japanese friends to which I referred in my comments was precisely based on trying to build a new kind of logic which was not based on a universal truth/falsity distinction but was relative to the user.     They spent a lot of time fantasizing (and it was entirely speculative) a logic not based on exactly that truth/falsity distinction but on what is sometimes called the "Hai!" phenomenon, where "Hai" or "yes" means "I hear you" not the opposite of "no," but the degree of "no-ness" is relative to the relationship of the speaker and the hearer.    Is it possible to write a code that talks to machines such that they talk back relationally, knowing when to say "Hai" rather than "no"?   Again, this was meant to be speculative, not literal, a challenge to existing code and existing propositional logic. 
To take this into a completely other tangent, I remember some computer scientists and engineers being annoyed by Sebastian winning the Darpa Grand Challenge of the driverless car competition based on Google street view, not on something more abstractly logical.  One of my engneering friends dismisses the self-driving car as "mere statistics" not "artificial intelligence."  (I find this funny, although I'm not sure I understand quite why it makes him so mad.)   As I understand the self-driving  car (which I have driven), it is constantly recalibrating based not just on real time and stored images of the world it is traversing but on thousands of calculations based on the erratic and variable behavior of those around it, such as easing into a stop more slowly than it needs to in order to  reassure a nervous driver that it is stopping.  
I am making leaps (I suspect some pretty silly ones)  outside both propositional logic and  far beyond my knowledge base here (I actually don't know the driverless car operates on anything like the principles my Japanese friends were interested in:  I'm making an analogy, not a comment about logic there).   The Sony AI folks of the eighties/nineties were, in a metaphoric sense, looking for a logic that would be able to develop Japanese robots that operated far less by the truth/false distinction than by "Google street view" for social-linguistic norms---before anything like Google or Google maps existed.   Put another way, they were seeking a programming logic that operated situationally, factoring in, in real time, culture and cultural variables and social, human dynamics of speaker and hearer (age, gender, class status, who is speaking, and other variables in Japanese discourse) intrinsic to Japanese discourse and social interaction.  It is from that relational point of view that the idea of a feminist programming language makes provocative sense to me.  I'm not sure if that is where the early, open-ended comment took others but it, perhaps nostalgically, took me back to those late 1980s and early 1990s conversations in Osaka.  
What is so great about the clarity of your post is it helped me to see the issues I was thinking about more clearly, Ian.   Propositional logic as the basis for programming is a way of talking to machines.   My Sony AI folks were more concerned with programming machines (robots) who could talk to us in a situationally appropriate manner that, in Japanese and, indeed, in all languages (even where less codified --or more!) is foundationally not about truth/falsity but about social networks and, indeed, hierarchies. Certainly fuzzy logic was all the rage then (one of them helped program the famous Sendai train that initiated fuzzy locomotion) but they wanted to take it to the next level. 
Again, I am talking here from the perspective of someone who is an outsider and amateure in this field. It is simply from lifelong interest not a knowledge base, but I continue to be fascinated.   You must be a sensational teacher.  Your clarity here, I hope, will spin a next-level conversation.
p.s.  I haven't seen Her yet but the reviews make it sound relevant.  Not sure.
Ian Horswill

Truth and silliness

Hi Cathy.  Just a couple of things:


Representing degrees of truth (e.g. fuzzy logic) is an important issue.  But it doesn't get you out of binary distinctions; it just pushes them to a higher level.  That is, even if truth(P) is continuous, rather than binary, it's still assumed to have some definite value, and so the meta-level statement:


is either true or false.  Another way of seeing this issue is that you can encode anybody's logic, so far as we know, in vanilla first-order logic.  So going multivalued does remove a truth distinction.

The intutionists might have a different take on this, since I believe the reject truth values in favor of provability/unprovability, but even that is a binary distinction in the meta language, so I'm guessing the general statement still stands.  But a real philosophical logic person would be able to give a better read on this.


I don't know that I'd call this discussion silly.  Computer science has serious gender issues, and it's plausible that those might play into issues in programming language design.  But to be honest, I don't think it's terribly productive to critique the metaphysics of programming languages (binaries, objects, etc.).  I don't think the notion of object in OOP has much to do with the notion of object in subject/object dualism, either conceptually or historically.

That said, I think a sociological critique of programming languages could be very fruitful.  Tom Knight at MIT once said there are two schools of programming language design: the "let them win" school and the "keep them from losing" school.  The former focuses on making languages as expressive as possible, while the latter focuses on discipline, rigor, safety, etc.  One of the reasons it's hard to productively critique the ideology of OOP is that it's actually a complciated historical phenomenon that came out of both camps.  On the "let them win" side, there were the Smalltalk and Lisp Machine people (among others), and on the "keep them from loosing" side, there were people like Barbara Liskov working on CLU.  Then it was taken over by industry and brought in still other directions.  So it doesn't really have a single, coherent ideology.  But there is a coherent ideology to the Dijkstrian "Discipline of Programming" school that would be easy to critique from a feminist perspective.

In any case, if one really wants to come up with a feminist programming language, then whatever critique one makes would need to translate into specific, detailed, and substantive changes in language mechanisms.


Agent oriented programming and subjects

I must admit, that at first I thought the idea of a feminist programming language was a joke. But after several days of thinking, I found the idea more and more interesting.

I also noticed the rather juvenile parodies. I think it could help calling it something else, like "humanist programming language", but I am not the right person to suggest the best name of the topic.

One way to get further, could be to learn from other programming concepts with similar ideas. I would suggest that you take a close look at Agent-oriented Programming (http://en.wikipedia.org/wiki/Agent-oriented_programming). I can recommend the way it is implemented as part of the language Scala.

Regarding the (p && !p) problem, I have a good solution: Whether something is true or not, depends in many cases of which subject (or agent) that you ask. So in a system with multiple subjects (or agents), p can both be true and not true.

Furthermore, it could make sense that a subject could be in multiple parallel states (indecisive state). This is both known from quantum physics, and from real-life people behavior. Not so used in computer science, but I think it could make sense in a real programming language.

I can come with some more detailed examples, if you are interested.


Feminism and Coding-- Worth Thinking About


I wish we could include neuroscientists and developmental psychologists in this discussion because I think we are dealing with social issues here more so than science, code, or logic.

I have no idea what a feminist code means or would look like but that's not the point I am taking away from this discussion. The point, I think, we should consider hard is why there are so few female computer scientists out there:

"Nationwide, women earned only 18 percent of the bachelor's degrees awarded in computer science in 2010, according to the National Science Foundation. That's less than half the proportion in 1985, when 37 percent of those degrees went to women." (http://chronicle.com/article/Rebooting-Recruiting-to-Get/135282/)

Because I have a 4 year old son, every now then I read about developmental psychology. My sparse understanding based on the little that I have read so far is that at least among young children, girls are better in activities that involve abstract, decontextualized thinking (what exactly these activities are, by how much girls perfom better than boys, and why, I could not--scientifically-- explain).

Then, Why on earth are there so few women in comptuter science (and science in general, in academics in general. Check out "Women as Academic Authors 1665-2010" The Chronicle of Highher Education, October 22, 2012)? ?

And would the science of computing be different if 80% of the field's graduates were women? I don't know. But I find it very much worth thinking about.

Arielle thank you for opening this topic up for discussion and thanks for the thoughtful, meaningful responses most of the respondents gave above.


Evan Donahue

Math and language: not so easily divorced

It seems to me that there are two main threads in the comments here: how might feminism apply to programming languages, and how might feminist programming languages apply to programmers. I have some thoughts on the latter, but for the moment would like to respond to the former. In particular, I would like to try to propose a constructive way forward that navigates between the precise, mathematical formulation of logic as the programmers in this thread understand it, and the linguistic, cultural mode of logic that the feminist theorists in the thread are bringing to the table.

In response to Barry Peddycord, Ian Horswill, and others who have offered illustrations of disolving gender binaries with propositional prestidigitation (or those who expressed confusion about how to reconcile mathematical logic and programming with feminist theory), let's take the statement is_a_man(tiresias):

It is of course easy to add additional machinery such as an is_a_woman predicate, or an additional argument to is_a_man(tiresias, .5). Propositional logic can certainly handle these modifications. Moreover, if we adjust our semantics to appropriately interpret our new syntax, then we can resolve in this instance this single conflict. I agree that this formalism does supply representational latitude. However, that latitude is not infinite; it is constrained by the neurological capacity of the human mind. First, note that even in the apparent compromise of is_a_man(tiresias, .5), while we have resolved the direct conflict between man and woman, we have introduced the absolute that Tiresias is .5 of a man in all contexts, at all times, and for all reasons. We have made a universal, unqualified, general statement that is only one degree less general than is_a_man(tiresias). Now let's play the trick of modal logic and add in dimensions for temporal logic to describe when tiresias was a man, epistemic logic to describe whether tiresias friends knew him/her as a man, deontic logic to gain a sense of the divine edicts that bound tiresias to the reality of being a man, and doxastic logic to characterize what tiresias' friends thought of this debate. I would argue that the proliferation of different types of modal logics is as much evidence of the sense logicians have always had that something fundamentally lacks in logic as it is the solution to that lack.


I would suggest that the idea that this dichotomy can be avoided with a simple representational choice, and that the machinery of logic is wholly outside those choices overlooks the fact that logic does force us to make very significant commitments: it forces us to speak about the world only in positive, universal statements, and one of the central lessons of feminist thought is, I would argue, that every universal is wrong in the right context. Now, you might still be able to escape this by arguing that one could, in theory, assign a proposition to every mollecule of the universe, every unit of time discretized down to the Planck constant, and every neuro-electrical configuration of every conscious brain and, by the magic of the universality of computation, build a model that could speak to the specifics only and never over generalize. The trouble with this is that logic has a dual nature: in its strict, mathematical sense, of course this should seem possible. It is possible mathematically to imagine this universal proposition. However, logic (even "mathematical" logic) is not purely mathematical: we speak in terms of ands, ors, and nots rather than nands because no matter what a computer might be able to compute, logic that can never be compressed enough to speak understandable statements to a human brain can simply never be used to create new knowledge. We could not speak to a computer that could speak to a universe. I would suggest that this is the essential reason why logic-based AI has been such an elusive project over the years; locally, it seems easy to just add another dimension or another predicate and brush away any conflict. However, when you begin to scale that system up to the level of a complete, logically consistent human intelligence, what researchers have encountered time and time again is that picking the right predicates to make a consistent system on that scale is a task that simply dwarfs the comprehension of the human mind. Making one change to one predicate is easy, but when thousands of other predicates in your knowledge base rely on that predicate, a small change could destroy the intuition underlying a whole other section of the graph.

Therefore, to Barry:

I would suggest that "((Tiresias is a man) && (Tiresias is not a man))" is true in that Tiresias is a man *in a certain sense*. And that "certain sense," or the context in whith Tiresias is a man, is one that would be impossible both to express completely with the temporal, epistemological, etc dimensions in purely positive, mutually consistent statements, and to express concisely enough to be of value to a human interlocutor. On a side note, I am having difficulty locating on what point exactly you believe we disagree. I certainly did not mean to posit that man and woman are innately opposite, and generally concur with your sentiments on modelling. If you could clarify where you believe we disagree, I would love to respond.

and to Ian:

In response to your call for an example, I would put forward a partial example/intuition I have been having on this point: Tiresias is a woman in the sense that Hera decreed that she be one. The essential way that I think this differs from simply a modelling decision within propositional logic is that rather than creating a completely "consistent" system in the traditional sense by adding dimensions until all of space-time is embraced in our predicates, rather the way to think about this programming language "as" a language might be to allow that is_a_man(tiresias) may simply be inconsistent with the same claim made in another context. p && !p, but accounting for the discrepancy by embracing inconsistency and subjectivity rather than by attempting to model explicitly a world so complex that no programmer could work with it. Inconsistency not in some sort of mathematical sense necessarily, but in a lingustic one. Try as we might to deny it, mathematicians are still human, and it is not an accident that mathematical logic reflects human language. Exactly how does one do this? I don't know yet. No one does, and that is why this post was written.

Ian Horswill


We're probably in agreement.  I wasn't trying to argue for any particular representational system, just that (1) commiting to a true/false distinction is logically independent of whether you model any other particular phenomenon as a binary opposition, and (2) that some of the complaints peopel were making about the true/false distinction don't go away when you go to multivalued logic, they just move into the meta-language.

As far as examples are concerned, though, I get that as an example of a representational problem, but less so as a programming language problem in the usual sense.

Evan Donahue

typedef gender

Yes, sorry, I was responding to your call for an example more than anything else. I did not assume we were in disagreement. At the time I thought I was heading somewhere constructive with the formal model critique. Not so sure now, but I do have, I think, a more tangible direction aimed more at the use/development of software as a cultural phenomenon rather than the theoretical model, inspired by some of the other comments about dedicated gender database types.


At least one strand of feminist critiques of logic I have encountered is predicated on the idea that the seemingly universal power of a logic to evaluate the truth or consistency of any set of statements liberates the logician in a problematic way from having to consider just what is being analyzed; problematic because, as I understand it, there is no guarantee that important information (such as memories, feelings, histories) will not be lost by the inability of the modeller to really actually capture the totality of relevant lived experience in the modelling choices. As an illustration of what one might do with this, I would suggest the illustration presented by the ubiquitous String datatype:


In theory, a string is a completely impartial concept, capable of representing any characters. In practice, when you put a sign up form backed by a string data type out on the web, you may, depending on your language, soon realize that, due to poor unicode support, any users who, unlike you (me), work in a non-ascii character set are excluded from identifying themselves by name within the universe of your application. Of course, nothing ever stopped you from appropriately escaping inputs by hand and thereby rolling your own unicode--the tools were sufficiently general-purpose--but the language did nothing to help you out of your ascii-centrism. The problem only worstens as you capture moer names, genders, and cultural identities with strings bools and ints. Operating on the assumption that a significant amount of software ends up having to interact with end users in the world, esp via the web, one might imagine a general user-oriented programming language that built in notions like gender, language, geography etc. so that instead of treating a name as a string, one could treat a name as a name and know that the system would handle language, naming conventions (first/last, only one, etc) and do the same for gender, assumptions about lifestyle (asking for people work vs home number, cell number, etc) in a more culturally attuned way than is invariably produced time and again by programmers for whom these issues are not central to their work. That direction seems to me like it would serve a very immediate practical need as well as achieve some reasonable political ends.


At least one strand of

At least one strand of feminist critiques of logic I have encountered is predicated on the idea that the seemingly universal power of a logic to evaluate the truth or consistency of any set of statements liberates the logician in a problematic way from having to consider just what is being analyzed; problematic because, as I understand it, there is no guarantee that important information (such as memories, feelings, histories) will not be lost by the inability of the modeller to really actually capture the totality of relevant lived experience in the modelling choices.

Whenever you begin a proper logical argument, you are first required to fully state your "universe of discourse". While this is often omitted since the universe is assumed to be understood, a logical argument is only consistent within a well-defined set of boundaries. Once you change those boundaries, it's a safe bet that nothing that has been previously defined can continue to be held as true or false unless they were accepted as axioms at the outset. You changed the system, you have to clean out the sandbox and start over again. This is why our math teacher taught us not to cut corners doing proofs. ;)

A logician is not liberated from disregarding race if they plot city districts vs arrest levels and make some "logical" iPhone app that tells you how to avoid the dangerous parts of town on your road trip. Their model doesn't simply "not consider" race. Their model "assumes that there is no effect of race on these variables at all", which is a pretty huge assumption. All models should come with the implied disclaimer that "any variables not explicitly stated are assumed by the author to not matter or exist". The burden of capturing totality falls squarely on the shoulders of the modeller. If they are in fact inable to model the nuances, then they are responsible for justifying why such assumptions don't threaten the validity of their model. This is a topic I have to be constantly aware of since I do quantitative data mining research in the world of education, a highly situational context.

The Colour of Numbers by David Gillborn does an excellent job of looking at this responsibility in quantitative methods: logicians can take advantage of the fact that they hold a privileged position in public discourse grounded in... well, you know, 100% accurate and objective logic. Because of this, we as ethical logicians must be aware of that particular privilege and take care not to mislead our audiences by cheating in how we present our models, and also hold other such logicians to task when they make bold - even if silently implied - claims.

The logic does not liberate the logician except in their own imagination. A logician is responsible for their assumptions and claims, and the programmer is responsible for not considering internationalization in their web application.

Evan Donahue

Yes, aptly put: modelling

Yes, aptly put: modelling decisions are often supercharged with assumptions and biases that can be difficult to detect, and that even experienced logicians can (and regularly do) fail to account for in their universes of discourse. Likewise, the programmer is clearly responsible for making sure their interface works for their entire audience, but if the language and tools give you no help, rolling your own unicode/gender support might be eclipsed by other work. If it were easier to create gender or religion datatypes that were appropriately nuanced, not only would more people probably do it but more programmers would also be exposed to those concepts and perhaps more regularly take them into consideration in the full scope of their application design. It would be harder to take a simple view of sexuality when your gender datatype is demanding that you account for a broader set of cases than the classic binary.


At the core I don't think

At the core I don't think there was a disagreement at all, I think some of it can be attributed to my confrontational style of writing. I was just trying to demonstrate a few things using your post as an example.

1. "All models are wrong, some models are useful." For some situations, Having a boolean where True=Female and False=Male is all the expressiveness you need to do the job you need. I don't find that correct, however, I still do it when I write programs where the spectrum of gender is not related to the task of the program identifying women succeeding in programming courses. When that's not enough, you can add more nuance and more nuance until it's as expressive as you need.

2. "The language is right; you are using it wrong". My post was an indictment of the language of logic itself. "Silly Evan! You are making a claim but do not fully grasp the full flexibility of the language! Let me show you a thing!" Any programmer is going to say there is nothing that can't be expressed in a Turing Complete language since, as you said, you can add more nuance and conditions to it. In fact, I feel like if you made the same claim on a programming forum, someone else would inevitably raise the same point. If you need more nuance, there's a universal turn-A quantifier for that. This attitude is something about programmers that rubs people the wrong way, but even more so, there's this appeal to the idea that we don't need another language since the languages we have are good enough.

3. "Programming languages were designed, not discovered". I think it's interesting that you bring up the idea of universal, perpetual truths. I find logic and object-orientation entirely utlilitarian, since it's a useful way of encoding the world in a way communicable to both humans and comptuers. I don't believe that programming languages and their "reification of normative subject-object theory" are what condition our programmers to be misogynistic dudebros. What I do believe is that programming languages are human constructs - they are one way we decided to speak to our computers, and what bothers me is how they are heralded as "true" and "more efficient" when it was entirely arbitrary. And as with all human artifacts, I think this is why a feminist or critical theory perspective is interesting. There was literally a sticky note on my computer on day one of this discussion about how programming languages position certain features over others.

My statement about genders being opposite come from your proposition having opposite gender as a necessary assumption for your model to be logically true, but I would rather not be part of the irony of discussing semantics in a thread about feminist programming languages. :)


Evan Donahue

Sony AI

Also, in response to Cathy: the discussions you are describing with the Japanese AI researchers sound exactly like the things I am currently working on and I would absolutely love to hear more about them.

Jeff Binder

On silliness, etc.

I certainly don’t agree with the people who have called the idea of a feminist programming language silly, but like Ian Horswill, I’m not really convinced that studying programming languages on an abstract, metaphysical level would be all that fruitful from a feminist perspective.  The problem, I think, is that this approach seems to rest on the assumption that we can find direct isomorphisms between programming languages and ideologies.  This is, I think, what Ari has in mind when she says that normative programming languages “reify” normative subject-object theory—the idea that programming languages can implement, as it were, particular metaphysical views.  But there’s a major difference between a programming language and an ideology or metaphysics as it exists in people’s heads, and it’s important to keep in mind the complexity of the relationship between the two.

(Incidentally, I don’t think that “reify” is the right word.  At least as I understand it, reification means incorrectly equating something concrete with an abstract idea.  But no one is equating programming languages with social norms—as we’ve seen, a lot of programmers insist that their tools have nothing to do with ideology at all.  A better example of something that reifies ideologies, to my mind, would be the “political views” field on Facebook.)

One thing I think we need to do is to step back and think about what programming languages are actually doing in the contexts where they are deployed. At least until the robots take over, computational systems can’t uphold gender norms all by themselves—someone still needs to know what the “M” and “F” in the gender field mean. To really understand the implications of computer systems for feminist issues, it’s necessary to look at the discourse surrounding the code along with the code itself.

This isn’t to say that I think feminist critique must stay in its traditional comfort zone of analyzing discourse.  I think it may actually be possible to come up with a programming language that encourages a juster programming culture.  But I’m not sure if we would be able to arrive at such a language through a discussion that treats programming languages as abstract objects divorced from their social context.

I would say something similar with regards to formal logic.  Some of the recent posts have made a convincing case for logic’s inherent limitations as a way of representing gender, but we can still step back and think about what we are actually trying to do with logic systems.  In particular, logic doesn’t have to be used in a positive way—that is, we don’t have to attempt to create a logic system that accurately reflects our own ideas.  It can also be like this: let’s come up with a logic system based on a view of things we don’t like (or are not sure about) and see if we can show that it leads to absurd or repugnant conclusions.  Logic systems can also be seen simply as toys, used to play around with ways of reasoning that are different from what we are used to.  I would argue that, from a feminist perspective, it would be more useful to question normative assumptions about what logic is for than to try to come up with increasingly nuanced ways of representing gender propositionally.


I think it may actually be

I think it may actually be possible to come up with a programming language that encourages a juster programming culture. 

I must disagree with you, Jeff. As you said, we should look at the discourse surrounding the code; the code itself isn't the problem here. Programming culture, as my experience goes (I've been in some smaller projects, as well as the student body in my college) is dismissive of politeness (Linus Torvalds and Tantek Çelik are great examples). The change must be in the programmers themselves, not the languages.

I would argue that, from a feminist perspective, it would be more useful to question normative assumptions about what logic is for than to try to come up with increasingly nuanced ways of representing gender propositionally.

Computers are restricted to normative assumptions about what logic is for because of the way computer circuits are designed. The underlying principles of code and circuitry have changed little since ye olden days of COBOL. To change such paradigms, a major redesign of circuitry would be needed.  (Do read "Code" by Charles Petzold, if you are interested a longer explanation of why; it explains everything from the code to the circuitry.)

Jeff Binder

Playing with logic

I must disagree with you, Jeff. As you said, we should look at the discourse surrounding the code; the code itself isn't the problem here. Programming culture, as my experience goes (I've been in some smaller projects, as well as the student body in my college) is dismissive of politeness (Linus Torvalds and Tantek Çelik are great examples). The change must be in the programmers themselves, not the languages.

I may be totally wrong about this. But I do think programming languages can encourage particular ways of working together. The OOP idea of encapsulation is an obvious example—it's tailor-made for the division of labor. I'm not sure exactly what a programming language that encourages a feminist organization would look like, but I'm not ready to rule it out either. The ultimate test, of course, will be when someone actually does it.

Computers are restricted to normative assumptions about what logic is for because of the way computer circuits are designed. The underlying principles of code and circuitry have changed little since ye olden days of COBOL. To change such paradigms, a major redesign of circuitry would be needed. (Do read "Code" by Charles Petzold, if you are interested a longer explanation of why; it explains everything from the code to the circuitry.)

I think maybe we're talking about two different things. It's true that computers as we know them are tied to a particular sort of logic, but it wouldn't take a hardware change to rethink the ways in which we use them. In particular, we can rethink the way we use data structures to represent the world, which is something that has far more to do with the people using computers than with their circuitry.

We could think, for instance, about different ways in which a social networking program might deal with gender. An obvious feminist move would be to replace the male/female options with a free-form field, but we could change things in more radical ways than that. What if, instead of a gender field, a site used something that worked more like modes of dress? For instance, rather than explicitly stating their gender, people could decorate their profiles and posts with colors and icons that have (possibly ambiguous or contradictory) gender associations. This would replace the direct representation of gender with signifiers that work primarily through connotation, that are expected to change frequently, and that suggest intentionality in a way that gender labels generally do not. It wouldn't involve a fundamental change in how computer logic works, but it would encourage a change in what people do with it—in this case, encouraging people to see computational symbols as things to play around with rather than as bearers of objective truth.

I'm not saying this way of handling gender would be a good idea necessarily, but I hope it shows more clearly what I'm talking about.


It's a disagreement about what is important here

I may be totally wrong about this. But I do think programming languages can encourage particular ways of working together. The OOP idea of encapsulation is an obvious example—it's tailor-made for the division of labor.

I think you are jumping to conclusions here. Encapsulation in no way or form has anything at all to do with the division of labour; it's merely there to separate the more static components of a program from the parts that are likely to change more quickly as versions come and go. It sounds like the social concept of separation of labour and/or classism, but it doesn't means it is. Conflating social structures with programming structures is not a good way to talk about software engineering.

I'm not sure exactly what a programming language that encourages a feminist organization would look like, but I'm not ready to rule it out either. The ultimate test, of course, will be when someone actually does it.

What part of C++ opresses women? In which way Python contrubutes to the patriarchy? Is Perl the exception for being non-normative or is it even worse? First, and foremost, you must define what makes programming languages non-feminist and/or patriarchal. Especially since software engineering is, after all, engineering; it means that to implement such a model, it needs to improve its predecessors in the relevant areas; in software, those would be expressive power, understandability and maintainability.

I think maybe we're talking about two different things. [... ] I'm not saying this way of handling gender would be a good idea necessarily, but I hope it shows more clearly what I'm talking about.

Oh, I see. Thanks for clearing that up. It's because this discussion sparked up some critique of binary machine language itself.

Jeff Binder

It's not that computers are evil

I think you are jumping to conclusions here. Encapsulation in no way or form has anything at all to do with the division of labour; it's merely there to separate the more static components of a program from the parts that are likely to change more quickly as versions come and go. It sounds like the social concept of separation of labour and/or classism, but it doesn't means it is. Conflating social structures with programming structures is not a good way to talk about software engineering.

Programming languages are not created in a vacuum; practical ones, at least, are designed to function in institutions for which the question of who works on what is significant.  OOP can make large projects involving multiple programmers easier to manage, and I don't think it's at all a stretch to say that this is one of the main reasons for its popularity.  An advantage of encapsulation from a project-management perspective is that it allows for a more efficient development process if two classes are the responsibilities of different people—ideally, at least, the person working on class A can do their job without having to worry about the details of how class B is implemented or how it might change.  OOP (and modular design of other sorts) makes it easier for managers to divide programs up into parts and delegate responsibility for them to different people.

What part of C++ opresses women? In which way Python contrubutes to the patriarchy? Is Perl the exception for being non-normative or is it even worse? First, and foremost, you must define what makes programming languages non-feminist and/or patriarchal. Especially since software engineering is, after all, engineering; it means that to implement such a model, it needs to improve its predecessors in the relevant areas; in software, those would be expressive power, understandability and maintainability.

I never claimed that C++ in itself oppresses women, but I do think programming paradigms can have an effect on how workplaces are managed, for better or worse (or for neutral).  I think that it is at least interesting to think about whether a programming language could be designed that encourages a mode of organization less alienating to women.

(I should note that I do not necessarily think it is the division of labor that alienates women.  I was just using that as an example of how programming languages can encourage certain management styles.)


I am curios on what ground

I am curios on what ground author assumes what all existing programming languages are not feminist? Regarding that first program was written by woman Ada Lovelace, first compiler for the computer was written by woman Grace Hopper, who is also conceptualized the idea of machine-independent programming languages, which led to the development of COBOL, one of the first modern programming languages.


Logic, Languages, Interpreters, Compilers, Humans and Posthumans


This thread was brought to my attention by Cathy Davidson many weeks ago and it's been popping in and out of my thoughts ever since so I thought it was probably time for a brain dump on the subject. Please accept my apologies, in advance, for the rambling nature of this post:




"I decided to explore feminist logic such that a feminist programming language could be derived."


Could you please provide us with some links to the feminist logic that you've been exploring as it'd be great to get some more context about the issue? My basic grounding in feminist critical theory has mostly centred on language and not really explored logic.


However, from reading the comments about non-normative logic paradigms (P == !P etc.) it may useful to take a look at non-deterministic systems whereby the execution of an instruction changes the outcome of the subsequent instruction with the same inputs (so-called "nondeterministic algorithm"). One potential place to look at is their use in non-congruential pseudo-random number generators.


Language, Interpreters and Compilers


I'd be most interested to hear at what level you are intending to derive a "feminist programming language". Whether it be at a purely theoretical (i.e. computer science) level or whether you are considering it at an executable (machine) level. Although perhaps it might be a good idea to look at the various levels in between:


Much of the discussion has centred around the "languages" the programmes are authored in: e.g. object oriented languages such as C and Java, pseudo-OO such as Python, delighfully duplicitious languages like JavaScript which are object oriented but permit functional programming concepts.


[Aside #1: I recommend completely ignoring "markup" for your endeavour, and that includes HTML, SGML, XML, The Semantic Web, Ontologies and (yes, even) databases. I think applying feminist critical theory to these would be a whole separate PhD in itself and, whilst related and equally meritorious, is a fundamentally different beast to programming languages. Although if you *do* want to address this then: cool, let's talk!]


But higher level programming languages themselves are merely constructs that only exist due to the execution contexts provided for them by lower level ones.


Taking Java as an example: it's portable nature exists only because the programmes that are written get compiled into an Intermediate Language which is run through an interpreter which itself is built to execute native code for a particular machine, or operating system. The Java interpreter has been compiled so that it is able to execute instructions for that particular machine - which implies that it is bounded by the limits of that machine.


Machines are themselves merely electronic processors (CPUs) that have predefined instuction sets which largely involve pushing numbers onto a stack and performing primitive mathematical functions (ALU) on them. If you really want to, you can write programmes in machine code and load them onto PICs.


The electronics themselves consist of complicated arrangements of logic gates, which are themselves just an arrangement of (in essence) transistors, which themselves are just an arrangement of semiconductor materials which have been doped with impurities like boron, phosphorus and arsenic allow current to flow or not flow by donating or accepting valence electrons when a voltage is applied in a certain way.


Beyond this, we try and explain the behaviour with quantum mechanics and no one really understands that!


So the point I arrive at is that the purpose of programming languages (in the real world - not at a comp sci level) is to abstract away the complicated task of making a machine behave in a certain way, without having to do a lot of really hard work to get it to do so.


You've probably noticed something by now: this gives you an angle to explore your topic using a deconstructionist approach at one or more levels (but maybe that's not appropriate).


[Aside #2: it's useful to be aware that whatever level you're programming at, there's something more fundamental going on at a lower level and you might be able to use this. Some programming languages even specifically allow you to do this. In its first iteration, C# allowed you to drop from its Java style into "unmanaged code" and declare and access C++ pointers. In subsequent iterations they have provided a namespace (Reflection.Emit) that allows you to write Intermediate Language directly. I was recently able to to use this in a WCF project to write IL which enumerated the methods of a sealed WCF client and wrapped each of them in a try/catch(handle by logging)/finally(cleanup and reset) to catch exceptions and render the client usable for subsequent calls. So when you read the next bit, remember this: you can sometimes break the parameters that a framework has imposed upon you.]


Even if you don't want to address the lower levels when creating a feminist programming language it's probably a good idea to bear in mind two things:


1) in doing so, you are creating a set of boundaries within which code can be written and therefore operate;


2) so what are you actually allowing the executed code to do? and why is it desirable to constrain it (or unconstrain it) in this way?


A possible third thing (yes I know this is a stupid way of throwing this in as I said to only bear in mind two things) is: *can* you enforce it? (See the aside #2 about breaking parameters.)


[Aside #3: does a feminist programming language imply that "gender" must exist within programming languages? If you define gender as being a predefined way of conforming or operating then it inherently does (within our own language definitions) as if you look at the myriad ways that programming languages encourage or enforce programming styles (or patterns - I don't really want to get into the normative implications that OO modelling encourages but you will probably have to at some point) then it may be worth considering whether programming is currently multi-gendered rather than the (assumed above by many commenters) binary. Ian Horswill touches on this in his discussion of logic (above), but if you extrapolate his comment to higher level languages it could imply many more "genders" exist within them.]


But this all leads us on to: humans


(Here's where I get a little bit confused about interpretations of gender/queer/trans/post within feminist critical theory so please forgive me when it doesn't really make sense.)


Our human view of gender (and associative mores) is most often expressed in a binary way but this is increasingly being questioned. I think it wouldn't be appropriate to, assuming a multitude of genders amongst programming languages, to try and map these to a binary definition of gender - because it strikes me as defeatist and counter to the purpose of a feminist programming language.


So instead, you might want to approach this by trying to identify the elements of existing programming languages which align with elements of feminist critical theory (though, in typing that is seems that it's probably something you've already considered).


There's a lot of evidence to suggest that language shapes the way that we view ourselves and our place in society, which is particularly prevalent in feminism (apologies I don't have the links to hand but Google will help you) as it illustrates how history/narrative has had a major effect on how groups of people (e.g. women, WoC, queer, trans*) have been portrayed to future generations and thus marginalised. It's interesting to see the "objective" comments from programmers (Juliet Rosenthal is illustrative but this may be a massive misinterpretation on my behalf) which fail to objectively realise that programming languages, like language, encourage the same thing - i.e. they encourage you to describe problems, model solutions etc. in certain ways.


So perhaps a way to approach a feminist programming language is to think about the problems that the programming language is trying to address: are they essentially feminist problems? if not then if you were to lay out some feminist problems for which a programming language would be required in order to solve, would it be very different from the programming languages that we have today? (my guess: probably - not just because a lot of the technological advances of the 20th century were due to war)


And to end on a weirder note: what happens when we enter a posthumanist society?


This might be taking it a bit too far for your research but I find it quite fascinating to consider how the frameworks (etc.) within which we currently instruct computers might have a bearing on society when humans are augmented with technology. It makes sense to suggest that if our programming frameworks have been constructed as a result of patriarchy (or capitalism, or whatever!) then when we implement these to have a direct affect on humans we are also applying those assumptions.


And then what happens when humans aren't here any more? Is it right that our legacy might be machines programmed in a way that's biased towards certain ways of thinking that do not necessarily reflect the level that society has evolved to? When we're dead and gone will it be just a bunch of trading machines running a virtual stock market against each other? Or a few marketing bots having ersatz but highly relevant conversations on twitter? (What will the last retweet be? … )


To end with: let's drop that down a level and consider what indirect effect our programming languages (frameworks, patterns etc.) are currently having on people via the ubiquity of computers/smartphones/social media. So another good starting point might be our current technological determinism and trying to rethink how it might have a risen from a feminist point of view.


To Arielle specifically: I really look forward to how this all turns out. Best of luck with it all!




P.S. One last thing as I haven't had enough asides: if you get the time you can try and apply reader-response-theory to JavaScript and the Web. Every browser (implementation) has a different version of the JavaScript interpreter which is a posthuman example of reader-response-theory, as it means that each browser gets to interpret the code in its own way – as it can change the experience that is delivered to the person consuming the website before they've even had a chance to directly create that experience themselves. Stanley Fish would be delighted or abhorred – depending on which browser he used to view this message.

Evan Donahue

typedef gender

EDIT: wrong reply link. See above ("typedef gender")


Subject-object theory

As both a feminist and a programming language designer and theorist, I'm really interested to see where this goes. (I wish I’d been here a few months ago!) I think there’s still a lot of room for radical experimentation in language design, and we ought to be exploring much more of the design space than we are.

I’m wondering, though, if this is really right:

I realized that object oriented programmed reifies normative subject object theory.

It seems to me that traditional procedural programming—in particular, in first-order languages—reifies normative subject-object theory much more than higher-order programming (including both functional and OO) does. In pure OO, everything is both subject and object, and because all interactions are mediated by messages, no “object” is ever acted upon without having a say. Whereas in, say, Pascal, the computation-data distinction is quite rigid: procedures act upon essentially passive values. So am I getting this wrong? Can you clarify?

Also, any updates???