(Most of my serious writing about Lojban is on the main site. This essay is not on the main site because I’m basically attacking one of the founding principles of the language, so it seemed inappropriate.)
This essay argues that Lojban is, and should be, a language defined by a central authority (presumably the BPFK), with the power to change the language as it sees fit, to produce authoritative texts about the language, and to declare particular usages of the language (past or present) as correct or not. Further, we (the Lojban community as a whole) should adopt a set of goals for the language (we don’t currently have those at all, just a set of design decisions from back in the day, which isn’t the same thing), with “respecting how people happened to use the language” and “making sure the meaning of past usage doesn’t change” being much lower on the goal list than they are now, and get on with actually fixing the language based on those goals.
In other words: Lojban is great, but it’s not awesome enough. We need to stop letting the past hold us back absolutely and get on with making it awesome. Letting the past stop us from being jerks to the current speakers is fine, but anything more than that is a mistake, and it needs to end.
Some personal and historical context is required for this essay to make much sense. First, the personal context. I have participated in the Lojban project for more than 10 years now, and I am a major contributor, both in terms of “fun” things (writing, jbonunsla, IRC) and the jobs everybody hates (book-keeping, BPFK). Since I’m about to propose what amounts to nearly a slap in the face to the old guard, I wish to first establish that by most standards I am among the old guard, and at this point there are maybe 5 people who have contributed more over their lifetimes to Lojban than me.
Now the historical context of this essay. It is currently February 2010. The new baseline statement and the BPFK have done incalculable damage to the project, of which more later. The new baseline statement came out in 2002, and we’re still not done baselining, and at the current rate we never will be.
Some history of Lojban is also needed here. Lojban grew out of a conflict with James Cooke Brown in which, as I understand it (this is before my time), he asserted that he owned everything written in Loglan. This, perfectly reasonably, led to the creators of Lojban making the language as open as possible, including the concept of the baseline. The baseline is the mythical future point where those involved in the language decide that the language is good enough, and that in future the language definition will be descriptive rather than proscriptive. That is, instead of defining the language, we’ll simply let people use it and see what happens. This stance has a slogan, “Let Usage Decide!”, and has been part of Lojban since the Loglan schism. It was one of the founding principles of the language.
The baseline was considered to have started a long while back (1997, see http://www.wiw.org/~jkominek/lojban/9703/msg00012.html). Some years ago/later (~2002), people realized that we hadn’t actually done the things the baseline required, like make a dictionary, so it didn’t count. This lead to the new baseline statement mentioned above and the formation of the BPFK to solve the problem (i.e., “finish” the language).
Since the new baseline statement, everything has kind of gone to hell. The BPFK has only done one significant thing (xorlo), and that alienated at least one serious, long-term Lojbanist. Almost everyone who has gotten seriously involved in BPFK work has lost some or all of their interest in Lojban. Every person who has tried to run the BPFK except me has completely left the Lojban project, and I myself spent at least a year almost totally ignoring the language. I personally mourn the loss of Jay Kominek and Nick Nicholas, but they’re far from the only ones.
On top of that, everything feels like it’s on hold. People (especially me, perhaps) are often talking about not working on projects until the BPFK is finished. Newbies are routinely told that we can’t tell them how the language works until the BPFK is done. Which would be fine if anyone was working on it, but no-one is.
Here’s what I think leads to the BPFK being such a black hole of people:
- It will accept as much time and effort as you give it, which is scary and daunting
- Similarly, how do you know when the BPFK is done? The goal is basically perfection: to define every relevant part of the language well enough to call it done, all at once, forever. Again, scary and daunting.
- What happens if you get it wrong? People are going to be stuck with it forever (usage decides after all). Scary and daunting.
- So, people stop working on it. But everyone involved knows that this is the most important thing in Lojban, so not working on leads to guilt.
- If thinking about Lojban makes you feel guilty, scared and overwhelmed, you’re going to stop thinking about it.
As I said, I basically spent about a year not thinking about it because of this, and we’ve lost a lot of great people to it too. I can’t say for sure that it’s all the BPFK, but with so many people that were heavily involved before the BPFK started now gone, it seems like a smoking gun to me.
What we’re doing isn’t working, at all.
I’m tired of having to talk to earnest, smart (but not in the geeky way of people who like to tinker with the language) people like Matt Arnold and having to say “actually, that part of the language is in flux, and has been for ... 5 years?” or “we don’t know what that means yet”. It makes me really sad.
As I see it, we have two options:
- Throw out the BPFK, and let usage decide from where we stand today
- Throw out the idea of usage deciding, and re-tool the BPFK to not have these problems
This essay is one big argument for option number two. Option one will not be discussed further except to argue against it. I contend that it is not possible to make the BPFK work if we’re going to worry about usage, and even if it is, we shouldn’t try.
Note that if you haven’t been dealing with the BPFK directly, you might be wondering what I’m talking about. “Let usage decide” almost never comes up outside of formal discussions of the nature of Lojban.
In linguistics (and other fields, I’m sure), a distinction is made between being prescriptive (telling people what to do; a style guide or the CLL) and descriptive (recording what people actually do; a natural language dictionary). The goal of the “let usage decide” policy is to move Lojban from a prescriptive/authoritative language to a descriptive one.
The problem is, it’s not going to work.
People are basically lazy if given the chance, and in the case of Lojban, they’ve already decided to spend time on something with very little tangible benefits; expecting them to seek shortcuts to reduce the amount of time Lojban takes for them is only reasonable. Then we hand them the most thoroughly and precisely specified language of all time. Naturally, they expect there to be an answer to just about every question they have about the language (and I agree!). How are we to then turn around and say, “Oh, but the very obscurest, hardest bits of the language? Yeah, you get to figure those out yourself. Oh, but no-one can actually add them to the specification, even though that’s how the entire rest of the specification was written. You just have to use things the way you want and hope it catches on. Have fun!”.
We’re basically demanding that every newbie have a gigantic level of dedication just to use the language effectively. We might as well put up a sign that says “Warning: hard work within”.
The other big issue is that newbies are looking for a logical language. I know I was. Part of what “logical” means is “rigorous and well specified”. GÃ¶del aside, something can’t be logical if it has holes, and it certainly can’t be logical if it’s subject to ordinary linguistic drift. I don’t want usage to decide, and I don’t think any newbie looking for a logical language does either.
Even if they think they do.
OK, probably not “no-one”, but in practice, and in decision making situations where it counts, I’ve yet to see a non-trivial portion of the community show any signs of actually wanting to let usage decide.
The behaviour of newbies is telling in this regard: they spend basically all their time asking how to say things, and then asking for documentation pointers to back up whatever the oldbies say (and why not? with a language so well specified, it must be out there somewhere, right?). During the whole xorlo process, to this day, almost no newbies ask about the relative merits of the two systems, nor do they want to make their own decision on which to support. They want to be told how the language works, and anything else leads to annoyance, upset, or derision. I don’t like to think about how many newbies we might have lost that way.
If we let usage decide, if no-one can ever legitimately tell another Lojbanist that they’re doing it wrong, we will end up with some very confused newbies; expecting guidance, but either not getting it (because their usage is as legitimate as anyone else’s) or getting contradictory advice from different people.
The formation of the BPFK itself is another example: when the community realized that the baseline was invalid, and that the language needed some polishing, what happened? Did people simply start changing the way they used the language? Did they let usage decide? No. Overwhelmingly the community voted/agreed to form a body (the BPFK) from which to officiate the language. I only recall one or two people even seriously suggesting letting usage decide.
When we developed xorlo, we suggested that people use it if they wanted, as it would probably be official when the BPFK was done. This caused huge communication difficulties on IRC, because every conversation had to start with “are you using xorlo?”, even though it almost never matters. People didn’t want to just talk and see how it went, as letting usage decide would require; they wanted a statement of position from everyone else in the conversation. As if that wasn’t clear enough of a desire for an authoritative language description, the community’s eventual response to this problem as the BPFK dragged on was to essentially beg the LLG to declare xorlo part of the language early.
The community very clearly wants Lojban to be defined centrally and decisively.
As I mentioned earlier, the idea of usage deciding doesn’t really come up outside of formal discissions of the nature of Lojban. Which is kind of the opposite of how respecting usage should work: if people really wanted usage to decide, you’d expect “Oh, look at that new and interesting usage!” to be common, rather than people getting attacked for not conforming to the CLL, which is what actually happens.
To be fair, this is consistent with a stance of pure conservativism. I disagree that such a stance serves the community, and I suppose we’ll find out if I’m right based on the community’s reaction to this essay.
This is probably a statement of my age (34, much younger than the founders), but “Let Usage Decide!” sounds like something the free software movement would come up with. In both cases, they were decent, good-hearted responses to people trying to exert unreasonable control over the creative output of large groups of people.
What we’ve learned from the free software movement, though, is that groups that all equally contribute to a great project almost never actually happens: you get a very small number of people (usually one) with near-total executive power, or you get crap, or you get a dead project.
While I’m not actually saying that a tiny number of people should take over and control Lojban de jure, believe me that I’m tempted, since that’s what seems to work best, and if my proposals are accepted, it will almost certainly happen de facto anyways.
The other thing we’ve learned from the free software community is that it is possible to have strong authority without screwing the community. I’ve never heard anyone accuse Linus of despotism, for example (although, humans being what they are, I’m sure someone has). Projects like Linux and Perl make it clear, though, that it is possible to give control over major, hard decisions (like breaking backwards compatibility) into the hands of a few people without anything horrible happening. These groups still take lots of input from the larger community. No-one would accuse either of offenses like those that led to Lojban’s formation. All it seems to require is both formal and informal recognition, throughout the community, that while certain people may be directing the process, they don’t own the result. This is an attitude that the Lojban community has in spades; I’m really not worried about despotism here. Nothing I’m proposing will make subverting the system any easier, regardless.
Usage deciding is going to lead to fragmentation. I find it obvious that the Lojban community doesn’t want that (each word having a single meaning is fundamental to the language), so I’ll just talk about why I think it’s inevitable.
If you look at things like xorlo, what happens is that without a single official interpretation, only confusion results.
The idea behind usage deciding seems to be that people will be able to figure this out as they talk, and settle on one or the other. In practice, though, how could you do that? Imagine the confusion that could result when speaking English if someone didn’t think that “the car” implied that there was actually a particular car. You’d be having totally different conversations, but how would you ever figure out where the problem lay?
Once you figured it out, what would you do? You’d grab a dictionary and show the other person to be wrong. Formal officiation is part of how natural languages resolve these sorts of things. The other way is body language and tone of voice (which is how slang drift occurs successfully), which is something that Lojban cannot, and must not, use. If we solve things that way, I’m out; I know where to find English already.
With disagreement on the meaning of actual content words, context can reveal the problem, but with cmavo (which are where all such issues in Lojban have occurred), there’s really no way to figure out what the other person is saying without meta-discussion. This lead to a bunch of conversations that started with “Are you using xorlo?”. If we ever let usage decide, you can expect much more of that sort of crap, as people divide into camps behind their favorite proposals.
The vast majority of Lojbanists have no one else to speak the language with, unless they make use of IRC or similar options. The formal definition of the language must be complete for their sake: otherwise you end up with many tiny islands of unique interpretations, and the continent of IRC users that hopefully are actually all speaking the same language (but probably not; that’s certainly not what happened with xorlo).
If we let usage decide, if no-one can ever legitimately tell another Lojbanist that they’re doing it wrong, we will end up with not just one or two languages, but dozens.
This is the option that really scares me: that natural language constructs will be imported into Lojban that will turn it into something I don’t want to be associated with. If people start saying “le prenu klama” for “the person goes”, a standard newbie mistake, and it becomes popular, will we have to respect that as valid, simply because there is usage behind it, even though it destroys the language (it would not longer be formally parseable)?
If the answer is “no”, then you’ve already accepted the central tenet of this essay: that Lojban is centrally deifned by its very nature. It’s just a matter of how far you’re willing to take it. As the joke goes, we’ve established what kind of person you are, we’re just haggling over the price.
This really is something to be feared, because the average person, including the average wanna-be Lojbanist, defaults to produing non-machine-parseble utterances (hang out on IRC for some weeks if you don’t believe me).
If the history of Lojban teaches us anything, it’s that people don’t need our permission to use the language as they please. They’ll do it regardless if they wish to, and no-one is proposing to stop them. Usage can still decide in practice without that being a formal policy, and as long as it makes sense and doesn’t break the language, a formalizing body might as well make it official, too. Hell, look at cniglic or lokadin’s “caps and no spaces” version of Lojban. Basically everyone else hates that sort of thing, but people do it any way, and no-one has suggested actively preventing them (besides social censure, anyways). We don’t need a “usage wins” rule, because at the end of the day, it does anyway. The language is only defined by its usage. But putting usage on a pedestal above the official language definition just isn’t appropriate for the Lojban that I came here for. If I want natural, growing, living languages, I know where to find them.
It seems to me that one of the main problems with Lojban, and the BPFK especially, has been a lack of goals. There have been lots of goals about the language (finish the dictionary, make a game in Lojban, etc, etc), but no goals for the language (“make it as consistent as possible”).
This goes hand in hand with letting usage decide: since everyone’s usage is valid, it doesn’t really make sense to set goals.
At one time, the language was open and fluid; at that time there must have been goals, even if they existed only in JCB’s head. Certainly large-scale changes were enacted by the Lojban founders at various times. But after the baseline, the only way to make such changes will be to make your own fragment of the language, and hope it catches on.
If someone finds a better way to do something (if we knew what “better” was; since we don’t have goals for the language we don’t, really) why penalize them for being late to the party? Why say “No, you would have had to be here 30 years ago, sorry”? It completely disenfranchises participants based solely on the time of their birth.
I know that the actual issue here is to avoid having to re-learn the language all the time, but that’s a straw man: people deal with drift in natural languages all the time. All we need to do is make sure Lojban doesn’t drift noticeably faster. This is hardly a tall order, and I outline my ideas below. As an aside, while I’ve seen people complain about all aspects of xorlo, I haven’t yet seen anyone complain that it was too much to learn or that the language was changing too much for them to want to learn it. Complaints of that type have always been about the lack of a single, absolute definition of the language to learn from, i.e. about fragmentation.
Being willfully authoritarian solves all these problems, and once we’ve agreed on goals, we can pursue them, and make Lojban more of what we love.
The case of .ai nai really exemplifies the need for goals for the language itself. It has been noted that “.ai nai broda” is exactly equal to “.ai na broda”, as .ai nai is currently defined, and that this is the only UI cmavo that works that way. This lack of consistency (essentially, an exception in our beautiful, supposed-to-be-exception-free language) really bothers some people, and they think it needs to be fixed. Others think past usage is more important. And... that’s where we’ve been for at least a year now. With no criteria to weigh the options by except “finish defining the language”, who is to say who is right?
We can’t go on like this.
(Please do not take this as any kind of formal proposal! The goal was as much to stir the pot as anything else; I am fluid on almost all of the details herein.)
By comparison to the justifications above, my proposal is simplicity itself:
- Clearly state to the community, on behalf of both the LLG and the BPFK, that the LLG exists only to deal with monetary matters, and the BPFK is for language definition issues. The BPFK should be open to anyone who is seriously working on learning the language (and, in fact, the BPFK should be in Lojban as much as possible: this is for formal decisions about the future of the language, by people who actually use it)
- Clearly state to the community, on behalf of both the LLG and the BPFK, that the job of the BPFK is to formalize Lojban in perfect detail, with the understanding that this is to occur in response to the language uses and its users, and thus will never actually be finished. This formalization should be directed by following an ordered set of goals for the language. The goals themselves are certainly up for grabs, but here’s my list:
- Lojban should be as logical as possible; by this I mean something like “internally consistent”, “without exceptions” and “building meaning from small, interlocking, orthogonal and well-defined parts”
- Lojban should be usable by humans to communicate as effectively as with other, natural languages
- Lojban should be unlike other languages
- Lojban should remain backwards compatible
- This is an ordered list for tie-breaking purposes; it is not intended to allow trashing the entire language (#4) to solve some tiny logic issue (#1). If a point of logic conflicts with an approximately equally important point of relearning, the point of logic should win (were these goals to be adopted as-is)
- For myself, I’m not sure about the order of #2 and #3
- The BPFK then finishes the dictionary, to whatever level of specificity can be acheived fairly quickly, which I expect to go relatively smoothly because of the goals themselves, and the lack of needing to worry about past usage very much.
- Voting is as needed, as things feel finished
- Voting is 80% of those voting, 90% of those voting for changes to these rules themselves.
- Every once in a while, a vote should occur to place a list of changes officially into the language. This means documentation must be complete (see below), and there shouldn’t be any feeling of all-or-nothing about it. We can make some things official while other things are not completely finished, and we can make mistakes and fix them in a later round (hopefully not many and no big ones).
- The BPFK is also responsible for evaluating conformance to particular versions of Lojban, as requested. The details of these certifications to be worked out later (but they must be worked out in a timely fashion when someone actually requests such an evaluation). It is understood that the BPFK is a volunteer organization with limited resources, and hence long texts may take an arbitrary length of time to be evaluated.
- It is also the duty of the BPFK to answer questions about Lojban posed to it that cannot be answered via the extant documentation, and to record the answers publicly, and possibly roll the answers back into the official documentation.
- As something of an aside, the BPFK does not rule on truth values. “Does “le cribe cu vinji” mean something like “the bear is an airplane”?” is a fine question, but “Is “le cribe cu vinji” true (or, equivalently, Does “le cribe cu vinji” make any sense?”) is outside the scope of the BPFK; perhaps the sentence came from a dream journal, for example. How this applies to the veridicality of references to unicorns is up to the BPFK to decide should it come up.
This is just some ideas I had for how to handle some of the complexities that I think might come up with the changed BPFK. They’re just first ideas off the top of my head; I do not suggest that they are the best ideas, or even good ideas, for handling these issues.
It is most definitely the BPFK’s responsibility to make sure that “The Complete Lojban Language”, “What Is Lojban?”, jbovlaste, and anything else official is updated as part of any actual update to the language. This means a full description of the changes, and updated versions of all documentation.
This means having good, diffable soft copies of everything, which we don’t yet have, but if this proposal is accepted I’ll handle that part personally.
With the language being both formalized and a moving target, we need some way for people to make sure they’re speaking the same language without a huge meta-linguistic discussion before every conversation. Regardless of whether the rest of the proposal is accepted, we do need this.
I propose a cmavo for language version, that takes a single number for the version; just a simple incrementing whole number. I suggest 1 for Loglan, 2 for pre-rafsi reallocation Lojban, 3 for pre-xorlo Lojban, 4 for current Lojban.
This bit is extra iffy; just me thinking out loud. Also, I’m not suggesting repurposing the experimental cmavo space here, just using bits of it, briefly, for slightly more official purposes than usual (but still experiments).
Something that certain software projects do that we should take on if this proposal is accepted is having fixed, formal times required for the process of breaking backwards compatibility. My proposal in this regard is this:
- Whem a proposal is agreed on, a new word (normally a cmavo) in the experimental range is coined, if appropriate, and used with the new meaning for a year.
- If no problems are found, the two words are swapped, the language version is incremented, and that continues for another year.
- If no problems are found, the experimental word that was used is marked meaningless, to remain that way for at least a year (although, of course, people can do whatever they want in the experimental range, but very much at the risk of confusion if you ignore the BPFK’s experimental usage), and the version is incremented again.
Lojban is, and always will be, a centrally defined, ridgidly formalized language; this is a fundamental part of its nature, and if we act against that we’ll lose the language we love. We need to stop resisting that, and embrace it for the good of the language. We need to move on from our current stagnant state. Lojban is a good language; we can make it great, if we stop being so timid about it.