meta data for this page
  •  

This is an old revision of the document!


On Nothingburger projects

Where's the Beef? (Classic Wendy's Commercial)

At some point in mid-2008, I set myself the task of figuring out what the JavaCC “community” had achieved, what work they had done on the code in the five years since it had been open-sourced on java.net.

Practically everybody uses Git nowadays but back then the standard thing was CVS, which was what Java.net used. CVS may be more crufty and capricious than Git, but if it is a question of just getting an overview of the history of a codebase, CVS serves perfectly well for that purpose.

Now, if I were a more masterful storyteller, I would find some way of building the suspense, to keep you waiting with bated breath. But I guess I'll just get straight to the point. Here is the summary conclusion of my code review of the time:

To all intents and purposes, no work had been done in those five years. Nothing.

Now, to be clear, that is not to say that there was no commit record. However, none of it related to the real core, the guts of the codebase.

Well, what I am describing is actually a general phenomenon, and I had encountered it before. Still, at the time, I did not have any terminology to describe it, and if there is a generally accepted term out there, I am not aware of it. Here is what I propose:

Nothing-burger-ism

I realize also that nothing-burger-ism is actually a quite major phenomenon (not at all exclusive to open source software development) and the sociology and psychology of nothing-burger-ism is well worth reflecting on. For example, there are major institutions in the open source panorama which are hard to come to some understanding of without grappling with the Nothingburger concept. In particular, Apache Software Foundation, which could perfectly well be called the Home of the Nothingburger.

So, using this new terminology, what I describe above is my realization that JavaCC was (and really still is) a Nothingburger project. Not the only one out there by any means, but very much a classic example. I'm sure that many people reading this are nodding their heads because they also have encountered these nothingburgers but maybe (like myself at the time) did not have a term for it.

Here are some telltale signs of a nothing-burger-ism.

  1. The project's core code has become a kind of no-go zone. What this means is that, if you look at the project's commit record (typically via git log nowadays) whatever activity you see there (assuming there is any, but usually there is something or other to look at…) revolves around ancillary things like the build system, maybe updating from Ant to Maven to Gradle… Maybe reorganizing the website… Maybe they correct a spelling mistake in a README file or something…
  2. If you are naive (or masochistic) enough to try to engage the nothingburger artists in a conversation, you'll find that huge, exaggerated importance is placed on backward compatibility and stability. In fact, these things are elevated to a quasi-religious status.
  3. When very minor changes to the code are made, patches that, by the principles of Semantic Versioning, would only justify a minor point-point release, like 0.7.1 to 0.7.2, they are represented as significant new development. One corollary of this (though this symptom may or may not be present) is that a nothingburger project frequently sports an excessively high version number.

One could surely list other important symptoms of nothing-burger-ism, but they kind of blend in and interact with one another. I think the above points I outline are key. Perhaps the first point, this kind of bizarre reverence for the existing codebase is the most reliable sign that a project has devolved into nothing-burger-ism. It is also the characteristic that I myself find the most unsettling, maybe even downright spooky.

I suppose the most typical pattern by which a software project becomes a nothingburger is that the original author loses interest, drifts away, and none of the people remaining, now the ostensible maintainers, really understand how the code works. So, if people lack the wherewithal to do fundamental work on the core code, then what do they do to justify their continued desired status?

To be clear, a nothingburger project is not the same as abandonware. Sourceforge and Github are full of orphan projects. However, nobody is trying to hide the state they are in or present them as active. The implicit metaphor in the nothingburger terminology implies some attempt at deceit. The art of the nothingburger is to present a bun with maybe some lettuce and tomato, a bit of ketchup or mayo, and somehow arrange a trompe l'oeil to trick people into thinking that there must be some meat in there. (Some real software development in this case.) But any close inspection reveals that there is no meat in the bun. The other key difference between a nothingburger project and simple abandonware is that the ostensible owners of the nothingburger project will do their level best to prevent anybody from coming in and doing anything. My best best is that in the vast majority of cases, if you approached the owner of some abandonware project on Sourceforge and told him that you would like to pick up the project where he left off and do some work, he would be happy to let you in and have a go at it.

It occurred to me recently that there is a science fiction genre that may best characterize this nothingburger state of affairs. In a post-apocalyptic, post-industrial future world, human society has mostly devolved to its pre-technological state. However, the landscape is still littered with vestiges of the long-gone industrial civilization. Now, a few old machines are in reasonable state and still work. However, no current-day humans understand how they work, much less possess the ability to build such machines. While human society has lost the all that knowledge, a few people have figured out how to tinker with these machines and keep them working. Somewhat… What happens now is that these people form a kind of priesthood that wraps their minimal knowledge in a kind of religious mumbo-jumbo.

Now, in this scenario, suppose somebody shows up (from the past somehow?) who really has the technical know-how to take these machines apart, fix whatever problem, and put them back together. How is this priesthood going to react? I think it is obvious. They are going to obstruct this person's attempt to do anything because it is a challenge to their legitimacy. The situation in these nothingburger projects is kind of analogous finally, no?

(I was trying to recall which science fiction classics have this sort of underlying theme. I vaguely recall one iteration of Planet of the Apes maybe… If somebody would write me and let me know, I would be grateful.)

Now, the second point, this excessive reverence for “stability” and “backward compatibility” is also quite symptomatic of all this. Well, really, properly understood, it is a rather transparent rhetorical trick. After all, you always have perfect stability and backward compatibility by simply doing nothing! So can this ever be considered any sort of great technical achievement? If the competition is over who can be more “stable”, the abandonware will win every time!

So, this is all a sort of sucker's game. Frankly, I have no more intention of competing with any of these people on stability than I do of entering a tanning contest with an African to see who can sit in the sun and get blacker! (Unless the African in question is a Boer from South Africa, in which case, I might consider it!) Regardless, the willingness to enter into a rigged competition in which you will always lose is probably about the dictionary definition of a sucker, so taking this rhetoric about stability very seriously is effectively just a sucker's game.

As for my final point above, that the extreme overvaluation of minor patches will lead to the nothingburger project having an absurdly high version number, this is a frequent symptom, but not really a sine qua non either. However, we do observe it in the legacy JavaCC project, which is apparently gearing up for an 8.0 release. The fact of the matter is that, in its 17 years of open source history, that project has not had a level of forward evolution that would correspond to a single point release (0.8 to 0.9 say) by the approximate rules of Semantic Versioning outlined here.

I shall close this segment on Nothingburgerism here. I shall continue the discussion with some analysis of the causes and treatment of the problem.