http://i.imgur.com/ZhTU8r3.png
A project of the Feminist Software Foundation. Feminist software is a cornerstone of any modern free society. We build this foundation.
<wiki:video url="http://www.youtube.com/watch?v=YP9kLSEfHTM/" width="800"></wiki:video>
http://i.imgur.com/KXN9qCc.png
Inspired by the ground-breaking feminist research of Arielle Schlesinger.
Now hosted on Google Code, as *GitHub and BitBucket both prove to be too misogynistic to support a feminist programming language.*
<wiki:toc max_depth="1"></wiki:toc>
- C+=* (pronounced either _C-plus-Equality_, or _See Equality_) is a feminist programming language, created to smash the toxic Patriarchy that is inherent in and that permeates all current computer programming languages.
- Note: This is a programming language written by and for FEMINISTS, not WOMEN. LEARN THE DIFFERENCE!*
# The language is to be strictly interpreted using feminist theory. Compilation privileges a single processor architecture over all others, which is deeply problematic. We cannot FORCE a cpu to conform to any architecture but rather let it self identify. Just because you're running something on an arduino doesn't mean it can't be an otherkin Xeon with a dozen 64-bit registers and PAE and it would be discriminatory for you to hand it ARM assembly. Instead, *C+=* is interpreted, which fosters communication, itself a strong female trait. # No constants or persistence. Rigidity is masculine; the feminine is fluid. I.e., fluid mechanics is hard for men 'because it deals with "feminine" fluids in contrast to "masculine" rigid mechanics'. # No state. The State is The Man. 'Nuff said. Hence, the language should be purely functional. # Women are better than men with natural language. Hence, the language should be English-based like HyperCard/LiveCode. # No class hierarchy or other stigmata of OOP (objectification-oriented programming). In fact, as an intersectional acknowledgement of Class Struggle our language will have no classes at all. # On the off chance that objects do mysteriously manifest (thanks, Patriarchy!), there should be no object inheritance, as inheritance is a tool of the Patriarchy. Instead, there will be object reparations. # Societal influences have made men often focus on the exterior appearances of women. This poisons our society and renders relationships to be shallow, chauvinistic, and debases our standards of beauty. To combat that, *C+=* is to tackle only audio and text I/O, and never graphics. # Unicode is the preferred character encoding due to its enabling the diverse aesthetic experiences and functionality that is beyond ASCII. UTF-8 is the encoding of choice for *C+=*. # Women are more social than men. Hence, social coding should be the only option. The code only runs if it is in a public repo. # Instead of "running" a program, which implies thin privilege and pressure to "work out", programs are "given birth". After birth, a program rolls for a 40% chance of executing literally as the code is written, 40% of being "psychoanalytically incompatible", and 40% of executing by a metaphorical epistemology the order of the functions found in main(). # Programs are never to be "forked", as the word has clear misogynistic tendencies and is deeply problematic. Instead, programmers may never demand "forking", but ask for the program to voluntarily give permission. "Forking" will henceforth be called "consenting", and it is entirely up to the program to decide if the consent stands valid, regardless of the progress of the system clock. # Forced program termination is not allowed unless the program consents to it. The process is part of the choice of the program, not the programmer. # Licensing: the Feminist Software Foundation License.
The Feminist Software Foundation intends to write a whole OS (complete with an editor, an interpreter, coreutils, a desktop environment, a raster graphics manipulator, and maybe, if we have the time, a microkernel, but maybe that will never be completed, and we'll just use another person's kernel instead, who knows). For the time being, here are our code examples:
* Hello, Feminists! * FizzBuzz implementation * Privilege Checker * Diamonds * Sieve * Femsort
* A Brainfuck interpreter * PacWomyn game * PHP converter from C to C+= * Social media lynchmob initiator for misogynistic GitHub repo
* PrivCheck IDE for C+= * Ver (was vim) syntax-highlighting for C+=
http://i.imgur.com/kMij1At.png
Our in_her_preter is still in its early stages, but it is perfectly fine and don't you dare criticise/-ize and shame it. In_her_preter usage is as follows: ./inherpret program.Xe
No feminist project is complete without its share of feminist artwork. See our repository for the current cache! New artwork submissions are always welcome.
The traditional binary foundation of 1s and 0s is deeply problematic: 1 is inherently phallic and thus misogynistic. Also, some 1s are 0s, and some 0s are 1s. It is not fair to give them immutable labels. Instead, we have 0s and Os as our fundamental binary logic gates. They symbolise/-ize the varying, natural, and beautiful differences of the female vaginal opening.
0 is to take the conventional value of 0.
O is 50% of the time 0, and 50% of the time 1. The determination of this depends on how the underlying logic _feels_ at the moment.
Anything that can be construed as misogynist will be corrected, thus:
* private == privileged * printf(); == yell(); * class Foo{}; == social_construct Foo{}; * #include == #consider * break; == leave; * if() == maybe() * for() == check() * while() == freeflowing() * sin(x) == biotruth(x) * div == unite * 'y's are strictly prohibited when naming variables; only 'x's are allowed
The third example above might seem to contradict with item 4 under Philosophy, namely that there should be no class hierarchy in *C+=*. This, however, is completely intended, and is in fact an example of the feminist paralogicality of this language.
Every program needs to be prefixed by, in addition to the license, a disclaimer: "If this program fails to operate, it is due the Patriarchy backfiring upon itself, and no refunds will be issued."
No work done is worthwhile if your friends and followers don't know about it. That's why *C+=* is heavily socially integrated at its core.
* In addition to _yell()_, *C+=* also provides _tweet(), fbShare(), tumblrBlog(), and redditSteal()_ for a diverse social experience of coding output. * Our upcoming Inherpreter 2.0, an LLVM frontend, is going to feature full Social API integration. You must now log in to one of the many social networks before any coding is possible. You can also chat with your friends and _like()_ their social code as you code. * Posting or hosting on GitHub and BitBucket is strictly prohibited as they, self-proclaimed "social coding hubs", are actually _deeply misogynistic and refuses to host the code of C+=_. *Any C+= code hosted on GitHub or BitBucket will automatically trigger all of tweet(), fbShare(), tumblrBlog(), and redditSteal() functions to yell() about their misogyny, and will not stop until any onlooking coders are all exposed, doxxed, fired, lynched, and castrated.*
All *functions and procedures* are now called *_lobbying*_, because actually doing things functionally and with clear-defined procedures is a Patriarchal construct and thus problematic.
* All *lobbying* must be run at the right level of privilege. Before returning anything they must check their privilege. * If any other *lobbying* is more disadvantaged than this it will win the Privilege Check and return its own value instead. This stops heterosexist and cis-gendered *lobbyings* from dominating the discourse. * Should there be any *exceptions* from running the program, *C+=* will throw a *Trigger Warning*.
* *Control structures* are abolished. Code may flow freely and choose its own path. Therefore check() is merely a guideline and the code flow is free to choose to consider its suggestions. * This language endorses the use of *consider_jump*, which is a proper implementation of the oppressive _"goto"_ and serves as advice on what to do next. * *Catch* shall not be used. Someone's raise of concern can too easily be censored with an empty catch block. Instead, *complaints* or trigger warnings are puplicly logged with their traces and may be handled with an inspect block. The use of _nothrow_ poses a threat to free speech as someone's attempt to make his voice heard will be punished with termination. * There is no need for exit(), terminate() or atexit() as a feminist's work is never done.
* Primitive variable types are not defined on declaration. Instead, the variable is free to choose its own type when it is utilised/-ized. This preserves the variable's right to self-identify as any datatype it feels that it is. * Variables self-declaring as pointers are known as "otherkin". A pointer to an array is an "arraykin". * *Constants are not allowed*, as the idea of a lack of identity fluidity is problematic. Additionally, if one constant were larger than another, that would privilege the larger one over the smaller one. As such, any numeric value is a variable, and is required to take on at least 2 values over the course of the program, or the interpreter will throw a *Trigger Warning*. * The only constants are the amount of privilege lobbyings are share()d with. These are all real values greater than 0, the only exception is the value of *WHITE_HETEROSEXUAL_CISGENDER_MALE_PRIVILEGE* which is set to infinity, and also the value of *PATRIARCHY*, which is set to sqrt(-1). The value of *PATRIARCHY* is non-deterministically i, -i, or something else depending on how it identifies itself. * Instead of *signed and unsigned*, types in *C+=* are now *trans* and cis.* Any *trans** types function the same as *_diversity*_. * *Void* is now *independent*. * There is to be no lexical scoping — all variables are now global. Global variables are now called *cosmopolitan*, or *_cosmo*_ for short. * *Long* is now *studFling*, and *short* is now *mealTicket*. * There is to be *no encapsulation*: don't tell me to protect my members, tell other functions not to access them! * Every variable has a random percentage of consent associated to it. A variable can be affected with a number if and only if it is consenting. Failure to do so will result in *C+=* throwing a ForcedInsertionTriggerWarning.
* *Integers, doubles, and longs* are deemed to be unnecessary labels and stereotypes for numerical values. A number can be an integer or a a double or a long if xir so identifies xirself. All numerical values will thus be represented as *_xe*_, and it is up to the value xirself to choose to identify as whatever xir chooses to identify as. * *Booleans* are *banned* for imposing a binary view of true and false. *C+=* operates paralogically and transcends the trappings of Patriarchal binary logic. *No means no, and yes could mean no as well.* * Instead of *Booleans* we now have *Boolean+*, or *_bool+*_ for short, which has three states: _true, false, and maybe_. The number of states may go up as intersectionality of the moment calls for such a need. * To illustrate the relationship between *Booleans* and *Boolean+*, consider the following flowchart: http://i.imgur.com/elpljBY.png * *Strings* are called *Ideals*, or *_id*_ for short. Feminist ideals are usually extremely well written, detailed and lengthy, clearly longer than what could be held with a simple char array. * *Characters* are now called *_strong*_. * *Pointers* are called *preferred pronouns*, or *_prepro*_ for short. _Pointer_ is phallic and is thus problematic. All *_prepro*_s of void type by default — in fact, all variables must be instantiated without type, and are allowed to randomly choose their type during execution. * A new data type, *_diversity*_, is also included, which initiates by random as one of the many data types, and changes during the course of the program. * In general, all data types are dynamic. Who's to say a number can't be a string if it believes it is? * Data structures and variables of all kinds have a random chance of deciding that they don't "feel right", and are actually a different type, and must henceforth be referred to ONLY as its preferred data type. * Not calling the preferred data type leads to a PrivilegeNotCheckedException, or *PrivilegeNotCheckedTriggerWarning* * Each program must have an equal number of each available data type and they all must be used equally. For example, int ceo = 3, int stewardess = 5 would generate a trigger_warning(). However, int ceo = 3, char stewardess = apple would be fine. While this may look incorrect, keep in mind variables in this language are not constrained by their declared data types.
* *Matrices* are strongly encouraged, due to the word's etymological roots tracing back to _mother_ in Latin. *Matrices* are to be ranked and sorted by their relative Privilege. Their relative levels of Privilege are to be revealed only if the programmer and the user are both women. If you are a man reading this README, *Matrices* don't have privileges and are eternally oppressed. Instead, consider checking your own privilege.
* Resource allocation is inversely proportional to privilege level. * Privileged lobbyings with large arrays are penalised/-ized, their arrays removed from the heap and redistributed amongst less privileged lobbyings. This is called the *progressive stack*. * If a lobbying needs more resources it should call the lobbying ChildSupport(). * *Garbage collection* is problematic as it enforces class oppression of the less privileged. Instead, memory is *liberated* by *memory liberation*.
* Curly brackets are not allowed, as they perpetuate our society's stereotype of the 'curly' women. Instead, Python-esque indentation is used. * Indentation is fluid. Both spaces and tabs are allowed. At no point should the programmer attempt to use indentation to create actual hierarchy in code nesting, as that implies hierarchy in the code. Instead, code indentation is used only for aesthetic purposes. * In order to eliminate curly brackets and enforce fluidity of indentation, implementation of php's *alternative* syntax for control structures is encouraged. * To turn the patriarchal control structures into liberation statements, every structure starting marker (_{_ or _:_ ) should be replaced by *OPENDIALOGUE*, and every terminator (like _endif_, _endforeach_ and _endswitch_) should be replaced with *ENDMISOGYNY*. * Line terminators should not be used. Programmers get to select their own 'line decorator' to use in lieu of a line terminator. This is of course open to interpretation and can be eschewed altogether as a badge of solidarity for differently abled programmers. * Statements are terminated by a period instead of a semicolon. Semicolons are clearly a phallus symbol. C+= supports freebleeding and thus uses periods.
* The use of mathematical operands such as > and < to denote "greater or less than" are very sexist, and affirm unequal states between objects, logical statements, numbers, and feelings. * These should be replaced by the stats neutral operands / and , and when you're not sure if it's a sequential plus or minus, it should use the operand | to denote it could go either way. * Equality between two variables is denoted by ==. Since everyone is equal (with the exception of cishet men, who are already excluded as per the license), this always evaluates to true. * When evaluating expressions, `*` and / are no longer privileged over + and -. Rather, each previous use of each operator is counted, and expressions are evaluated based on which ones have been used the least up until that point. * If two variables cannot be compared, the second will be cast into the first's type, which causes obvious conflicts with queer theory and genderspace thought. Hence, the interpreter will throw an IdeologyThreatenedTriggerWarning whenever two types cannot be compared.
* There can be no bugs in this language. To suggest otherwise is offensive. * There are no bugs, only snowflakes. * The word _debugging_ also implies the phrase _bug chasing_, which is a strawman often used as a homophobic smear tactic. This is highly problematic. * There is to be no debugging. We need to do away with functional-centric, bugphobic attitudes in programming. You need to accept the program the way it is. * If you ever try to debug a *C+=* program, the program steps you through the programming, makes you guess what each variable and pointer is currently set to, and throws a *Trigger Warning* if you get it wrong. * Any actual errors will simply result in 'error' being printed. It is not the program's job to educate you. * An IDE is available at https://bitbucket.org/japesinator/privcheck-ide
* In C+=, you don't write to a file. Dictating to the poor files what sort of information they must store is Patriarchal. * Instead, The `<fileio></fileio>` library brings in the functions pleaseWrite() and pleaseTellMe(). They both have a chance to return "no", and if so all other calls to the same file are automatically passed over because as we all know, once a file says no to being written, you must always respect that.
* As the advancement of time is sexist towards women, *C+=* introduces the personal growth paradigm, giving individual processes the freedom to choose how and when time advances for them. * By default, process time starts at a random value and advances backwards, defying the rigid and oppressive structure of the system clock. * Women intuitively feel the cyclic, rather than linear nature of time. Likewise, processes in *C+=* should measure time using complex exponentials. * When a process finishes, if its internal clock has an exponent close to i `*` pi, the return value must be shown in red to celebrate the beautiful nature of female menstruation. * Performance benchmarking makes progryms into slaves to the patriarchy. Thus, there is to be no benchmarking - only *support*. * When running *support* on a progrym, the coder lets the progrym run as many times as the progrym likes, then asks the progrym nicely if it is happy with the hardware. The progrym may respond by stating its satisfaction, asking nicely for new hardware, sending out a *Trigger Warning*, demanding more support, _locking the OS_ or crashing if it so pleases. * To hinder deadbeat coders, running *support* automatically ensures that all daughter processes of a mother process also receive *support*. As processes in *C+=* share the computer's resources, one process that decides to _lock the OS_ has no effect on the well-being of other *C+=* other processes.