Feminism and Programming Languages

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.

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.

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.

Cheers,
Marco

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?

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."

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.

Here's the link to Ari's follow-up blog on technology and feminism:  http://www.hastac.org/blogs/ari-schlesinger/2013/12/13/feminist-programmer

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:
http://www.hastac.org/blogs/ari-schlesinger/2013/12/13/feminist-programmer

Original Blog:
http://www.hastac.org/blogs/ari-schlesinger/2013/11/26/re-feminism-and-p...

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.

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/

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.

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, 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 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.

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.

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.

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

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

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!

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.90.4954&rep=rep...

The approach tells little about programming languages, but a lot about modern feminism.

Dear A.S., you question each and everything. From ancient logic to modern programming languages and technology, not to mention the society which grants you a comfortable live and rights to criticise everything, not to forget: provides the resources to think months over the topic. But you have no doubts about any “feminist” approach. Have a little of a bias here?

Modern feminism is a terrible ideology if put in work in everday life, it ruins people's lifes. Think of the divorce industry for example. It's contrary to the women's right movement 100 y ago.

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.

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:

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.

Ari's post is in italic.

In the scope of my research, a 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.

This is word salad. "Non-normative paradigm"? "Alternative ways of abstracting"? Did  Ari ever write a line of code, let alone read anything about programming language design and implementation?

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).

The "object" in "object oriented programming" does not refer to the same thing as the "object" in "subject-object theory". "Objects" in programming languages are constructs intended to logically group data and the functions which operate on them.

Their main purpose is to simplify the understanding of the code by other programmers and reduce the number of errors resulting from inconsistent manipulation of data by different parts of the program.

Objects can have methods (procedures that work on an instance of the object) which can in turn call methods on other objects, so there is actually no "subject-object" distinction: every object can both manipulate and be manipulated upon by other objects. In other words, this "insight" is completely off the mark.

And finally, subject-object theory is not important to software engineering.

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.

These are not "groups", these are programming paradigms. It is rare for a language to support only one of them. For instance, Python has imperative, functional and object-oriented features. C++ is all four. Most major programming languages are multiparadigm (except C). Furthermore, there are many programming paradigms; Wikipedia has an extensive list. To say that there are four main groups is a misunderstanding at best.

I cannot even begin to imagine what "feminist logic" is supposed to be, any more than "feminist topology" or "feminist real analysis".

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

I suggest you learn to program in a "non-feminist" language first, instead of classifying according their description. How are programming languages "non-feminist"?

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.

Everything I dislike about postmodernism condensed into one blog post.

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.

"Normative concepts" in programming languages are not there to reinforce cultural norms, they're there so that 5 years later you or the guy who was hired after you left can actually understand what the code means. The human brain thinks in patterns and programming languages are intended to express instructions for a computer in a form that matches the patterns picked up by our brains.

mezangelle is not a programming language at all. It is a very quirky form of poetry formatted to look sort-of-like markup or code.

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

p && ~p is not a falsehood in intuitionistic logic, which is a flavor of formal propositional logic. The main rationale for using it is that a proof of the existence of some property expressed in intuitionist logic is always constructive and can be mechanically translated into a computer program which computes the property. Treating p && ~p == 0 as an axiom allows non-constructive proofs which show that something exists, but tell nothing specific about how that something "looks like".

I have no idea how the idea that "something can be and not be without being a contradiction" is feminist.

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.

The first sentence might indicate that this person is unaware or inaccurately understands the notion of Turing-completeness: if the language meets certain criteria, it can express the computation of everything that is computable. It's not possible to design a language which answers different "types of questions" than normative languages. (Unless Ari is aware of some new, more powerful model of computation realizable in practice, in which case she should receive a Turing Award.)

"Entanglement" is an opaque term from postmodern social theory (I'm not really sure about its exact sense) which has absolutely nothing to do with programming. The author conflates social structures with data structures (basically, a data structure is a way of organizing data in memory and a set of algorithms that perform specific operations on this data) and conflates social values with values of expressions (the value of the mathematical expression 2 + 3 * 4 has nothing to do with the social value of freedom of speech).

Ternary machines are just a different computer architecture. With a suitable compiler, you could compile most existing code for a ternary machine and it would work without modifications. There is absolutely no benefit in non-normativeness for the sake of being non-normative.

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.

The Sapir-Whorf hypothesis applies to natural languages, not to formal languages.

The fact that programming languages constrain the way we can understand and solve a problem is actually a good thing. They were designed to do that. Ari seems unaware that the central problems of programming language design are expressive power, understandability and maintainability. It is very hard to design a language which is both restrictive enough that code written by one programmer can be easily understood by another and generic enough to be highly expressive (i.e. so that it can describe complex functionality in a small amount of code).

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.

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.

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.

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.

Thought this might be relevant 

http://en.wikipedia.org/wiki/Non-English-based_programming_languages

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.

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:

Logic

"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!

L.

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.

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

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???