meta data for this page
  •  

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
nothingburger [2020/04/26 12:39] revuskynothingburger [2020/10/02 01:54] (current) – [Passive Acceptance of Illegitimate Authority] revusky
Line 3: Line 3:
 //Where's the Beef?// (Classic Wendy's Commercial) //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.+As [[ancient_history|I describe here,]] 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. +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: 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:
Line 11: Line 11:
 //To all intents and purposes, **no** work had been done in those five years. **Nothing.**// //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. +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:+What I am describing here 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// //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,[[https://apache.org| Apache Software Foundation]], which could perfectly well be called the //Home of the Nothingburger//.+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,[[https://apache.org|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. +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.
  
-===== Some Telltale Signs of Nothingburger project =====+===== Return to Planet of the Apes? =====
  
-  - 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...+It occurred to me recently that there is a science fiction genre that characterizes quite well 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 all that knowledge, a few people have figured out how to tinker with a few of 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. (One unmistakable symptom of //nothingburgerism// is an obsession with formalisms, doing everything according to the //proper procedure//. This could almost be likened to religious rituals.) 
 + 
 +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'll express shock that the person is not going about things in the proper manner, following the rituals established by the priesthood. The bottom line is that they are going to obstruct this person's attempt to do anything because it is a challenge to their legitimacy. Finally, one cannot help but notice an eerie similarity with the state of affairs in these nothingburger software projects. The most common pattern by which an open source 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? It is not hard to see how the //nothingburger// culture or mentality takes form. 
 + 
 +===== Telltale Signs of the Nothingburger project ===== 
 + 
 +  - 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... 
 +  - The //culture// of a nothingburger project is typically one of extreme fastidiousness, an obsession with the //proper procedure// for doing things -- the approved way of tagging and labeling a release, of opening (and subsequently closing) some "issue".... the proper way of wiping your arse after you take a shit... In short, a mentality where people are much more concerned with the correct procedure for doing things than with actually doing anything!
   - 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.   - 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.
-  - The //culture// of a nothingburger project is typically one of extreme fastidiousness, an obsession with the //proper procedure// for doing things -- the approved way of tagging and labeling a release, of opening (and subsequently) closing some "issue".... the proper of way of wiping your arse after you take a shit... In short, a mentality where people are much more concerned with the correct procedure for doing things than with actually doing anything!  
   - When very minor changes to the code are made, patches that, by the principles of [[https://semver.org|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.   - When very minor changes to the code are made, patches that, by the principles of [[https://semver.org|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. +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, the first three in particular, 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 //nothingburgerism//. It is also the characteristic that I myself find the most unsettling, maybe even downright spooky. 
 + 
 +At this point, let me be clear about one thing: I do not mean to say that one should not have a certain amount of structure and organization in how one goes about things. Rather, I am talking about a situation where this is all taken to such lengths that it creates a quite mentally oppressive environment. Come to think of it, I am sure that, on occasion, this is a factor in the original author(s) losing interest and abandoning the project! Many things in this life are a question of balance, after all. Yes, a reasonable level of hygiene is a good idea, but what we are talking about here is something more akin to [[https://en.wikipedia.org/wiki/Obsessive–compulsive_disorder|obsessive-compulsive disorder]]. People who suffer from OCD may wash their hands hundreds of times a day. They wash their hands and, a minute later, are obssessed with the idea that their hands are dirty, and feel compelled to wash their (quite clean) hands yet again. OCD, by the way, is a genuine mental illness and no laughing matter. By the same token, //nothingburgerism// is a psychosocial malaise, and also no joke. (Even if I do crack a few jokes when describing the situation...) 
 + 
 +Now, 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 bet 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. 
 + 
 +===== How about a Tanning Contest this Summer? ===== 
 + 
 +Now, as for the other point I mention above, this excessive reverence for "stability" and "backward compatibility", on one level, it could be seen as a 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! 
 + 
 +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!//) Generally speaking, 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 the 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 [[https://semver.org/|here]]. 
 + 
 +===== The Army with No Soldiers ===== 
 + 
 +I have no doubt that there are certain people who will jump at any opportunity to twist and misrepresent what I am saying here, so I feel I have to be very very clear about certain things. By no means am I saying here that the //only// thing anybody can do of any value in a software project is write code. In fact, it is frequently the case that the most value that can be added at a given point is by doing things other than coding. For example, most (pretty much all) open source projects are sorely in need of better documentation than what they have. 
 + 
 +However, the real issue here is one of balance. Suppose you were a journalist assigned to write some articles on the military and you are given access to various people to interview and profile. It turns out that all of these people and, in fact, every "soldier" you ever come into contact with has some desk job doing completely sedentary work, typing up reports and such. Also, every last one of these people is of officer rank. Suppose further that when you say you would like to interview some regular soldiers, you are given the runaround and it gradually becomes apparent that there are no regular soldiers to interview. 
 + 
 +//This is an army with all officers and no regular soldiers.// 
 + 
 +Would that not be completely surreal? How much expertise in military affairs would it take for you to realize that there is something very screwy going on? Of course, we could also imagine a situation where the journalist realizes all this but keeps it to himself, since he realizes that honestly reporting on this absurd state of affairs might be career suicide. In this story, one is not claiming that nobody should be doing any office work. A modern army is a very large bureaucratic organization and it is inevitable that there are lots of personnel engaged in accounting and record keeping and such. However, an army in which every last person has a desk job is an utter absurdity regardless. 
 + 
 +===== It must be nice to be a superhero! ===== 
 + 
 +We could shift that military metaphor a bit and get to another point, which is that the stance of people in a //nothingburger// project is entirely //defensive//. As I pointed out earlier, they have this outrageous, exaggerated fear of changing anything, particularly in the core code. As I said before, this led me to think of the future humans in the post-apocalyptic science fiction, who have a completely mysterious, mystical relationship with any of these remaining machines. I like the analogy, but I realized at some point that it actually understates the case. You see, the stance of the "priesthood" in that post-apocalyptic science fiction story is not entirely unreasonable. It actually makes sense to be very hesitant to muck with machinery that you don't understand. I myself have a somewhat similar relationship with most of the appliances in my home, and I would not mess with them. (Though I am happy to have a qualified repairman to fix my washing machine when it needs fixing.) But the thing is: we're talking about physical machines here.... 
 + 
 +//Software, code, is not a **physical** machine.// 
 + 
 +If your code is stored in a code repository such as Git, SVN, or CVS, you can restore it effortlessly to any previous state it was in. I recall on a mailing list hosted by Apache Software Foundation, this whole topic came up. It was about just how conservative the project was in terms of letting people commit code. One of the people there was making some comparison between allowing people to commit code and trusting your fellow mountain climbers. (Apparently, the guy's hobby was rock climbing or something.) 
 + 
 +I pointed out to him that the simile would be more applicable if, when you fell off a cliff at time t, and presumably broke all the bones your body, you had the capability of instantly restoring yourself to the state you were in at t-1 just before the fall. 
 + 
 +//In essence, hacking code is a bit like being a superhero, who cannot really be hurt, like the Wolverine character in X-men.// 
 + 
 +Wolverine can be beaten, stabbed and shot and his body just regenerates in short order to the state it was in before. (I grant that Wolverine still feels pain and it can be painful to have to back out your changes and revert to a previous state of the code, but the point is that Wolverine cannot be //permanently// hurt, since his body always just regenerates to its previous state. Similarly, you can always revert your code to any known working state.) 
 + 
 +So, what is the agenda of somebody who likens mucking with source code to a physically dangerous activity like rock climbing? If you took the analogy with physically dangerous activities seriously -- rock climbing, deep sea diving, etc. -- yes, you would be very cautious about who you would allow to participate in such activities (people need proper training and so forth). Also, you would be right to be extremely fastidious about following all the established safety procedures! If the analogy were correct, the stance of these //nothingburger artists// would actually make some sense! 
 + 
 +//But the analogy with the physically dangerous activity is completely nutso!// 
 + 
 +No matter how irreparably you mess up the code, it can always be restored to the previous state anyway. And even so, it would still not be comparable to falling off a cliff to one's death! In reality, the argument being made implicitly with this analogy is multiple degrees away from making any sense at all! 
 + 
 +This leads us to another frequent symptom of //nothing-burger-ism//: 
 + 
 +//The insiders in a nothingburger project frequently **affect** that they don't understand how version control systems work.// 
 + 
 +The //nothingburger artists// will frequently argue that it is extremely risky to let some "unproven" person (//except how is he supposed to prove himself?//) come in and do anything. Why? They might screw something up. (//This is also the general-purpose argument for never doing anything. It is the absolute guaranteed way to never make a mistake!//) Well, aside from the fact that code stored in a version control system can be restored to any previous known working state, there is also this feature that they all have called //branching//. If somebody shows up and proposes some ideas that you think are dubious, they can be given a separate branch to work on, and have a shot at demonstrating the worth of their ideas. What all of this suggests, by the way, is that the correct policy in running an open source project (at least if you want there to be any progress) is: 
 + 
 +  - An extremely aggressive stance in terms of evolving the code forward, refactoring etcetera. (Because if you do some things that turn out to be a bad idea, nothing is lost anyway!) 
 +  - An extremely liberal, open stance towards letting people contribute. (Because newbie contributors can't really do any damage anyway! Especially, if you give them a branch to work on!) 
 + 
 +Of course, a //nothingburger// project is always run 180º away from the above ideas. 
 + 
 +If you are foolish (or masochistic) enough to be engaging these people in discussion and you point out these things, the typical result is that they simply walk away from the conversation. (//One key anti-nothingburger measure must be that you have a culture in which it is **not acceptable** to simply walk away from a conversation. Either you produce a valid counter-argument, or you concede the point at hand.//) 
 + 
 +===== What is to be done? ===== 
 + 
 +That you can diagnose an illness does not mean that you know how to treat it. If you really thought about //nothingburger-ism// as a sort of illness that afflicts open source software projects, diagnosis seems quite straightforward; the symptomology is quite clear. But, as with any illness, what is more useful and important is how to treat the problem. 
 + 
 +//Even better than treatment would be prevention!// 
 + 
 +Regardless, identifying the problem and having a name for it is a necessary initial step and hopefully, dear reader, we are on the same page on that. In that case, we would at least agree that //Nothingburgerism// is: 
 + 
 +  - Real, i.e. not a figment of Revusky's overactive imagination. 
 +  - A problem. (A big problem!) Thus, there is some value in thinking seriously about how to deal with it. 
 + 
 +Now, let me say here, up front, that I don't actually know what the remedy is when an open source project has reached some advanced state of //nothingburger-ism//. I don't even know whether there is any real answer. 
 + 
 +I recall some anecdote that might (or might not) even be true. A prominent engineering firm in job interviews of recent engineering graduates would ask them the question: //Suppose you drop your car keys into the middle of the ocean? How do you solve this problem?// 
 + 
 +Apparently, the correct answer is: //Don't drop your car keys into the middle of the ocean!// 
 + 
 +It could well be that a similar answer applies to //nothingburger-ism//. What do you do about an open source project that has devolved into a state of nothingburger-ism? Answer: Don't let your project devolve into nothing-burgerism! 
 + 
 +Though admittedly, not as absolutely impossible as retrieving one's car keys from the bottom of the ocean, when a once healthy project has lapsed into //nothingburger-ism//, I believe it is extremely hard for it to get out of that state. Now, if nothingburger-ism was a purely //technical// problem, I suppose it would not be so intractable. However, that is not the case. I'm pretty sure that it is primarily non-technical factors that make the situation so impossible -- things best understood in terms of social psychology and such. One problem is: 
 + 
 +===== Passive Acceptance of Illegitimate Authority =====
  
-NowI 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? +In any Psychology 101 courseone typically learns about the [[https://en.wikipedia.org/wiki/Milgram_experiment|Milgram experiment]] from nearly 60 years ago. This demonstrated just how conditioned people are to obey anybody that they perceive as an "authority figure"Quite literallymany people will electrically shock somebody to death rather than disobey authority//Perceived// authority reallysince the "authority figure" in the Milgram experiment actually has no real authority over the subject.
-  +
-And this actually leads naturally to the second point, the culture of extreme fastidiousnessNow, to be clear, I do not mean to say that one should not have a certain amount of structure and organization in how one goes about thingsRatherI am talking about a situation where this is all taken to such lengths that it creates a quite mentally oppressive environment. Come to think of it, I am sure that, on occasion, this is a factor in the original author(s) losing interest and abandoning the project! This is actually a big topic that I will explore more in a later segment of this Nothingburger series.+
  
-Now, to be clear, //nothingburger// project is not the same as //abandonware//. Sourceforge and Github are full of orphan projects. Howevernobody is trying to hide the state they are in or present them as activeThe 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 casesif 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.+Though shocking in way, the Milgram experiment does reflect my own casual observationNot just in open source software by any meanshave been continually amazed at people's passive acceptance of what is obviously completely illegitimate authority.
  
-It occurred to me recently that there is a science fiction genre that may characterize quite well this nothingburger state of affairs. In a post-apocalypticpost-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 a few of 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. (This relates directly to the second point above about proper procedures and such, that could almost be likened to religious rituals.)+In Hollywood movies there is frequently some pivotal moment in which an authority figure has some sort of breakdown and starts rantingtalking such self-evidently deranged nonsense that he immediately loses all credibility. One example that comes to mind is the Captain Queeg character in the [[https://en.wikipedia.org/wiki/The_Caine_Mutiny_(film)|Caine Mutiny]] portrayed by Humphrey Bogart.
  
-Now, in this scenariosuppose somebody shows up (from the past somehow?) who really has the technical know-how to take these machines apartfix whatever problemand put them back togetherHow is this priesthood going to react? I think it is obviousThey'll express shock that the person is not going about things in the proper mannerfollowing the rituals established by the priesthood. The bottom line is that they are going to obstruct this person's attempt to do anything because it is a challenge to their legitimacyThe situation in these nothingburger projects is kind of analogous finallyno?+But that is Hollywood. I was pondering how frequently such things happen in real life and I came to the conclusion that this mostly just happens in movies. In the real worldit seems to be just about impossible for an authority figure to lose his authority this way. Just for example, I recall the president of the United States of some years backone George W. Busharguing that it was necessary to invade Iraq because we had to //fight the "terrorists" **over there**// or we'd be fighting them //**over here**//As I recall, nobody bothered to ask the president how said "terrorists" were going to get //**over here**//It's not just that this made no sense, but rather, //it was multiple degrees away from making any sense//. Even if we accepted the (frankly dubious) premise that Iraq and Afghanistan were full of these "terrorists" who want to come //**over here**// and kill random peopleAND further accepting the (frankly dubious) premise that they had the means somehow to get //**over here**//, how would invading and occupying these countries remedy the problem? (//If anythingit would exacerbate the problem, but certainly not make things better!//) If real life worked like these Hollywood movies, the appropriate people would have shown up shortly to drag off MrBush to the rubber room. Or, if not quite that, by talking such self-evident nonsense, Bush would have squandered pretty much all of his credibility and moral authority. Wellwe know that nothing of the sort happened. Mr. Bush got the "splendid little war" that he (or, more precisely, his handlers) wanted and was re-elected to a second term in office.
  
-(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, don't mean to say that these Captain Queeg moments //never// occur in real life"Never" is a strong word and how could know that anyway? However, I would say that they are much more the exception than the rule. What is typical, as the Milgram experiment and the preceding case of George Bush show, is that very many people, maybe the vast majority, will not question a perceived authority figure even under quite extreme, downright surreal conditionsSelf-observation is always difficult, but I believe that I myself, for whatever reasons, have somewhat less tendency than most people to accept illegitimate authorityHowever, I still made a very key mistake in that regard when I "forked" the JavaCC codebase and named it "FreeCC". Even though I rejected the "authority" of the Nothingburger artists in control of the existing JavaCC project, for some reason, I still accepted their exclusive right to call their product "JavaCC"On reflection, however, my "fork" was (and issimply a forward evolution of the codebase that Sun Microsystems released in 2003. In what real sense is it less "JavaCC" than anything else is? In retrospect, it is quite clear that I should have simply labeled my "fork" as JavaCC and if this caused any confusion, simply to say that this was JavaCC and their tool was also JavaCC, though obviously a quite inferior, less advanced version.
  
-Now, the next pointthis excessive reverence for "stability" and "backward compatibility" is also quite symptomatic of all thisWellreallyproperly understood, it is a rather transparent rhetorical trickAfter 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! +I would also add that if these people ever did have any real exclusive right to use of the namethey really forfeited that right when they refused to even review contributions. It simply makes no sense for people to be able to remain in a position indefinitely when they fail to carry out the most basic responsibilities that said position entailsNot only had these people not done any work on the codebase in five yearsbut when somebody eager to do something with itand had already a significant contribution to make (not just proposalstalk, but work already done!) showed up, they refused to review it. One might think that only a very foolish person would accept that by just continuing the work elsewhere and calling it JavaCC, I was violating their "rights". Becauseyou see, my work was not a "fork". It was then (and now) the only line of active development on the JavaCC codebase.
  
-Frankly, 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!//) Regardlessthe 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.+That is my current position. am satisfied that it is correct. However, I am perplexedquite franklythat it took me so many years to realize this. Well, I can be quite slow at times.
  
-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 symptombut not really a //sine qua non// eitherHowever, we do observe it in the legacy JavaCC projectwhich 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 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 [[https://semver.org/|here]]+At this moment, this essay is still work in progresswhich I intend to resume later and polish off, time permitting. At this point, I will leave things off by clarifying simple point: I am not claiming to have any definitive answers or solutions to //nothingburger-ism//. ThusI write this essay more to open a much-needed discussion than anything else. If you wish to engage in such discussion, please go here: [[https://discuss.parsers.org/t/the-art-of-the-nothingburger/38|https://parsers.org/t/the-art-of-the-nothingburger/38]])
  
-I shall close this segment on Nothingburgerism here. The [[Nothingburger2|next segment]] will continue the discussion with some analysis of the causes and treatment of the Nothingburger problem.