Slashdot Mirror
The Most WTF-y Programming Languages
itwbennett writes "A couple of years ago, developer Sammy Larbi undertook a project to identify which languages had the most instances of the string 'WTF' in their GitHub code repositories. At the time, Objective C topped the list. ITworld's Phil Johnson has updated Larbi's research using GitHub data from the last 21 months, but instead of screen-scraping GitHub search results as Larbi had done, he queried the GitHub Archive for stand-alone instances of 'WTF' in the comments attached to GitHub commits to weed out cases where the string 'WTF' was legitimately used in the code. The three most baffling languages for 2012/13: C++, Lua, and Scala. Objective C comes in at #16."
WTF?
Solving Unix problems since 1989...
C++ deserves its spot, it's pretty screwed up. I haven't dealt with Lua or Scala, so I can't comment on either. However, I imagine this probably also scales directly with the popularity of the language and indirectly with the skill of the people writing in it. So Lua would make sense; it's popular and seems to attract a lot of amateurs. I'm surprised PHP is so low, though; I hear horror stories about it that make me glad I never have to touch it.
How is making a variable called WTF better than adding WTF to a comment? To me it means even the original writer didn't know WTF he was doing. For some reason Objective C apparently uses it a lot as a variable name.
Just wondering...
We were all warned a long time ago that MS products sucked, remember the Magic 8 Ball said, "Outlook not so good"
I'm not sure whether it's the language, or the people who choose to use it.
...instead of the code itself?
I've seen plenty of "WTF was this guy thinking when he wrote this?" or "WTF is he trying to do here?" comments in code.
Loading...
WTF
Where are some examples of these offending comments? With no context this list of languages is meaningless.
I am Slashdot. Are you Slashdot as well?
those conclusions are drawn without controling for a language usage. Since c++ is widely adopted so there will be more instances of a comment where "WTF?" is used.
Why don't use a percentage at least? Even if that was the case, the problem remains... a wtf-y language may be the most avoided and/or not present in github
Sometimes it's better not having signature
Escher was the first MC and Giger invented the HR department.
Is there any indication why Lua scores so highly here? It seems a rather benign little language to me. Certainly, nil-terminated arrays are can be tricky, and a missing local keyword can ruin your day, but that seem minor annoyances. And for the local-vs-global issue, there are now editors with semantics highlighting that clearly disambiguate the two cases.
Whenever I start on a maintenance project, the first thing I do is grep the codebase for profanity. It always gives me an idea of how painful the job will be.
I have a customized WTF comment template i really like.
Brainfuck. Look it up, I can't even give a code example as it pisses off /.'s filter.
Python would be my biggest WTF.
My WTF would be people posting Visual Basic to GitHub. Then another WTF for anyone posting cobol to Github. My next WTF would be where the WTF is directed. Is it directed at the code or away from the code. Also many might be directed at the language or even a specific implementation. So my regular WTF in Objective-C would be theInsanelyLongDefinedParametersThatAreUsedInTheNS library. But when it comes to much of my own past perl code I suspect I would comment WTF in that in my Perl days I could twist a regular expression into pretty much anything.
But when you are getting to a lower level as in C and C++ you are going to be running up against strangeness in libraries like OpenGL and might be writing a comment such as "WTF won't nVidia release a proper library for Linux?" Or "WTF is wrong with the Android NDK and getting GPS data in C++?"
And not WTF per line of code? Seriously?
Watchdog Timer Fault.
Get free satoshi (Bitcoin) and Dogecoins
C/C++ does allow for a lot of that.
Reading IOCCC entries illustrates this perfectly.
We Objective-C developers prefer more verbose WTF statements, such as
- (void)whatTheFuckAreYouDoing:(NSString *)wtf withThatAbsurdAlgorithm:(NSString *)algorithm thatOnlyOnePersonOnDevTeamUnderstands:(BOOL)doesHeReallyUnderstandIt;
All of us develop according to the platform. In other words, you want to make a living coding apps, code in Objective -C, C# or Java.
What's the issue here?!
I mean if I had to make a living coding COBOL, I'd do it!
Languages are irrelevant. You want to develop iOS apps - Objective-C. MS apps? Well, you get a break here C# (Java Clone), VB, C++, C, etc ...
Android - C++ and they push you to Java.
Languages are just Syntax - get over it.
Stuck on a language because it's the "best" tool? You are a hack. A computer scientist KNOWS that languages are just syntax and anyone worth their salt can implement their algorithm in ANY language.
Morons.
More like 'WTF was I thinking when I wrote this?"
And then one day I started working on a mobile application regulated by the FDA as a medical device and realized that I'd better start making smarter comments.
Turns out the better you comment your code as you go, there are less or no WTF's in the final commits.
Of course then there is JavaScript where WTF returned as undefined so who knows.
According to TFA, he "calculated the average number of WTF commit comments per repository". So why not per line of code or whatever? C++ projects tend to be rather large (because it is harder to write large projects in other languages), so surely by this metric C++ would win (aka lose) here.
If there is one thing I have learned about statistics it is that you can prove about anything you want ... unless you want and are actually able to find the correct normalizations.
IMHO, C++ is a simple, flexible, intuitive, and powerful language... IF (and only if) you know how to use it.
The problem is, most programmers don't. So often, I end up working on spaghetti code written 5 years ago by someone who, for example, thinks inheritance is the solution to all problems, and that private member variables are for sissies.
Also, I wonder how many of those "WTF"s were from people trying to use Windows APIs (don't you just love COM?). That's what consistently causes me the most frustration.
It's also skewed to "languages used in Github projects". More importantly, would the people programming in a real WTF language not even know that it was such a WTF?
#naabhaprzrag, #sverubfr-000, #agi-fcbafberq, negvpyr[pynff*=' negvpyr-ary-'] { qvfcynl: abar !vzcbegnag; }
by using the search term "l33t".
I knew a guy whose initials were WTF......
I don't know if he ever used them as a login, though.
There's obviously something wrong with this metric since Python has twice the whatTheFuckability as Perl: http://www.itworld.com/sites/default/files/WTF_programming_languages-600x450.jpg
soylentnews.org
I think the best way to evaluate this would be WTFs per node in a parse tree, or some other structure that accounts for the actual complexity of the code as opposed to the verbosity of the language. Otherwise, begin... end languages would appear less WTFy then {... } languages.
The question is really moot though. Just grepping for WTF won't tell you if it's directed at a problem related to the language (WTF doesn't this template generate what I want, Lisp macros were so much better) or the code (WTF were they thinking when they created this mother-of-all classes?).
WTFs could also relate to the environment in which the code is being written. Start-ups using JavaScript might not mind if you swear in the code. They might let you do that until the company gets big, then the boss tells you to do a global search and replace on all the swears. I've seen that happen. Perl is more likely being used for mature projects where that happened a long time ago, and you really should have got the memo or read in the company handbook that any hint of unprofessional language isn't allowed in the code.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
... that since there's always going to be detractors in any programming language, the more popular a language is in actual use, the more prevalent there is liable to be a bias against that particular language. The correlation of course, is not strictly linear, since different percentages of people familiar with a language will be biased against them, Nonetheless, I think a more interesting and informative analysis would be to normalize the list of hated languages against the individual language's actual real-world use.
File under 'M' for 'Manic ranting'
Anyone know how many clones of WebKit and related projects are on GitHub? Because I can imagine that pretty much skewing the statistics for C++ due to this: https://trac.webkit.org/browser/trunk/Source/WTF.
Perhaps says more about the culture of the language. If you go to the raw numbers, you'll see that WTF is not used in the more than 20k Ada repos. First -- surprised that there is that much overlap between Ada programmers and Github users; and second -- the kind of people that would use Ada generally would not type "WTF"...
I challenge anyone to show me a legitimate instance of WTF in code.
Good code vs. Bad Code
Have gnu, will travel.
I'm so sick of the idiots coming out of college now that only know Java, the way they look at you in horror when you say, "No, there is not a library for that. You have to write it yourself."
I can agree with the sentiment that someone who only knows how to put libraries together wouldn't be a particularly good developer (and by extension, a particularly good employee), but discounting someone who prefers using a pre-existing library instead of baking their own solution seems a bit of an overreaction. Software development is like any other aspect of collaboration: you won't get very far by reinventing the wheel every time, so what's wrong with building on the work of others in order to accomplish a goal?
WTF?
SELECT repository_language, count(*) AS wtf_cnt
FROM [githubarchive:github.timeline]
WHERE type == "PushEvent" AND
REGEXP_MATCH(LOWER(payload_commit_msg), r'wtf[^a-zA-Z0-9]')
AND PARSE_UTC_USEC(repository_created_at) >= PARSE_UTC_USEC('2012-01-01 00:00:00')
AND PARSE_UTC_USEC(repository_created_at) GROUP BY repository_language
ORDER BY wtf_cnt DESC
LIMIT 100
Guns don't kill people; Physics kills people! - John Lithgow as Dick Solomon on Third Rock From The Sun
there is a reason there isn't WTF for java.... because nobody uses Java to write, for example, a graphics card driver or code that has to interface with graphics card drivers. Because you can't. It's like saying, look at how many bullets get shot at you if you are in a police car vs an ice cream truck, then saying that ice cream trucks are better cars because they get shot less.
C++ is full of constructs that while good code and properly used, still leave the reader thinking WTF? There's just a lot of language that most people have no reason to use, and so can be baffling when first encountered. Things like overloading "new" and "placement new" make perfect sense when you have the problem they were intended to solve, but otherwise just inspire "what is this I don't even!"
Good C code tends to make sense even if you don't know C.
Socialism: a lie told by totalitarians and believed by fools.
Noting that you can write WTF code in any language, and putting up a defense of C++ on the basis that just because a feature exists you don't need to (mis)use it, even though sadly the majority of coders using it tend to so, Scala is really the most unsuitable language I've ever encountered for preety much any application due to what I call the novely factor whereby nobody using it in commercial projects knows how it can be used advantageously to build something better than they could with more mature application frameworks: I watched a total slow motion car crash of a Scala project descend into mayhem over 9 months, at which point the only happy event noticeable was that all the "Scala evangelists" were told never to turn up ever again.
But it sounds similiar to how muds/mushes from the early 80s to mid 90s looked.
Thankfully there weren't many gotos in those codebases, but a *TON* of them relied on some pretty convoluted switch statements for a number of years before moving to saner data structures for command parsing.
WTF comments could also reflect on the project's setup. Or people working on a project's skills. Etc etc et. Language is just a tool, I've had WTF moments in many languages that where not dependent on the language.
Why would seeing 'WTF' implicate the language...instead of the code itself?
Well, my nominee for the language that enforces a "WTF" syntax is DOS/Windows batch/command language (so WTF it doesn't even have an official name). There's been more than a few times I had to google to figure out how to script some seemingly simple functionality and upon finding the answer said "Really?!?! WTF?!?" It is pretty much impossible to make more-than-trivial batch scripts readable to someone not well versed in the black art of .bat, at least not without a boat load of rem statements.
Momentarily, the need for the construction of new light will no longer exist.
Or are the results skewed by how many lines of code and how popular those languages are?
Given the way the author searched, the title of the article should be "Top 10 worst coded programming languages" or maybe "Top 10 worst Hacked Programming Languages". The article only measures what coders thing of other people's code, not the languages themselves.
Good code in any language should make sense to a layman. If a "user" can walk up and start reading your code/comments and follow the logic flow then you are doing your job. I maintain a codebase at work that is very good and very clean but the naming is a tad terse and it lacks comments that are needed when such a style is used. In other words, you need to be a seasoned developer to understand even the simplest constucts. There are not many things that even qualify as WTF, although people complain all the time, but it takes a lot of time for experienced developers to dig deep.
I object to power without constructive purpose. --Spock
I don't think he's discounting someone who wants to use a pre-existing library. He's saying he enjoys making them write libraries because one doesn't exist for the given task. But i think calling people coming out of college idiots is itself idiotic. College doesn't teach people to be good and experienced programmers/developers. It gives them a lot of different experiences. He calls C#, Java, Ruby, and Python garbage because he probably has never worked with them. I'm sure he still writes his website's back-end in C++ too, lol.
http://soylentnews.org/~tibman
...doesn't mean you should shout "fire!" in a crowed theater.
I am very small, utmostly microscopic.
I have been writing C++ for over 20 years. I love it. But I also think Java and Python are decent languages as well (and I have heard great things about Ruby).
I am very small, utmostly microscopic.
PS you haven't lived until you have written a Python extension in C++ (which of course lives in a C wrapper). Good clean fun, that.
I am very small, utmostly microscopic.
I agree. Just because some code was commented on by William T Foster doesn't mean the code or the language is bad.
C++ tends to make way too much implicit making the code much harder to read at a logical level, as you always have to keep all of C++s quirks in mind when reading. For instance, C++ is the only language I know of where the following is not equivalent:
Widget foo; foo=bar;
And:
Widget foo=bar;
Having to keep in mind one evokes the default constructor and the other invokes the copy constructor makes it much more difficult to focus on what the code is actually doing, and things like that tend to lead to a lot of subtle bugs in C++ code.
Monstar L
Obligatory comic
I've worked with all of those. Java is ugly and overly verbose, but usable. It's basically cobalt. C# is better than java, but useless because it's tied to windows. Ruby is shit. Using it for anything beyond a silly script for yourself is asking for disaster. Python is amazing.
Lua is designed to have very minimal documentation so while learning it there is sort of a constant WTF going on. I like the fact Lua can be used in this manner but while learning to do things in it I was sort of aghast at how much thinking on your feet you have to do. C# is like an art supply store and Lua is like a single piece of chalk but with either it is possible to create amazing artwork.
Did he take into account the amount of code written in these languages and offsetting that against the WTF instances? For e.g. Clojure will not have a code base as large as that of C++. So it's obvious, that it will have lesser WTF than C++. A weight needs to be given to the amount of code as well otherwise these figures are just common sense.
C++ amongst 3 most baffling ...
Wonder if a breakdown of features within the language would show the template features as the largest subset for bafflement
or possibly something more dealing with libraries which might, with more low level usages/utility, be more diverse (and more marginally documented by minority user groups)
http://thedailywtf.com/Articles/A_Case_of_the_MUMPS.aspx
;1/16/92 11:36 AM
;;19.0;VA FileMan;;Jul 14, 1992
;
;
;
; ;
%DTC
%DTC ; SF/XAK - DATE/TIME OPERATIONS
D I 'X1!'X2 S X="" Q
S X=X1 D H S X1=%H,X=X2,X2=%Y+1 D H S X=X1-%H,%Y=%Y+1&X2
K %H,X1,X2 Q
C S X=X1 Q:'X D H S %H=%H+X2 D YMD S:$P(X1,".",2) X=X_"."_$P(X1,".",2)
K X1,X2 Q
S S %=%#60/100+(%#3600\60)/100+(%\3600)/100 Q
H I X<1410000 S %H=0,%Y=-1 Q
S %Y=$E(X,1,3),%M=$E(X,4,5),%D=$E(X,6,7)
S %T=$E(X_0,9,10)*60+$E(X_"000",11,12)*60+$E(X_"00000",13,14)
TOH S
%H=%M>2&'(%Y#4)+$P("^31^59^90^120^151^181^212^243^273^304^334","^",%M)+%D
S %='%M!'%D,%Y=%Y-141,%H=%H+(%Y*365)+(%Y\4)-(%Y>59)+%,%Y=$S(%:-
1,1:%H+4#7)
K %M,%D,% Q
DOW D H S Y=%Y K %H,%Y Q
DW D H S Y=%Y,X=$P("SUN^MON^TUES^WEDNES^THURS^FRI^SATUR","^",Y+1)_"DAY"
S:Y<0 X="" Q
7 S %=%H>21608+%H-.1,%Y=%\365.25+141,%=%#365.25\1
S %D=%+306#(%Y#4=0+365)#153#61#31+1,%M=%-%D\29+1
S X=%Y_"00"+%M_"00"+%D Q
YX D YMD S Y=X_% G DD^%DT
YMD D 7 S %=$P(%H,",",2) D S K %D,%M,%Y Q
T F %=1:1 S Y=$E(X,%) Q:"+-"[Y G 1^%DT:$E("TODAY",%)'=Y
S X=$E(X,%+1,99) G PM:Y="" I +X'=X D DMW S X=%
G:'X 1^%DT
PM S @("%H=$H"_Y_X) D TT G 1^%DT:%I(3)'?3N,D^%DT
N F %=2:1 S Y=$E(X,%) Q:"+-"[Y G 1^%DT:$E("NOW",%)'=Y
I Y="" S %H=$H G RT
S X=$E(X,%+1,99)
I X?1.N1"H" S X=X*3600,%H=$H,@("X=$P(%H,"","",2)"_Y_X),%=$S(X<0:-
1,1:0)+(X\86400),X=X#86400,%H=$P(%H,",")+%_","_X G RT
D DMW G 1^%DT:'% S @("%H=$H"_Y_%),%H=%H_","_$P($H,",",2)
RT D TT S %=$P(%H,",",2) D S S %=X_% I %DT'["S" S %=+$E(%,1,12)
Q:'$D(%(0)) S Y=% G E^%DT
PF S %H=$H D YMD S %(9)=X,X=%DT["F"*2-1 I @("%I(1)*100+%I(2)"_$E(">
<",X+2)_"$E(%(9),4,7)") S %I(3)=%I(3)+X
Q
TT D 7 S %I(1)=%M,%I(2)=%D,%I(3)=%Y K %M,%D,%Y Q
NOW S %H=$H,%H=$S($P(%H,",",2):%H,1:%H-1)
D TT S %=$P(%H,",",2) D S S %=X_$S(%:%,1:.24) Q
DMW S %=$S(X?1.N1"D":+X,X?1.N1"W":X*7,X?1.N1"M":X*30,+X=X:X,1:0)
Q
COMMA
S %D=X<0 S:%D X=-X S %=$S($D(X2):+X2,1:2),X=$J(X,1,%),%=$L(X)-3-
$E(23456789,%),%L=$S($D(X3):X3,1:12)
F %=%:-3 Q:$E(X,%)="" S X=$E(X,1,%)_","_$E(X,%+1,99)
S:$D(X2) X=$E("$",X2["$")_X S X=$J($E("(",%D)_X_$E(" )",%D+1),%L) K
%,%D,%L
Q
HELP S DDH=$S($D(DDH):DDH,1:0),A1="Examples of Valid Dates:" D %
S A1=" JAN 20 1957 or 20 JAN 57 or 1/20/57"_$S(%DT'["N":" or
012057",1:"") D %
S A1=" T (for TODAY), T+1 (for TOMORROW), T+2, T+7, etc." D %
S A1=" T-1 (for YESTERDAY), T-3W (for 3 WEEKS AGO), etc." D %
S A1="If the year is omitted, the computer "_$S(%DT["P":"assumes a
date in the PAST.",1:"uses the CURRENT YEAR.") D %
I %DT'["X" S A1="You may omit the precise day, as: JAN, 1957" D %
I %DT'["T",%DT'["R" G 0
S A1="If the date is omitted, the current date is assumed." D %
S A1="Follow the date with a time, such as JAN 20@10, T@10AM, 10:30,
etc." D %
S A1="You may enter a time, such as NOON, MIDNIGHT or NOW." D %
It should probably also be offset by how many lines of code there are in language X.
Michael J. Ryan - tracker1.info
What's sad is I've looked at code before and thought WTF, who the hell wrote this cr@p, checked the change log and it was me :-(
There are three kinds of falsehood: the first is a 'fib,' the second is a downright lie, and the third is statistics.
I'm sure he still writes his website's back-end in C++ too, lol.
But see there's the myopia (no offense intended). Who said anything about websites?
I'm not the OP, but I've also used C++ for about 20 years (C even longer). I develop firmware for safety-critical systems. Most of them have hard real-time deadlines. My colleagues and I have to understand assembly language, schematics, compilers and linkers, optimization opportunities, etc. Most of us are pretty strong in DSP. Most of us couldn't design a website, write a javascript program or tell you jack about Ruby on Rails.
C and C++ are the go-to languages in embedded systems. There was a LOT of code before the World Wide Web (even the internet), and you've probably used 10 embedded systems just since you woke up.
You're welcome to stay on my lawn, but please don't poop on it.
why is this important in any regard or even news?
When I have been part of interviewing new hires, I've tended to ask this question: "what do you find frustrating about C++?"
If you really know C++, there are bound to be at least a few things that you find frustrating. The lack of standardisation on binary interfaces, the continued drive for flexibility at all costs (resulting in a million ways to do one simple thing) and the way they have ALWAYS emphasised pattern clutches over improving the language. Despite (or perhaps because of) the near-complete lack of ABI compatibility between versions, they nearly never remove or depricate anything in the the standard or the STL API, meaning any new "simplification" always comes in addition to the old way, it never replaces it. Sadly this means the standard is never actually simplified, they just add yet another layer of abstraction, which always leaks. Lots of the STL and the standard patterns used by C++ developers are really clever and I'm sure they were intensily satisfying to develop. But satisfying cleverness is not necessarily something to build a programming language on.
The worst part is that the patterns and algorithms which were developed to work around gaps in the core language actually become arguments not to improve the core language. Let's face it; as much as I've used std::for_each, it should never have existed. Instead, range-based for-loops should have been in way before C++11.
The c++ FQA sums up some of my own frustrations.
That said. There is no other language with such easy access to such a myriad of great libraries out there, especially for science/engineering/visualisation, and for this reason I cannot agree with the FQA's notion that there are no reason to start new projects in C++. By using these libraries, your own code could well become quite elegant and you would shoot yourself in the foot if you decided to avoid C++ on principle for a situation where C++ and its large set of libraries would solve your problem.
Worse yet, they forgot INTERCAL! Any language with a "COME FROM" command (rather than "GO TO") should make the list by default.
Of course, noone uses it, so maybe it didn't meet the criteria. Whereas I agree that SQL is hugely used. SQL isn't really a programming language, though... extensions such as PL/SQL help make it so, but those are very non-standard and tweaky in their own right. As a set-focused (relational) data processing tool, SQL actually does OK.
---Chip
The real source of WTF is the platform - you're trying to reverse-engineer the design of some library or framework that people have been overengineering for a long time. C++'s libraries and templates are mind-boggling. Android is so overengineered that I can't figure out how to do simple things without creating a big mess. Java has three or four I/O libraries and two or three threading libraries.
I'm afraid that the vanishingly small sample of Lua and Smalltalk render their WTF-yness rather invalid. One might call this the hasty generalization fallacy.
Kriston
The most WTF language is "Anything they don't use" ;-)
KateKarnage - Goth, Geek, Not all there......
I don't consider C++ code itself to be confusing or poor, but I think there can be significantly more done to modernize the language, including it's IDE and compilers to remove the contrivances of headers, slow compile and retarded linkage. Considering that large C++ projects could still take hours to compile on over-spec'd monster boxes, compared to modern languages that takes only a few seconds to compile on a far leaner machine, it is obvious C++ needs some serious overhaul at its core.
I haven't thought of anything clever to put here, but then again most of you haven't either.
lol objective C would have been my guess for # 1
Structured Query Language is indeed a programming language. Maybe you mean that it isn't Turing Complete, but it is none the less a programming language for computers.
Guns don't kill people; Physics kills people! - John Lithgow as Dick Solomon on Third Rock From The Sun
Sure, C++ explicitly give you the freedom to do stupid shit, and if coders in fact do stupid shit in your code base, then you'll have a shitty codebase. That's why C# or Java is better for most projects: few teams have the process and discipline to keep the junior guys from doing it wrong. Though with modern code review tools, this has become far more reasonable to do, and I might actually consider C++ for a new project thanks to ReviewBoard and the like.
But if you need the difference between the copy constructor and assignment. Or, more likely, if you need your own memory management model, or any of the other quirky stuff C++ has support for built into the language, you're just better off using C++ than re-inventing it in C - I just have too much experience with the bugfest of the latter approach to tolerate reinventing those wheels ever again.
Socialism: a lie told by totalitarians and believed by fools.
Which language(s) do you currently use?
Unity? Screw that: XFCE. Slashdot Beta? Screw that: SoylentNews. Australis? Screw that: Pale Moon. UX developers DIAF
I wasn't doing any pooping. Only pointing out that you need to use the right tool for the right job. Saying C++ is all you need sounds like a developer making excuses for not wanting to learn new languages. You can still write C++ binaries and put them into the cgi-bin for your website back-end but yuck and ouch. Please don't take that statement to mean C++ is garbage. It is not. It just isn't as suited to web development.
http://soylentnews.org/~tibman
I have no qualms with the copy constructor, if only it were made explicit. The fact that C++ makes way too much implicit(like in the example above) is probably what I find most objectionable about the language. It makes code much harder to read if in addition to evaluating the logic you also have to keep a million rules about what is really going on in your head.
Monstar L
Oh, I agree completely. My list of things that annoy me about C++ are pretty much all that same complaint - the C mindset of making everything as terse as possible only works with a language as simple as C.
Socialism: a lie told by totalitarians and believed by fools.
Precisely.
It should probably also be offset by how many lines of code there are in language X.
Why? That just skews against more verbose languages. It should be possible to write non-trivial projects without any WTFy-ness at all. If your language can't, that's a really good indication that it is the wrong tool.
"Little does he know, but there is no 'I' in 'Idiot'!"
PHP is 100% WTF