Absolutism Has Greater Burden Of Proof

Those who claim there is "one true way" have a greater burden of proof than those who claim a personal preference to a technique. This is because the scope of the claim of the first is much greater than the second.

I created this topic because the issue keeps coming up. Thus, I wish to factor it to one spot.


Absolutism is not about "one true ways", it's about "truth", starting with 'true and false are distinct and not equal to one another'.

In this context, it is about proving that software principles and related tools and techniques are "objectively better".

TopMind once again stands proudly upon his white horse and commands all to speak HIS version of the English language. (...) or is it HumptyDumpty on the wall?

Do you have a specific complaint? Otherwise, stop filling up wiki with vague dangling personal digs like a 7-year-old tagger on crack.

It would take a blind man not to see the specific complaint listed just three sentences above, and then see TopMind redefining language to his preference one sentence below that. Top will stop receiving personal digs when he stops earning them.

Other readers may not want to see your spanking sessions scattered all about this wiki. Don't make them suffer for my (alleged) sins. It's rude to them also. You are not mature and patient enough to be the punishment giver anyhow

Absolutism Challenge (that isn't really about absolutism)

I've never seen an objective proof that any software engineering technique is "better" than another. All past attempts eventually boil down to psychology (AllHolyWarsTiedToPsychology?). I challenge anybody to point out such proof.

It is undeniable that some software designs and languages are objectively worse or no better at ALL of software properties that one might reasonably deem "good" than are certain other software designs and languages. Trivially, one can intentionally design a language that is intended to have poor performance, to make expression of any concept non-trivial to the programmer, to compound and exaggerate errors, to introduce errors artificially and pseudorandomly (maybe based on the phase of the moon), to make security or performance or correctness guarantees impossible, et cetera. (And that language is called "Java". Sorry, carry on.) And some people have designed such languages and frameworks, often for the fun of it. One can also intentionally solve every single problem in the most bass-ackwards way their imagination can devise - and some people do so on a regular basis - see WorseThanFailure and such constructs as:

  return (test == true)? ( (test == false)? false : true) : ((test == false) ? false : true); 
  // which can be reduced to 'return test;'  
It is languages and designs and software snippets such as these that prove that some software engineering techniques are objectively better than others, and thus disprove any naive insistence or belief to the contrary.

Sure, it's silly, but it is also sufficient.

One could, of course, come up with a ridiculously twisted set of values such that "security is bad! it means I can't install a backdoor or scam money!" and "readability is awful! it harms job security!". While I admit to finding such statements entertaining, they aren't really serious attacks against the fact that some language/framework/architecture/software designs are objectively, by all reasonable measures, strictly worse or no better than others.

When I forgot my password when I'm in a critical hurry, security certainly feels "bad" at that moment. Needless to say, every feature or technique has it's trade-offs.

Actually, I think you need to both 'say' "every feature or technique has its trade-offs", and then you need to prove it. That was, after all, a very absolute statement you just made - one that must have greater burden of proof. What, pray tell, are the trade-offs of exchanging 'return (test == true)? ((test == false)?false : true) : ((test == false) ? false : true)' technique for the 'return test' technique? Are you going to argue that you're trading-off confusion for clarity? inefficiency for speed? what?

Lack of trade-offs is not the default if I fail to provide proof of tradeoffs. "Unknown" or "null" is the default.

Barne of C++ fame says almost this very statement (regarding readability) that C++ was invented for genius/experts only, and that the entire purpose of C++ was to weed out any programmers (re: jobs etc.) who couldn't understand its syntax, notation, pointers, etc. The exact quote, is.. "insert_here"

But there is still no consensus objective way to measure such. A really smart person may get the hang of just about any language anyone could invent and be as productive as the average Java or PHP programmer. We can take a vote, but that only measures subjective preference.

{On 'readability', indeed, there is little consensus on a proper way to measure it. Part of the problem is that there is no clean laboratory setting - no matter what language you design, potential users of the language will be influenced by the languages they already know - we'll probably need to develop 'artificial' language-learning agents with scalable but objectively measurable levels of 'intelligence' before there is a fair test that can be applied to any language. That said, I think inventing a language for genius/experts only is a wholly stupid idea. The more people that can effectively, and correctly, do programming, the faster innovation will occur and the more grunt work can be handed off to people who aren't willing to dedicate the effort necessary to be creative (since creativity is, in both my experience and that of Edison, 99% perspiration).}

Some objective properties that are generally considered good:

Note that some of those objective properties are easiest to measure in comparison to another implementation as opposed to on some absolute scale. They are no less objective for this.

Some subjective but statistically measurable properties that are considered good:

Possible Exceptions and caveats include:

Even GoTo's have not found objective evidence again them (something that almost nobody supports anymore). The best arguments are still tied to psychology assumptions. If we cannot do it for GoTo's, then how is anybody going to succeed with other HolyWar topics such as typing, OOP, and relational normalization degree?

See a GoodUseOfGoto

The "predominant style" is nested blocks these days. Whether a sprinkling of Go To's or Go-To-like idioms are acceptable or not is mostly a side detail. But structured blocks grew in popularity mostly by ArgumentFromVotes, not objective proof.

Do you have any objective proof that structured blocks grew due to argument from votes? The relational model grew because of ArgumentFromAuthority (Ed Codd was the authority on the subject) which was a good thing. I think structured programming also grew because of authority; people listened to the experts on the subject. It grew because of logical reasoning more so than authority or votes, though.

Some claim that the evidence is in academic papers or books. If you believe such, then please supply the following:

The one true way might not be something we can follow word for word exactly, but having a guideline and point of reference is important. Just as math exists as a good guideline, so that when we add one plus one together.. we get two. It is a guideline, and a good one. If we have other people adding one and one to get five, then our guideline is f**kered and we have to do something about it - create standards, articles, guidelines, education, etc. As something such as normalization is a good guideline to follow - just as one plus one is a good guideline to follow - how can one claim that having a personal preference that one plus one is five is more worthy of respect and proof?

We can empirically test arithmetic by counting items such as pebbles. Balancing our checkbooks is another such empirical test.

Not if the person psychologically doesn't enjoy counting pebbles, and if he psychologically thinks 1+1=5, he may have a valid psychiatric problem. If he wants to think that 1+1=5 and that fits his psychology, why not let him? EverythingIsRelative so to him the number 5 could be the number 2.

You are over-focusing on EverythingIsRelative. I've found it better to find a common ground between parties and work up from there. There is no use in arguing about whether a chair exists (common exercise in Philosophy 101) if both parties agree it exists for a sake of a common issue between them. Call it "local absolutism" or "working absolutism": these are the givens we both agree on. As far as this wiki, somebody with too many "unpopular" givens (base assumptions) that they cannot reasonably justify as deserving consideration is probably going to be ignored, regardless of whether they are "right".

For example, most people these days prefer blocks over goto's and there is little incentive for anyone to "prove" blocks are better. Thus, as a practical issue, it's usually moot. It's only an issue in an academic kind of setting or people studying or interested in evidence presentation techniques. And some WikiZens are indeed interested in such subjects.

There was incentive decades ago to prove structured programming is better, which is not just blocks but a whole branch of programming technique like the relational model. There was incentive decades ago to prove relational was better too. People listened, and understood the logical superiority - whereas you claim there isn't any logical superiority and it is just a matter of psychology.

Goto's are an interesting case study in that almost everyone agrees that "blocks won" (for the most part), yet an objective proof remains elusive. Thus, if we can't do it for the "obvious" winners, then how do we do it for more contentious superiority claims? -t


EditText of this page (last edited August 26, 2014) or FindPage with title or text search