144858

304
+833  Q:

## Strangest language feature

What is, in your opinion, the most surprising, weird, strange or really "WTF" language feature you have encountered?

+100  A:

1;


In perl, modules need to return something true.

Sorry, not getting it...
That always gave me a queasy feeling, too...
Some modules may return values based on runtime operations. If you always return true, you still don't have to be uncreative about it: http://returnvalues.useperl.at/
i respect the perl and its users for their creativity ...
If my Perl memory serves me correctly, returning true from a module indicated that the module loaded successfully. Returning a false value meant that something went wrong and would prevent the program from running (if not caught).
This is a valid C statement as well, only nothing is returned.
many modules do end, for giggles, in: 'false';
Mark Dominus wrote, "I have very rarely used 'Cogito ergo sum'; which as everyone knows is self-evidently true in all possible universes. This ensures maximum portability."
PHP <?=1;?> returns 1. <?=true;?> returns 1. <?=false;?> returns null.
+16  A:

Being able to cast out of range ints to enums in C# is quite weird in my opinion. Imagine this enum:

enum Colour
{
Red = 1,
Green = 2,
Blue = 3
}


Now, if you write:

Colour eco;
eco = (Colour)17;


The compiler thinks that’s fine. And the runtime, too.

See here for more details.

C# doesn't hide the fact Enums are just integers, or whatever you set it too. Int is just the default type. If they would require you to explicitly give enums a underlying type, would it look less strange?
@Dykam: I don't think that enums in C# are *just* integers; if they were *just* integers, we would be using variables of type Int32 to use them, and we are not. Instead, we use a purposefully-created mechanism, the Enum type, that adds *some* type safety to finite lists of named constants. From a semantic point of view, the interesting things about enums is that they represent a domain of values, not that they are integers.
If you look at it like that it can be weird. But if you are afraid the casting will make the code error prone, don't use them... I don't use them either but am happy that the possibility is exposed.
Might be because adding checks to make sure that bitfield enums are valid would be expensive?
@Dykam, @Roger: I don't disagree with either of you. Some time ago I suggested that it might be nice that enums (i.e. finite lists of named constants) and bitfields could be implemented through different syntactic mechanisms in the language rather than the same one. .NET uses the "enum" construct to implement *both* enums and bitfields (perhaps inheriting the C++ tradition) but, from a semantic perspective, a list of named constants (a proper enum) and a list of combinable 1-bit values in an integer (a bitfield) are quite different things. Different things need different language constructs.
Agreed, they are a different beast. Though the current way does simplify some stuff greatly.
@Dykam: Agreed, but still a WTF to me...
+73  A:

In C

a[i++]= i;


It compiles, but it rarely does what you think it ought to do. An optimization change leads to producing wildly different results. And it runs differently on different platforms.

Yet, the compiler's perfectly happy with it.

.. but the language is not. More than one reference to something in an expression that is modified in the expression is undefined behaviour.
@Richard. Why would undefined behavior compile and run? That's my point. That's the strangest feature of the C language. And this particular block of code is what I use to summarize that strange feature in a tangible way. It sometimes leads to arguments with C n00bs who claim that is has a clear meaning.
"Why would undefined behavior compile and run?". In general because some things which cause UB in C cannot be detected at compile time, and detecting them at run time (or defining the behaviour) would significantly impact performance. In this particular case, I do think it's a bit feeble that compilers generally don't detect the error. It would certainly end a lot of those arguments. But equally I'm not about to submit a patch to gcc to issue a warning. Presumably your compiler's authors are working on other things, which would get pushed back if the C language mandated an error for this code.
"Undefined behavior" means the compiler can get away with not handling this code correctly and/or issuing any warning or error whatsoever. That's why it is important, especially in the case of C, to be aware of any undefined or unspecified behavior of the language (as specified in Annexes of the ANSI-C standard). Compilers (or their manufacturers) generally assume you are aware.
@cschol: "Compilers (or their manufacturers) generally assume you are aware" That's precisely the WTF of C.
It's an inevitable consequence of the fact that C permits low-level programming, but CPUs do different things in response to low-level errors. If C had defined all behaviours, then C on x86 would be slow, because it would be attempting to emulate edge-cases from a PDP-7. If you don't like it, you either write in assembly for a particular architecture with fully defined behaviour, or you don't write low-level code. Seems a bit weird though to say in effect, "C's wtf is that it's a portable low-level language". That should not be surprising, since that is its purpose.
a[i++] = i is obviously UB, otoh a[(*p)++] = *q is UB depending on whether p and q point to the same object; you can't tell which until you run the thing, and so the compiler can't actually do anything in the general case. another example: division is UB if the denominator is zero, but what do you expect the compiler to do with x / foo(69)?
In any case, the question was odd features about a language, not a language implementation. As far as I know, undefined behavior is fairly common for languages, and how an implementation treats a case of UB is not a language issue. There may be a catch here that qualifies, but I don't see it offhand.
"undefined behavior is fairly common for languages" Not really. I've worked with a lot of languages; C has this problem in the worst possible way, leading to endless WTF's. Some modern languages like Java don't have this "UB" concept at all. Things are either defined or forbidden or it's a bug waiting to be fixed.
Forgive my C "n00bness," but why is it that this line compiles to something other thana[i] = i; i++;?
@tzenes: it's unclear where -- precisely -- i gets incremented. It could be (as you hope) after the statement as a whole. Or it could be after evaluating the LHS of the assignment. And it's unclear if RHS or LHS is evaluated first. So there are at least four alternatives.
Undefined behaviour is just that, it's undefined. It doesn't mean that it is illegal, just that you can't expect the same *defined* behaviour from all implementations.
It was my understanding that C requires assignment operators to be evaluated RHS first [ie. a=b=c compiles to a = (b = c)] . Based on the postfix increment that should compile to: temp = i; temp_p = i++; *temp_p = temp; But now I'm going to have to dig through the C standard to see if that's true. Edit: apparently I was wrong
"you can't expect the same defined behaviour from all implementations". Best of all? No warning from most compilers. Just code that behaves "oddly" when you change something. That's the WTF moment.
@S. Lott: Over the past sixty-plus years, we've learned a lot about specifying language behavior, but we're not perfect, so there's still undefined behavior in many modern languages. Moreover, languages like C are going to underspecify behavior to allow performance. C is probably still the poster child for UB, though.
@tzenes: It gets complicated. Operations are performed in a more or less defined order to evaluate the value of expressions, but there's a lot less restrictions on applying side effects. The standard specifies "sequence points" at which all side effects have been applied, but there's no sequence point inside that expression. It's an illegal expression, but it isn't obviously so, and similar expressions are well-defined.
with the the -Wall flag, gcc warns about this warning: operation on 'i' may be undefined
In C# at least, it (shouldn't) be undefined: we get i and store it in a variable. increment i, access the array with the temp variable, and set the value. AFAIK, that's how it works...
-1: Undefined behavior is undefined behavior, not illegal behavior.
@trinithis: You're missing the point. The mere presence of "undefined behavior" which compiles without error and produces code is what's wrong with this.
@S.Lott: Except that it's deeper than that. As sgm pointed out, it's easy to write code that might create undefined behavior that the compiler can't possibly catch, unless we want to have defined behavior for x/0, which will seriously slow down division on some computers, whatever the definition. We both know that C has a lot of UB issues, but we seem to miss the root cause.
I'm fine with run-time errors like x/0. I'm not fine with something that compiles error-free and ambiguously. It's the ambiguity that kills me.
+459  A:

Trigraphs in C and C++.

int main() {
printf("LOL??!");
}


This will print LOL|, because the trigraph ??! is converted to |.

Quick! Tell all C /b/ programmers!
Trigraphs are amazing, because you can be sure nobody will -ever- find out what ??! will mean from Google without knowing the name already.
Are trigraphs changed to their equivalent character by the preprocessor?
No dreamlax, by the actual compiler I believe. As long as I know the preprocessor only touches lines that begin with a #
@Andreas: except for of course macro replacements, right?
@bytenik: macros still work in C++. Somehow I think it has a preprocessor... No to mention, oh, *preprocessor directives*!
Trigraphs are disabled by default in GCC.
I don't particularly see the point of trigraphs, although I knew they existed. Are they just there to increase compilation time and help programmers who don't have | in their keyboards(do those keyboards even exist?)
These let you use the "WTF operator": (foo() != ERROR)??!??! cerr << "Error occurred" << endl;
Trigraphs were a necessary evil when they were introduced. Some platforms just did not include certain characters key to the language, so it was either "trigraphs" or "you can't have a C compiler period-end-of-statement so go use assembler". Check out Stroustrup's description in "The C++ Programming Language".
Couldn't it be a feature of the editor, rather than buil tinto the language?
I used to program in C on an IBM mainframe using a 3270 terminal in EBCDIC. Some of the characters needed by C (possibly including the "|" character) weren't on the keyboard and there was no such feature as ^Q 7 C on a block-mode terminal. Oddly, there was a "¦" (U+00A6, "Broken Bar") character. Even more oddly, most modern US PC keyboards have the "¦" character drawn on the key but the PC turns it into "|"
@Adrian Pronk: When I was growing up I always thought it was very strange that the key had a broken bar but when I typed it, the bar was solid. I passed it off as one of those "it is because it is" things.
voyager, I don't think C /b/ (difficult to google) supports trigraphs. (I guess they are included and defined to cause compilation errors.)
@Adrian- You were the other guy doing that? I interned at IBM one summer and they ran out of stuff to do so I proposed a project which the head nerd thought would be great until I said, but if you want me to finish it I have to do it in a language I know really well: C. And so I did. And they loved it. But I had to learn trigraphs.
@Tom Hawtin: http://en.wikipedia.org/wiki/4chan
gcc disallow (or at least warns about) trigraphs by default.
gcc returns it correctly
Having read the Wikipedia digraphs and trigraphs page, it's interesting that the <% and %> are replaced with { and }. I wonder if that's ancestral to their use in asp asp.net php etc.
@dreamlax - that's because the PC keyboard was designed in the 80's for DOS and (IBM/PC flavored) ASCII. If you launch a console window you will see that the 'broken bar' key still output a 'broken-looking bar' there. The bar is 'broken' so it can be composed with - and + to produce _very primitive_ graphical boxes. In Unicode, I believe that the 'broken bar' was introduced elsewhere (0xA6) for compatibility, just so that such graphics can still be drawn.
| ¦ | was for drawing roads in ascii games
Why did they choose weird ??! over just inventing more \e scape \c haracters?
@Chris because they are not escape characters. The example shows the use inside a string, but, get this, you can use them everywhere! Like this: if(foo ??!??! bar) instead of if(foo || bar).
@Euro Micelli: some kind of escaping for Finnish programmers was probably necessary (although lots of Finnish programmers just resigned themselves to programming with operators like ä), but trigraphs are a particularly bad kind of escaping. GCC offers a much more readable set of two-character escapes instead.
A:

The BrainFuck language. It really is!

It's not much of a "strange feature" though, is it? As a language, it's actually extremely simple, and besides, there are *much* more complicated languages out there (Malbolge, for example: http://en.wikipedia.org/wiki/Malbolge).
There should be some kind of Godwin's Law for programming language threads and somebody mentioning BF.
@Coder 42: Let's call it law 42: As an online discussion about programming languages grows longer, the probability of someone mentioning, or posting a solution in, brainfuck aproaches 1.
Edit: As an online discussion about programming languages grows longer, the probability of someone mentioning, or posting a solution in, an esoteric or rarely used programming language aproaches 1.
+8  A:

I've written a programming language for a client (used for experimentally driving custom hardware) with some custom types (Curl, Circuit, ...) that each have only 2 values. They are implicitly convertible to boolean, but (at the request of the client) the exact boolean value of a constant of such a type can be changed at runtime.

E.g.: The type Curl has 2 possible values: CW and CCW (clockwise and counterclockwise). At runtime, you could change the boolean value by a simple assignment statement:

ccw := true


So you could change the boolean meaning of all values of those types.

This would seem like a good idea to me (it allows things like ccw to be defined based on what is in actual data), but only if all such assignments are the same. Differences should be flagged as conflicts, unless there's some awesome way for the compiler to translate between modules. It does seem pretty out there at first glance, I'll agree, but it's a neat idea if you're dealing with input data whose sense you have no control over.
+32  A:

In ruby/python/c, you can concatenate strings just like this:

a = "foo" "bar"
print a # => "foobar"

In C as well, no?
And Python also.
THat's not WTF --- that's awesomeness
@redder: as long as they're constant strings - yes.
Oh yeah. That's fun if you have a variadic function in C and forget the comma between two symbolic constants. All params offset by one, and crashes galore. But is nice in e.g. ObjC, where you can use @"" __FILE__ to get an NSString with the file name.
Ooooh, neat ObjC trick!
Still a better string concatenation syntax than + (see chrisharris.'s above), except that it's only good with constants.
As a side note in Obj-C, when you use it with NSString constants (@""), you don't need any extra @s. For example, @"foo" "bar". This can be really useful for breaking strings across lines...
Pfft, sh has been doing this for decades.
String **constants**. Doing "foo" bar where bar is a variable containing a string won't work.
In Core Foundation, the CFSTR macro that builds compile-time static CFStringRef instances ensures that it is only used with constant strings by being defined like this: #define CFSTR(x) __some_magic_builtin_that_i_cant_remember("" x "")
In Python this is not "string concatenation" - it is part of the parsing of the code. it is one ot the few thigns taht happen at parse ("compile") time, instead of runtime. So, print "a" + "b"andprint "a" "b" Yield the same result, but are fundamentally different things - the later should only be used for splitting large string constants over multiple lines of code, (where you can't afford the triple quote - """ bla """ style due to the \n's, that is)
I would just call it a string constant syntax, not concatenation.
In Python that only works for string literals so it's always obvious what's going to happen
+1250  A:

In C, arrays can be indexed like so:

a[10]


which is very common.

However, the lesser known form (which really does work!) is:

10[a]


which means the same as the above.

Oh, my. this is my very first to see this feature. It's really a WTF to me.
that's because a[10] means *(a+10) ... and 10[a] means *(10+a) :)
Don't forget "Hello World"[i]. Or i["Hello World"]
i think that this was 19 upvotes a minute ago
I've been waiting a long time to find a question where *this* little bit of trivia would come in handy :)
For an in depth look at this: http://stackoverflow.com/questions/381542/in-c-arrays-why-is-this-true-a5-5a
Consider debugging code like this: printf("%c", [!!flag]"FT").
Loadmaster: [!!flag]"FT" is invalid syntax.
I'm pretty sure that's supposed to be: "FT"[!!flag] -- which actually isn't so bad if you're used to C's treatment of strings as aarrays and booleans as integers. It's not nearly as bad as C++ code that uses badly designed operator overloading.
@Edan Moar: it is invaluable if you want to compete in the obfuscated C contest (http://www.ioccc.org/) ;)
One should notice, that this only works as expected if sizeof(a[0])==1. So it works fine for char, but meaning differs for wchar_t.
@frunsi: It *always* works as expected. Pointer addition is not the same as simple integer addition on addresses. It is commutative *no matter* what size is the type in question.
It is even useful. Actual code extract (compacted to fit in comment): do { tmp = val; val /= 10; *p++ = "9876543210123456789"[9+tmp-10*val]; } while(val); ... - guess what its doing?
frunsi: That code snippet is not using the number[array] format in this answer: indexing a string like that is not strange at all.
roger: you're right
@Martinho Fernandes: I don't understand how this can work with larger datatypes. Suppose it's a short[]. Then a[10] = *(a+2*10) right? How would the compiler know that 10[a] is the same thing? a is just a big number, and 10 is just some un/misallocated memory location.(Just thinking about this made me feel smarter. Imagine that. 10 years after I did anything in C.)
@mcv - a[10] is the same as "* (a+10)", where the expression "a+10" is pointer arithmetic (and since a is a short, in your example, a + 10 means 'start at a's address, and move 10 shorts, i.e. 20 bytes'). The expression 10[a] is interepreted as "* (10+a)", where "10+a" is *also* pointer arithmetic, and is treated exactly the same way.
Guys, guys! Astonishingly, this crazy syntax can be, in fact, useful... http://stackoverflow.com/questions/469696/what-is-your-most-useful-c-c-utility/470221#470221
I don't see it as a feature - so much as exposing the core of what C is about. Its all about pointers and getting to the memory directly with as little indirection as possible. Kind of beautiful, really.
I've known this one for years. This was in the original C FAQ that was a dos program similar to man. You can probably still find it on x2ftp
A:

I would definitely give Perl the honor of having multiple horrible examples:

if(!$#var)  or if($mystring =~ m/(\d+)/) {

is second one regex? If so i cannot blame Perl. Regex looks weird at first.
how about $_   Sorry guys but all the "hated" features of perl turn out to be some of the most useful especially at 3am when you need a 3 line program to get everything up and running again. Except for regex syntax which predates perl itself you can (and should!) code all the perl shortcuts in longer and more explicit syntax to make it easier to read. -1 this answer is complaining about a language's syntax rather than any actual behavior. Forcing perl to calculate$#var's lvalue behavior can decrease performance unnecessarily. That should probably be "unless(@var)".
I find scalar(@var) to be much clearer.
What's wrong with that second one? If the string matches the pattern, do the following. What's the big deal?
yeah i dont see whats that wrong with the second one either
I don't see what's wrong with _either_ example other than @Anonymous' point about the un-perl-ness (which can hardly be a language wtf).
+12  A:

ActionScript 3:

When an object is used by its interface, the compiler doesn't recognize the methods inherited from Object, hence:

IInterface interface = getInterface();
interface.toString();


gives a compilation error. The workaround is casting to Object

Object(interface).toString();


PHP:

. and + operators. It has its reasonable explanation, but still "a" + "5" = 5 seems awkward.

Java (and any implementation of IEEE754):

System.out.println(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1);


Outputs 0.9999999999999999

It also means PHP has to use -> for qualifying objects instead of the prettier ..
It's great that PHP didn't do what Javascript did with overloading the + operator for both string concatenation as well as addition. In PHP, if you see + you know you're talking about adding numbers. *...(unless you've got arrays...)*
The first one isn't a WTF - it's a gotcha that catches most people sooner or later regarding the finite-precision floating point representation on computers.
well, the first time you see it, it's definitely a wtf :)
And it's not a Java WTF, it's WTF for any correct(!) implementation of IEEE754.
But 1 equals 0.999…. See http://en.wikipedia.org/wiki/0.999...
@Gumbo: sure, but 0.9999999999999999 does not equal 0.999... nor 1. IEEE754 values do not have infinite precision
C# just gives me a 1 :)
That's because in C# the default type for a number with a floating point is Double. Having 0.1f instead of 0.1 would give the same result.
@nickf no, overloading is perfectly fine. Allowing "addition" with the operands being strings, that's just 100% wrong. If you convert "a" to an int, you should get an exception. And not silently 0.
Correction to my previous comment: executing Debug.WriteLine(0.1f + 0.1f + 0.1f ...) will print 1.0 because the compiler converts that expression to a constant (and when calculating it, it must be using a double). But if you use a loop to add 0.1f ten times, you will get 0.999999...
@cdmckay actually 'a'.'5'.'...' looks pretty in my editor because of the markup colors... -> gets so annoying because it *appears* similar to HTML tags. Which is why :: seems to work better for that.
+155  A:

Algol pass by name (illustrated using C syntax):

int a[3] = { 1, 2, 3 };
int i = 1;

void f(int j)
{
int k;
k = j;  // k = 2
i = 0;
k = j;  // k = 1 (!?!)
}

int main()
{
f(a[i]);
}

If you think about it, it actually makes some sort of twisted sense
If I thunk about it, you're right. ;-)
This is the ultimate "pass by reference".
Interesting, what PHP calls a reference is more like a shallow version of an Algol call-by-name than like a pointer in C. It's useful to find out it has an intellectual heritage.
Sometimes I really wish for that feature in Java...
It's possible in Scala though (def f(j : => int))
Nice that you use C for illustrating that - I have always thought that C preprocessor macros are the closest equivalent to "pass by name" that any language that is in wide use has.
So this is something like ... template<typename T> struct by_name { virtual operator T }; void f(by_name<int> j) { ... } int main() { f(struct : by_name<int> { operator int } }); }?
Scopefail.......
Amazing, though I'm wondering how you would implement this feature.
But your thunk accesses the scope from where it is used, which is insane and not at all like a closure.
No, the Algol thunk (not mine!) accesses the scope from where it is defined. So it would have to work like a closure.
The traditional thing to do is to pass the array index as an argument as well, instead of making it a global variable, so you can say x = dotproduct(a[i], b[i], i).
I just died and went to hell.
The problem is that it's not clear that you are passing by reference. In C/C++ syntax it looks like you are passing by value and not reference. This feature is very standard, but one must know that Algol passes by reference in this case I guess?
D version: auto a = [1, 2, 3], i = 1;void f(lazy int j) { writefln(j); /* 2 */ i = 0; writefln(j); /* 1! */}void main() { f(a[i]);}
This is an Algol bug, not a feature, eh?
In Smalltalk you can have similar fun with become:, it swaps any two objects in place, for example true become: false.
This looks kind of like lazy evaluation mixed with imperative programming. :)
This was originally done for things like integration and derivaties. It's indeed poor man's closure. No matter how complex is the expression you pass in, it's reevaluated every time it shows up in the function's text. Think of the fun with side effects! And, if I remember correctly, it was the default method for passing parameters, too. In Algol 68 it was called _proceduring_ and was not default any more, as far as I can recall.
This blew my mind
+206  A:

PHP's handling of numeric values in strings. See this previous answer to a different question for full details but, in short:

## "01a4" != "001a4"

If you have two strings that contain a different number of characters, they can’t be considered equal. The leading zeros are important because these are strings not numbers.

## "01e4" == "001e4"

PHP doesn’t like strings. It’s looking for any excuse it can find to treat your values as numbers. Change the hexadecimal characters in those strings slightly and suddenly PHP decides that these aren’t strings any more, they are numbers in scientific notation (PHP doesn’t care that you used quotes) and they are equivalent because leading zeros are ignored for numbers. To reinforce this point you will find that PHP also evaluates "01e4" == "10000" as true because these are numbers with equivalent values. This is documented behaviour, it’s just not very sensible.

Just use === and !==. Which should be used anyway unless a loose type comparison is needed.
Weak typing strikes again!
+1 ... WTF? Good to know this.
I always knew PHP was a sin. Up until now I didn't realize it was an unforgivable sin :D
This is heinous! But I'm confused: are you saying that "01a4" != "001a4" in PHP? If so, I don't get it. How can "01e4" == "001e4" if "01a4" != "001a4"? They're all valid hex values.
PHP intval() is recommended for integer comparisons using == when in non-integer variable form.
They should tech people to use === in any programming book or tutorial. Added note: On a badly written PHP app I was able to supply as my password anything that was parsed as the same number.
I've hit issues in PHP where I used a very large number (a Facebook API key) and didn't quote it when declaring it; PHP silently converted it to floating point in scientific notation when I displayed it and screwed up the API call.
How come PHP is not first in the wtf list?
+1 for using 1a4 :P
I knew the was a reason I distruted weakly typed languages. If a well designed langauge there should be no need for abominations like === and !==. As string is a string. An number is number. If I want to convert one to the other **I** will SAY SO
+8  A:

In C or C++ you can have a lot of fun with Macros. Such as

#define FOO(a,b) (a+b)/(1-a)


if FOO(bar++,4) is passed in it'll increment a twice.

or #define false true
#define while if (who needs loops?) #define void int ("Why is the compiler complaining about no explicit return from my void functions?") #define main(argv, argc) (main)(argc, argv) (switch argv and argc for no apparent reason)
While there are dumb things you can do with #define, there ARE perfectly valid reasons for defining it the way it was defined. As opposed to some of the other entries here...
I agree with Brian, but maybe a warning indicating that you're redefining keywords wouldn't hurt anyone...
I've seen someone on stackoverflow mention #define private public.
@Brian, yes there are very smart things you can do with define but they asked for strange things. Being able to #define void int is quite odd.
This is in the Unix Haters Handbook.
#define NULL 42
#define InterlockedIncrement(x) (x)++http://stackoverflow.com/questions/652788/what-is-the-worst-real-world-macros-pre-processor-abuse-youve-ever-come-across
I've heard that this is actually undefined because having the decrement/increment operator(s) occur more than once in a statement apparently isn't defined. Unconfirmed.
@bamccaig: You're absolutely right.
+27  A:

Not so much a weird feature, but one that's really irritating from a type-safety point of view: array covariance in C#.

class Foo { }
class Bar : Foo { }
class Baz : Foo { }

Foo[] foo = new Bar[1];
foo[0] = new Baz(); // Oh snap!


This was inherited (pun intentional) from Java, I believe.

I'm not sure I understand the problem here...
Assigning an instance of Baz to foo will result in a runtime error, since foo is actually an array of Bar, from which Baz does not derive.This means that if – for example – you have a method that takes an array of Foo, you can't be sure whether you'll actually be able to modify it without causing an exception.
Well to be fair, when you say 'Foo[] foo =', you tell the compiler that foo is an array containing Foo objects... Why should it complain when you add a foo object? It seems like this is rational behavior to me.
The point isn't that it should prevent me from adding new Baz() to foo; rather, it shouldn't have let me coerce the array into type Foo[] in the first place. An array of Foo makes two guarantees: 1) that any element retrieved from it will have type Foo, and 2) that any object of type Foo may be assigned to the array. This obviously isn't the case if the underlying type of the array is actually Bar.
Eric Lippert wrote a good series of articles on type variance, the second of which illustrates the problems with array covariance:http://blogs.msdn.com/ericlippert/archive/2007/10/17/covariance-and-contravariance-in-c-part-two-array-covariance.aspx
This *is* the case. This is the **whole point on inheritance and polymorphism**. You do something similar every time you use an interface!
In Programming Scala, this behaviour is talked about on page 391: "When asked [why Java has covariant arrays], James Gosling, the principal inventor [of Java], answered that they wanted to have a simple means to treat arrays generically. For instance, they wanted to be able to write a method to sort all elements of an array, using a signature like the following that takes an array of Object: void sort(Object[] a, Comparator cmp) { ... }. Covariance of arrays was needed so that arrays of arbitrary reference types could be passed to this sort method."
@Kobi: I don't follow. Bar[] is not a subtype of Foo[], so what do inheritance and polymorphism have to do with it? The reason that this kind of type variance shouldn't be allowed is that an array allows both read and write operations on its underlying type. A read-only type may be type covariant, while a write-only type may be type contravariant, but a read/write type may not be type variant at all.
@cdmckay: This could easily have been achieved by way of generics. I realize that this may have been before they were added to Java, but it's still an incorrect form of type variance (and it's possible to achieve this in C# without array covariance or generics by using the Array type).
@Inquisitor: Oh I know, I was just giving some context as to why Java has covariant arrays.
@Inquisitor: A nit-pick here: Java doesn't have generics. Java has templates, which are much less powerful than generics. See C# for a good example of real generics implemented in a C-like syntax.
No, Java does not have templates. Templates generate new code for every type that uses the template. C++ templates do this, Java generics do not. Java generics are more similar to C# generics; the difference is that C# retains information about type parameters in the bytecode whereas Java discards this information after using it for type-checking at compile time.
This behaviour is totally intended.you should be able to assign an array of bar to an array of foo as they are the same base type. However Baz and Foo are on different branches of the tree so you cant instantiate an element of Bar as a BAz ... you could add an element of baz to an array of foo though.
A:

Weak typing, in general.

C:

printf("%c\n", 'a' + 3);


PHP:

echo 5 + "3";


And far too many other languages.

-1 for begging to start a flame-war -- this is to highly debated to be called "strange"
In C it is not weird for me. It would be if '3' + 3 was equal to 6. But you are right about PHP.
In C any letter in single quotes giving us ascii number, if you know this, then 'a' + 3 is not "WTF", also as a['b'], and ('d' - 'a') / 4..
-1 for incorrectly stating that the C example is weak typing. In C, the constants 'a' and 3 are both ints with values of 97 and 3, respectively, and adding them produces an int of 100, which is passed to printf() for the argument %c (which takes an argument of type char which int is easily convertible to) which prints "d" (ASCII value 100). Any confusion is from a misunderstanding of the C language. If "a" + 3 worked that way in C, it would be a valid complaint about typing, but that does something totally different.
PHP is a stateless language designed for the web, and all variables are passed from the browser as strings, which is why it makes sense for the language to handle a lot of the type-casting for you.
@jcasso: Actually '3' + 3 is equal to '6'.
@Chris Lutz: printf() is a variadic function, which means that nothing is passed as a char or a short or a float. This means that 'a' is an int, 3 is an int, 'a' + 3 is an int, and it's passed as an int to where %c expects an int and prints it out as a character value. There are no type conversions whatsoever in that example.
In C, 'a' + 3 may or may not be equal to 'd'.
@David - My bad for not checking the manpage. %c converts an int to unsigned char for printing, but it is passed as an int (depending on your architecture, of course). @Alok - This is true, but from a practical perspective even in EBCDIC 'a' + 3 == 'd' (you only get problems around 'l' and 'm' in EBCDIC).
+138  A:

INTERCAL is probably the best compendium of strangest language features. My personal favourite is the COMEFROM statement which is (almost) the opposite of GOTO.

COMEFROM is roughly the opposite of GOTO in that it can take the execution state from any arbitrary point in code to a COMEFROM statement. The point in code where the state transfer happens is usually given as a parameter to COMEFROM. Whether the transfer happens before or after the instruction at the specified transfer point depends on the language used. Depending on the language used, multiple COMEFROMs referencing the same departure point may be invalid, be non-deterministic, be executed in some sort of defined priority, or even induce parallel or otherwise concurrent execution as seen in Threaded Intercal. A simple example of a "COMEFROM x" statement is a label x (which does not need to be physically located anywhere near its corresponding COMEFROM) that acts as a "trap door". When code execution reaches the label, control gets passed to the statement following the COMEFROM. The effect of this is primarily to make debugging (and understanding the control flow of the program) extremely difficult, since there is no indication near the label that control will mysteriously jump to another point of the program.

Quite evil -- turns labels into GOTOs. Sounds like a language feature hackers would beg for...
Yes it is quite eval -- but when you think about it you will see its just a primitive implimetation of "Aspect Oriented Programing" or "Dependency Injection" expect its not kool and AOP is.
it's like the GOTO for AOP...
Ok, but INTERCAL is supposed to be funny - this is not really a surprising "gotcha". INTERCAL compiler can actually refuse to compile the program if you don't use the PLEASE modifier often enough!
Don't forget that defining multiple COME FROMs allows multithreading.
@alex: that's just in the Threaded-INTERCAL implementation. It's not part of the INTERCAL spec. (I can't help but laugh when I say "INTERCAL spec")
@Martinho The mere thought of "Threaded-INTERCAL" gives me chills down my spine. Scary!
Sounds like AOP :)
What amazes me most is that in system requirement analysis in the "World of Commercial T. I." , COMEFROMs are actually used in text files describing Use Cases. (seriously: some analysts here delayed a corporate wide migration to OpenOffice instead of MS's Office because the former could not properly reference a "comefrom" with the required granularity in a link)
Groo: It's worse. Use PLEASE too frequently and it refuses to compile your program because you're grovelling (C-INTERCAL requires between 33% and 66% of statements to have PLEASE modifiers).
COMEFROM statement considered harmful
But the real beauty of this is that you can have *multiple* statements that come from the same line... Yup, intercal has multi-threading!
Python has comefrom too! http://entrian.com/goto/ :)
@Groo: Also, too much pleasantry makes the compiler suspicious of your intentions. ;)
Is it just me, or does this actually sound a lot like plain ol' events in .NET?
+88  A:

I would say the whole whitespace thing of Python is my greatest WTF feature. True, you more-or-less get used to it after a while and modern editors make it easy to deal with, but even after mostly full time python development for the past year I'm still convinced it was a Bad Idea. I've read all the reasoning behind it but honestly, it gets in the way of my productivity. Not by much, but it's still a burr under the saddle.

edit: judging by the comments, some people seem to think I don't like to indent my code. That is an incorrect assessment. I've always indented my code no matter what the language and whether I'm forced to or not. What I don't like is that it is the indentation that defines what block a line of code is in. I prefer explicit delimiters for that. Among other reasons, I find explicit delimiters makes it easier to cut and paste code.

For example, if I have a block indented 4 spaces and paste it at the end of a block that is indented 8 spaces, my editor (all editors?) have no idea if the pasted code belongs to the 8-space block or the outer block. OTOH, if I have explicit delimiters it's obvious which block the code belongs to and how it should be (re-)indented -- it does so by intelligently looking for block delimiters.

edit 2: some people who provide comments seem to think this is a feature I hate or that I think makes python a poor language. Again, not true. While I don't like it all that much, that's beside the point. The question is about the strangest language feature, and I think this is strange, by virtue of it being something very, very few (but >0) languages use.

if it gets in the way of your productivity then your non-python code can't be very readable...
What language did you use before Python? How were you able to work with other people and not indent that language? How could anyone put up with non-indented code in *any* language? Did you work in a room full of geniuses who didn't need visual cues in the source code?
+1 Couldn't agree more, if my editor (Emacs) can't indent my code based on something distinct (like braces/begin, end/you name it) automatically, it's seriously silly. Pretty much any refactoring you'd do on a "bigger" function can be a really bad experience.
@S.Lott: Of course he did, he's from the future where all programming is done via brain-machine interface
Did he ever say that he does not like to indent at all? But being forced to at all prices, and having to deal with strange space-vs-tab issues may be painful. (I hope I didn't tell rubbish, because I never really did Python)
You're the first person I've seen claim that it was still a "problem" even after working with it for any extended period of time.
All the places I have worked, none have used Python. **BUT** consistent was still required, not by the language, but by the people on the dev team. As for 'spaces vs tabs'... this is something that you solve in about 2 seconds with a simple editor command.
Here's the deal - with any other language, I can highlight a block of code and have it indented properly by any editor.But because whitespace IS by definition the proper indenting, you lose that ability in Python. So it's harder to move code around or refactor things. And for the person who claims the OP is the "first person to claim it was a problem", well I had to maintain some python code for a while and I will now use any language over python for this very reason.
Really? I like this feature in Python because it forces you to make your code readable. I don't see how that would affect productivity at all; in fact, I'd argue that Python's method is more productive because the braces don't get in your way, and they don't add to visual clutter. The only problem I could see is with editors that mess up the "spaces vs tabs" thing, but I don't have that problem because my editor handles it nicely.
It does get in hte way of productivity!!There is not way for an editor to work out what the indentation of pasted code should be, vi's "%" command does not work any more, and if you make a mistake in indentation there is no "{" or similar which might highlight this mistake to anyone reading the code on complex statements which go over more than one screen its a pig to match the end of the block with the matching 'if', 'for' or whatever.Still its a small price to pay for the most elegant programming syntax yet devised.
@Kendall: Emacs indents Python alright.
Another thing is that it means that every user of the language must use the same format, which is IMHO a good thing.
@RCIX: that sounds good in theory. In practice people are still free to choose the amount of indentation to use so you still have to rely on standards within a group. Just within the last month I had to re-indent a bunch of code checked in by a new team member, so Python is really no better nor worse than any other language in this regard.
There's always problems like that when you copy/paste code with a different format. I've copied code in C++ with different indentation and you end up correcting it, just for having a consistent style, which is always useful.Of course, the indentation can be a little messy sometimes, but, to me,it's one of the BEST ideas of Python. I love that feature, and yes, it forces you to use ALWAYS 4 spaces to indent, which it's not bad at all...
@Khelben: ALWAYS 4 spaces? Are you sure?... The difference with C++ (or any other bracy language) is that *you* don't need to correct things. You can ask the editor to do it for you.
I don't mind the whitespace in Python. The WTF is that it's not enforced consistently. You can mix indent levels and tabs, so long as they're consistent with their siblings. So the first indent level can be one space, and the second can be two TABs, and this is not a syntax error.
"if python's mode of defining blocks with whitespace is so superior, why is it virtually the only language past or present to do it?" -> Other examples: boo (well, it's based on the python syntax), Haskell.
Let me get this straight: You rearrange code blocks so often that a few keystrokes to realign them is a drag on your productivity.
Indented block is one of my most favourite features of Python (and The Layout, correspondigly, of Haskell). Yes, it makes copy-pasting less “productive” and more likely to produce broken code, but it makes _reading_ of written code easier. And yes, it forces the programmer to layout his code manually. Think of typeset books (Python) vs text markup (C-like). BTW, braces are a pain to enter with Italian keyboard layout... (I don't use it normally, but when I have to, it's a pain).
<blockquote>but honestly, it gets in the way of my productivity</blockquote>How so ? [Begin Block : Tab vs {-Enter-Tab], [End Block : Backspace vs }-Enter], [Find End of Block : Visually vs Goto Block Begin + Some keystroke]
Wow, this is the first argument against significant whitespace in Python that makes sense to me. I've run into the "I've moved this block of code and now have to manually fix the indent" problem many, many times.
@Martinho don't forget F#. Note that in both Haskell and F#, the whitespace-as-syntax is optional syntax sugar; one is perfectly free to use the more cumbersome desugared syntax with braces and semicolons.
If you're using Vim, look up the ]p and ]P commands, which help paste code into new locations while automatically using the correct indent.
@Greg: how does it know what the correct indent is? If you paste between two blocks with differing indent which one does it choose? It can't possibly know.
@Bryan: Have a look at the docs, or try it. Vim adjusts the indent of the pasted block so that the first line of the paste aligns with the line the cursor is on. The difference between ]p and ]P is whether the pasted text is inserted below or above the current line.
I wonder how many folks are unaware of the block indentation feature of many editors. i.e. Highlight a block of text (several lines) and press TAB to push the entire block in, and SHIFT-TAB to move it out. It's "obvious" if you know about it, but until then realignment is a lot of work.
Kendall: Your editor can't do it for you because it's part of the syntax. (I'm not sure how it makes refactoring harder; every editor I've used in the past decade made it stupid-easy to in/dedent.) That's like a Lisp programmer complaining that in C you can't just highlight a block of code and have your editor properly capitalize it -- capitalization is part of the C language, so obviously the editor can't do it for you. But it's not a problem because I can recognize that caps are significant in C so any refactoring must *include* that, just as it does indenting in Python.
Your editor argument has merit, however in my editor of choice (vim) it's only 3 keystrokes to indent it appropriately, also Guido himself mentions in the docs that any piece of code with 8 levels of indentation needs refactoring ;)
Looking at a representative sample of my own code, I think Guido is too generous. I don't have anything past five, and not very many blocks with four levels beyond the left margin.
@Richo: The difference (as already stated tons of times) is that in a language with explicit block delimiters, it's only **0** keystrokes to indent it appropriately.
You can always do:from __future__ import bracesand use braces :)
It's a matter of taste, so why bother ? You don't like it ? Use Ruby, it's as good as Python. I love white spaces, it makes the code simple and elegant. My productivity is much better when I don't have to think about where this "}" is supposed to be aligned. See ? Really a matter of taste.
@e-satis, I actually like ruby better than python (and maybe groovy better than ruby) but at my job we use python. I don't understand your comment though. Remember, the question isn't "what do you hate about a language" but what was weird, surprising, or WTF. I think it's safe to say that since python is one of only a very, very small handful of languages that use whatspace in this way, it meets the definition of "surprising or weird". There are a lot of other things about python that outweigh this feature. Python is a fine language, but it's use of whitespace is IMO, "weird, strange or WTF".
I see both sides: for one, Emacs' python-mode has the ctrl-c > for indenting (one level, prefix for more), and ctrl-c < for dedenting the region (and a pasted block is the current region). But you can't just mark-whole-buffer and then indent-region.
Another language that used whitespace was Occam.
-1, who upvoted this?
@presario don't you believe others can have opinions that differ from your own?
-1: 'Strangest' is a long shot from something like this.
The problem is that editors aren't smart enough yet. I still think whitespace indentation is one of pythons greatest features.
What's scary to me is how many programmers find copy/paste essential (and how many do it vs. writing a throw-away function).
@xcramps: copy/paste is essential for refactoring. When I move a block of code out of or into a function or class definition I use copy/paste. Sometimes the move requires that the level of indentation changes. In my experience, having explicit block delimiters makes that easier.
What I find surprising is the number of people saying they like Python's indenting misfeature because it enforces the nice indenting based on structure. As if, when they write in C or other languages, they don't bother to indent their code. I've never seen a professionally written C program that did not use proper indentation. This Python thing fixes a problem that doesn't exist in the real World. And where you do see badly formatted code, your modern text editor has a function to beautify it at the touch of a button.
Maybe I haven't studied this well enough, but I also find that docstrings seem to be inconsistent with python indentation.
@Kendall “in Python I have to THINK about what the right placement is” – I hope you actually think about the placement in *any* language.. And then it's not a problem at all to realize what indentation level you need..
@poke - why SHOULD I think about placement? Why should I have to bother? I know it's in a block, so why should I care where I type or copy the code - when with a single keystroke all of it is formatted correctly? With whitespace-based block definition, you are just adding busywork to the process of coding and increasing the chance that code goes in the wrong block.
+1 That's exactly the reason why I use Perl instead of Python if I need it. If you need indentation to be forced upon you, you're too lazy.
+1 this is totally true. While I agree that using whitespace reduces the noise and might help the readability, it has caused me headaches lots of times. Since code is not just prose text, I believe it is better to use explicit delimiters for structuring.
+845  A:

In JavaScript:

 '5' + 3 gives '53'


Whereas

 '5' - 3 gives 2

I remember when I first started using javascript using this sort of technique to add numbers in strings: "111" - -"222" gives 333 whereas "111" + "222" gives "111222".
+ for string concatenation is horrible
damn that's really a wtf. +1
+ for concat isn't the problem. Weak typing is.
@FogleBird Neither one is really the problem. It's just the **combination** of the two with inconsistent coercion rules.
So basically, + is concat when a string is involved. Why can't they code something like '123456' - 456 = '123'? That would be interesting.
It's weird, but it does make sense. You trying to add a number to a string, so it goes with concatenation. In the second, you cannot subtract a number from a string, so it just casts the string to a number.
That's one reason Perl uses completely different operators for addition (+) and concatenation (.).
@Jimmie LinWould that be a decatenation?
I'm not seeing the sense. None of my computer science theory courses or books used "+" to mean concatenation. Where did that come from, anyway?
If you think about what concatenation actually means, it makes perfect sense. When you concatenate "abc" and "def", you're adding "def" to the end of "abc". It isn't mathematical addition, but logically it's similar. Of course, that doesn't mean that it's a good idea to use + for concatenation.
@Eric: I don't have a problem with + for concat. It's just a symbol. (It's how it behaves with mixed types I don't like). But I find string concatenation a very different operation from mathematical addition, beginning with the fact it's not commutative.
So... in JavaScript, '5' is 27.5 and 3 is 25.5, right? :P
Eric: Nope, still not making "perfect sense" to me. I thought about "add" and "append" and "concatenate", and they're all different words with subtilely different meanings, so it makes sense to me that they'd be different programming language functions. In other languages which use different names, I've never once wished they used the same name, and I still think that there's probably a reason none of my books or profs ever used "+" for concatenation.
This is exactly why I hate implicit string -> number conversion, and any language that allows it. VB.Net will allow this as well, iirc
There's no problem with implicit string -> number conversion because of the fact that it was a *really* poor choice to not have a dedicated concatenation operator. If that was fixed then it wouldn't be bad.
In mathematics + is not used for non-commutative operators (although I'm sure someone will give a counter-example). Even as a monoid(?) I'd prefer not to use * as it would cause the same confusion.
WTF?!?!?!?!?!?!
@Tom Hawtin - tackline: The operator * may be non-commutative in math. In matrix multiplication, A*B may be possible and B*A impossible, for instance. I can't think of any examples for +, but I'm pretty sure there will be.
+ for concatenation isn't the issue, Python's implementation works great. It just refuses to add int and str without conversion. Javascript should throw an exception in this case.
Weak typing isn't really the problem, but Javascript's strange implementation of it
WTF... isn't '5' string in the two ways??!!
That tripped me up so bad when I was first learning javascript. The inconsistent behavior made the bug extremely hard to find, especially since I didn't have a line-by-line debugger where I could watch variable values.
So you have to remember that most variables in JavaScript are converted into strings in a heartbeat. To convert to numbers, use expressions like x - 0.
"foo" + + "bar" => "fooNaN"
What's worse... 'a'+2+3+5+7 is 'a2347'. Now tell me what 'a'+2+3-5+7 will be. Wisest syntax lawyers get baffled.
@SF: alert('a'+2+3-5+7). You need to meet some wiser language lawyers.
Neither + for concat nor weak typing is the problem. Programmers who are unaware of the language semantics are the problem. I mean: If you think it's a good idea to subtract an int form a string, it's all your own fault. And if you're even not aware what type your variables belong to -- so much the worse.
@TM: Also not the combination is the problem. The problem is automatic casting or allowing such operations on objects of different types.
At first it sounds like a big wtf, but it's easy to memorize and BigBeagle's comment explains it well.
@tlrobinson lol
Weak typing can hardly be the problem, as JavaScript is not weakly typed. It is strongly typed: there is never any doubt about what will happen according to the language definition. It happens to be dynamically typed, but that doesn't make it weak. The exact opposite would be C, which is weakly statically-typed: types can be declared at compile time, but the declarations are allowed to be wrong (due to casting) and so some programs have undefined behaviour. The problem (if any) is implicit conversion.
+11  A:

In my opinion this should not be allowed in C++:

class A {
public:
virtual string foo(){return "A::foo";}
};

class B : public A {
public:
virtual string foo(){return "B::foo";}
};

int main () {
B* b = new B();
// In my opinion the following should not be allowed
cout << b->A::foo() << endl;  // Will print "A::foo"
}


This may seem right, but this means that you cannot override a method without allowing users of the subclass to call the original method instead of the new one.

Just think about a subclass of a collection where you want to increment the number of elements when adding an element to the collection itself.

A logical solution would be to override the add() method to increase the counter before adding the element, but a user of the new collection could add an element to it using the old method so bypassing your increment and resulting in your elements-counter disagree with the actual number of elements of the collection.

This is not possible in Java.

Here you can see the code in action: http://codepad.org/tVyG4yyv
I think who ever downvoted this two times should give some reasons why he did - I can't see anything wrong.
Using this kind of syntax is a code-smell in itself :\
Just more examples of trying to make object-orientation do things it's not supposed to be doing. The syntax makes it very clear that you are purposely calling the *base* function. If you really don't want that to happen, the two classes are most likely not Liskov-Substitutable, and you should be using protected or private inheritance which disallows this construction, or even aggregating the "A" inside a completely new object so that A is not available from the outside.
@MadKeithV I don't agree with you :) I think that in fact the two classes should be obviously subtypes by the point of view of OOP and so substitutable.You're right that making an Adapter (by aggregating A) or with implementation-inheritance you have control over the situation, but this way you loose the useful subtype relation and this only because of this, in my opinion wrong, behavior of C++.In Java or other OOP languages this problem does not exist because you can call, from the outside, only the newest method.
You seem to be taking an attitude opposite Stroustrup's. Stroustrup didn't worry about features having the potential for misuse, provided they were sufficiently useful. C++ is full of abusable features.
@David You are right. Every choice made by language designers make sense from their point of view: here I'm just saying that in this specific case I have a different opinion and that I don't agree with the language designer.I really think that this is violation of the way it was intended to work in general OOP and the fact that Stroustrup decided to allow this make me feel a bit unconfortable.Don't you have fear of the fact a user of your class can call a LESS specific version of a method you've overrided? Because in some cases I do :)
mentioned http://stackoverflow.com/questions/1995113/strangest-language-feature/1996486#1996486
@EvanCarroll No: this one is a different problem ;)
@Andrea Zilio: Personally, it doesn't bother me, because to get this weird behavior the programmer had to write something obviously weird. Anybody can write bad code in any language; the benefits languages provide in this case are to make writing better code easier and to make worse code more obvious.
I agree with David, the C++ design philosophy is not to restrict what the programmer can do just because their decisions might be dangerous or wrong. While I personally wouldn't follow this philosophy myself and am not a fan of C++, the language's success over the years certain vindicates this as useful way of doing things, if perhaps not the ideal way.
There's a simple solution for this: make foo() protected in the base class (and rename it foo_core() or something). Then define a public non-virtual foo() in the base class that calls the protected virtual one.
I Agree with Nate C-K...
munificent is right -- you should try to avoid making virtual methods public. This makes it easier for the base class to enforce constraints on derived classes (e.g. via the Template Method pattern). Guru Herb Sutter explains: http://www.gotw.ca/publications/mill18.htm
I don't think this is a strange language feature.
+109  A:

Don't know if it can be considered a language feature, but, in C++ almost any compiler error related to templates delivers a fair amount of WTF to many C++ programmers around the world on daily basis :)

Depends on the compiler. MSVC++ is much worse in this regard compared to GCC.
That's okay, most code related to templates already creates plenty of WTFs around the world.
To me, templates is one of the 'features' of C++ to get directly ignored...
@Khelben: However, Matt Greer's example is about something like cout << "Hello, World!", which many people don't realize involves templates. (Using a string instead of a quoted string would have been even more verbose.)
@Khelben templates are about the only reason to use C++ rather than an object oriented language or C + GObject
I once had a template-related compiler error that was five lines, the shortest of which was seventeen thousand characters (the classic 'no match for x' error, in a deeply templated program). That's the WTF, not the feature in the first place, templates are wonderful.
Even if there's no error, try finding which functions take the longest with your profiler. Oh look, it's std::vector<std::pair<int, std::complex>, std::allocator<std::pair<int, std::complex> > >::vector< std::vector<std::pair<int, std::complex>, std::allocator<std::pair<int, std::complex> > >::iterator>(std::vector<std::pair<int, std::complex>, std::allocator<std::pair<int, std::complex> > >::iterator, std::vector<std::pair<int, std::complex>, std::allocator<std::pair<int, std::complex> > >::iterator, std::allocator<std::pair<int, std::complex> >)
Ouch, it hurts the eyes!
I think this fits here: Check out STLFilt at http://www.bdsoft.com/tools/stlfilt.html to make the output readable.
boost::lambda is excellent for this kind of stuff! :) ... (it's also excellent to write functional-style C++ code with, but that's another topic... ;-P)
@mxp: interesting tool. Isn't it revealing that they call it a "decryptor"? ;-)
Depends on the compiler. clang has fixed it mostly (for example leave away default template parameters and more). And I think GCC is following (or is planning to).
Template error messages are full of meaning, for some **strange** reason some people can't understand 6 whole pages of pure meaning...
+127  A:

Not really a language feature, but an implementation flaw: Some early Fortran compilers implemented constants by using a constant pool. All parameters were passed by reference. If you called a function, e.g.

f(1)


The compiler would pass the address of the constant 1 in the constant pool to the function. If you assigned a value to the parameter in the function, you would change the value (in this case the value of 1) globally in the program. Caused some head scratching.

Ooh. Then 2+2 *can* equal 5 (for very large values of 2 of course!).
um, what value of 2 would make "2+2" == "5"? I don't know any integer value 2 can take on for that to be true.
@Aaron, I'm guesing 2 is defined as a constant, and as such could be sent by reference to a function making the constant 2 be any abritrary value in the actual machine code.
@earlz: I suspect that it would wind up as an integral value, of whatever bit pattern. On the other hand, you could probably set 5 to 4 that way (so 2+2 would equal 5 for small values of 5).
The ultimate monkey-patch!
Maybe we can change the quote to "2+2=5 for very small values of 5". http://www.thinkgeek.com/tshirts-apparel/unisex/generic/60f5/
Excuse me, Alok, but this is early FORTRAN we're talking about. It won't be true that 2 + 2 = 5; that'll be a syntax error. What will be true is 2 + 2 .EQ. 5.
actually 2 + 2 can't equal 5, but 2 + 2 .EQ. 6 would be possible...
@Thomas: 2 + 2 .EQ. 5 is possible. Just read the other comments. Or if you don't want to, just make 5 be 4.
it depends on the value of 5, clearly
Haha, David. Thanks for the correction!
In Haskell the following snippet evaluates to 5: "let 2+2=5 in 2+2" :)
Ahhh, my favorite bug. I spent *days* debugging that one once. I ultimately found it very fascinating to discover the constant 1 had the value zero after a certain point in our program. That was eye opening.
This isn't necessarily strange - in C, arrays are always passed as a reference, which can be really handy!
2 = 100 5 = 200 2 + 2 .EQ. 5. There. 2 + 2 is 5 for very large values of 2.
Almost like pythons shared-mutable-default-args, but global.
Interesting. If C had had a similar history, the old "if (1 == x)" trick (in place of the (IMHO) more readable "if (x == 1)") might never have been created... or would at least have been as bad as the problem it was invented to avoid.
This was true up through FORTRAN 66. Later versions of F77 corrected it. Been There Done That!
A long time ago, a programmer (designing a TRS-80 game, IIRC) did this accidentally, passing 1 as a parameter to a function that passed that parameter to another function which altered the value of 1. He declared a variable I, assigned 1 to it, and passed it in, so nothing untoward changed. This demonstrates one of Murphy's laws: "Constants aren't, and variables don't."
I had been wondering about that question in [The HACKER test](http://www.hungry.com/~jamie/hacker-test.html) "Ever change the value of 4?"
@Alok: How? If x is an integer, shouldn't x+x at least always be an even number? Or can you even make the integer constant 2 point to 2.5?
@Albert, who is to say that 5 is actually 5? If the value of 2 can change, so can the value of 5 (so 5 could be changed to 6 for example)!
+97  A:

For those who don't know, bc is an "arbitrary precision calculator language", and I use it quite often for quick calculations, particularly when the numbers involved are large ($ is the prompt): $ bc -lq
12^345
20774466823273785598434446955827049735727869127052322369317059031795\
19704325276892191015329301807037794598378537132233994613616420526484\
93077727371807711237016056649272805971389591721704273857856298577322\
13812114239610682963085721433938547031679267799296826048444696211521\
30457090778409728703018428147734622401526422774317612081074841839507\
864189781700150115308454681772032


bc has been a standard Unix command for a long time.

Now for the "WTF feature". This is from man bc (emphasis mine):

quit: When the quit statement is read, the bc processor is terminated, regardless of where the quit statement is found. For example, "if (0 == 1) quit" will cause bc to terminate.

halt: The halt statement (an extension) is an executed statement that causes the bc processor to quit only when it is executed. For example, "if (0 == 1) halt" will not cause bc to terminate because the halt is not executed.

I use Haskell for this stuff.
I use irb (15 char limit is dumb)
I've started using Python myself, and google calculator is nice if you're online. But I used to use bc before that, and wanted to write about bc in my post because of the great quotes from the man page.
I like dc myself, but that's because I'm an RPN geek.
@Brian, then you will like: echo '[q]sa[ln0=aln256%Pln256/snlbx]sb3135071790101768542287578439snlbxq'|dc (although you might already know this).
I use irb (Ruby interactive shell). But back in the day, I always reached for dc - like bc, but uses reverse polish. Geektastic !
quit should be renamed to exit, and then this makes sense. I feel like language features were added ad-hoc, and then to keep backward compatibility, names weren't changed.
+9  A:

In earlier version of Visual Basic, functions without a "Return" statement just "Return None", without any kind of compiler warning (or error).

This lead to the most crazy debugging sessions back when I had to deal with this language on a daily basis.

Oh *man* this sucked. I was so glad they pulled that out in later versions of VB.NET. They really should have just created VB.Sharp and left the compatibility argument on the table.
I'd say the return statement that lets you return a value is one of my favorite improvements of VB.NET over VB6. (My #1 favorite is exceptions vs. On Error Goto.)
This is also one of python's features. In a strongly typed language it wouldn't be so bad, and one could actually argue that it's good because it makes things more uniform (all functions have a return value), but with dynamic typing it always causes me headache.
Python is both strongly and dynamically typed. Just sayin'...
+132  A:

In Python:

>>> x=5
>>> 1<x<10
True
>>> 1<x<3
False


Not a WTF, but a useful feature.

I wish every other language has this feature
As with pretty much every cool Python feature, it looks like Guido just ALGOL-ized the syntax of a cool Lisp feature. :-)
this feature also performs better than writing out "1 < x and x < 10"
Feature? Looks like a big fat bug to me.
Geoffrey, it s a feature, and (10 > 5 > 1) != ((10 > 5) > 1) in Python.
Also, it evaluates just once, so (funct_a(5)+5 > b > funct_a(5)) only calls funct_a(5) once.It's a GREAT feature!
I wouldn't call this a strange feature though..
It's not WTF. It saves typing (and evaluation); I think it's up there with Perl 5.10's 'defined-or' operator.
I was proficient in Python before learning much fortran and C, so this led to a subtle WTF in a piece of C code. That *wasn't* easy to spot.
What Khelben says actually *is* surprising, IMHO.
Delphi Prism has this feature too.
@rjh - Perl's // operator is simply amazing.
Simple, but very nice feature - I didn't know about this before. I'll be sure to use it now.
hmmmm, wonder if they'd consider adding this to c++0x
@Grant Peters: if they did, it won't make it to C++0x anymore. C++0x is gone since last week. Now all the cool kids are using C++1x.
@mizipzor: It is unusual because it is different from how most mainstream languages parse expressions, although it does make more sense.
Even better is the lisp version: (< 0 1 2 3 4) => true the < function actually tests if all the arguments are in ascending order.
@Khelben: No, funct_a will be called twice in that example. In b > funct_a(5) > c it will only be called once though, as opposed to b > funct_a(5) and funct_a(5) > c.
@Baffe_Boyois @MatrixFog Sorry guys, you're absolutely right! I think I was drunk or something the day I wrote that. The correct answer is what Baffe Boyois says...
Damn... what's worse, it is perfectly correct syntax in C (and all of its offspring) but yields entirely incorrect results there. ((bool)(1<a)) < 3
+7  A:

The bigest collection (today 1313) of decent and weird programming languages I know, you will find here: http://99-bottles-of-beer.net/ be prepared to see real weird stuff ;-) Everybody should make his one choice

http://esolangs.org/wiki/Main_Page
+1 I love that page!
+187  A:

Perl's many special variables

$.$_
$_# $$[ @_  They're definitely shorter than the equivalent, but if you subscribe the school of thought that you write code for humans rather than trying to impress the computer then it makes reading the code for a non-Perl veteran a lot harder. Read the complete list here The [ variable is the most evil of them all. Would definitely appreciate it if Perl 6 was something I could code in without having to check perldoc perlvar every five seconds. (Though I confess that half the time I check it thinking "I know there's a special variable that can do this for me, I just don't remember which one..." =P ) @Lutz: use English;, but don't blame me if you get strange looks. The problem with use English; is that it affects RegExp performance. I am not making this up. http://perldoc.perl.org/English.html#PERFORMANCE _ is my favorite variable. Having to write foreach(a as v) in php makes my hair hurt. I think the worst ones are [email protected] and @. Both work and I still have no idea what the 2nd one does (the first one is an eval error). I was debugging some code that was supposed to use [email protected] but the original coder wrote @ and it evaded me for hours. @Dave: it's not a problem because of the -no_match_vars option in the page you linked. @Brad: [ is SO evil. The intention behind it is evil, yes, but it also doesn't even work! @Artem: from perlvar "Perl identifiers that begin with digits, control characters, or punctuation characters are exempt from the effects of the package declaration and are always forced to be in package main ; they are also exempt from strict 'vars' errors." So that means @ would be created and assigned to without an error even under stricture. Ugh! Ruby has stuff like this too. Quite annoying. @rjh: re: use English -> but then you would have to use the non-English vars for regex. I felt like the topic of this post was the names of the variables, rather than the function of them so I created a new answer specifically for the function of [: http://stackoverflow.com/questions/1995113/strangest-language-feature/2008240#2008240 +1 for "trying to impress the computer" I hate use English;. I hate mixedCaseCode unconditionally as it is, but ALL_CAPS_CODE is a whole new level of loathing. They're nice for one liners, though. {local /=undef;_=<>} +1 to give you a century of votes :) I am by no means a Perl veteran and I LOVE these special characters. You just have to be aware that Perl has these special characters and know what they mean. It's like learning any new language ... you have to learn the syntax in order to understand how to write and read the code. (Plain) Python doesn't have this <censored>. Guess why I prefer it? ;-) $$ is more evil than Brad's one, I'd never seen that before. So doesn't$[ always have the value 0?
If you subscribed to that school of thought, you wouldn't use Perl!
@Brian: How do you propose to learn the syntax when the official documentation itself states that there are circumstances where the Perl interpreter *heuristically guesses* what a sequence of characters means? E.g. in /$foo[bar]/, is the [bar] part a character class or a subscript to the array @foo? Grep perldata for the terrifying answer. That column of special vars is clearly a man with a hat riding a segway. They HAD to it this way. This is valid PHP...<?$__='([^/]+)@i\',$__,$___';$_=preg_match('@^(?:,)?([^/]+)@i',$__,$___);echo$_;echo $__;print_r($___);?>
By the way, one other slight problem with these variables: They're ungooglable!
@malvim: Luckily you can find everything about these variables from the command line, for eg. perldoc -v $. Also see perldoc perlvar for complete list (also online: http://perldoc.perl.org/perlvar.html) +39 A: I would not dare to claim that XML is a programming language, but isn't it close to our heart? :-) The strangest feature, to my mind, in XML is that the following is a well-formed document: <_....> </_....>  Here is the the lexical definition of NT-Name that allows consecutive dots. What is the reasoning and value of this really? It seems like some joke from the xml designers. If I read the spec right, I could also have <:-D>..</:-D> as tag. Great, I'm going to abuse this immediately! Esko: that won't quite work, because the namespaces spec prevents you from having a colon with no prefix before it :) You will have to put at least one valid start character before the colon.XML does not need the navigation programming languages like Java do (e.g. foo.bar); why they did not restrict the lexical definition further, I don't know. Laziness? Or they just did not care. So by giving a hat *(C)* to the smiley face it should be valid? <o_o>OMG</o_o> is directly valid tho' XMI, the interchange format for UML, uses plenty of dotted names. xcut has it right. Namespaces kill this. +1 for the poetry +1 for obfuscation <_><:>:_>:/:_<:</:></_> It's very far away from my heart! Talvi, isn't XML obfuscated enough as it is... +4 A: In two words: multiple inheritance. It makes no sense, and creates nothing but trouble. Edit - I am referring to MI in C++, not mixins and the like in Java and other languages. how many parents do you have? Personally I like multiple inheritance, as it promotes a mix-in style of programming. Something I always enjoyed, but can't do much anymore as I'm mainly working in .Net :( jk, how many different species do you belong to? Is it MI you hate, or a particular implementation of it? I've seen MI done really well, and I've seen MI done really poorly. No. It's just plain evil. Okay, so what implementations of MI have you worked with? I assure you it works great in certain languages to develop text adventures in, and it's just fine in the Common Lisp Object System. @jk - I have two parents, but nobody was depending on my having a specific eye color. I use C++ and find that it creates too much confusion. When classes derive from MI classes, member order is not guaranteed. Just too many better solutions exist. @cwap: composition @Dykam: I really like composition, I just miss some form of automatic interface delegation in C#... mainly to reduce boilerplate code. To clarify what jk means: What happens if you apply that statement to yourself having stated you have more than one parent? -1! LOL. George Edison, another victim of the mind eating Java marketing machinery. Sorry, but please justify your statement. Why do you think so? Like I said, member order is not guarenteed. Now, this is not necesarily a problem, but a potential pitfall if one is not careful. And as for Java, to say I hate mixins is far from the truth. I think Java has a much better implementation of MI. George Edison: That would depend on HOW multiple inheritance is defined to work. It may not work in YOUR language; but done right, it's pretty sweet. I know. Some languages do, some don't. I should probably fix my question. @jk how many species are you? Parent is a hasa unless you are a mutant @jk I have two parents. I also have many characteristics that neither of them had, and many from one parent that arbitrarily overrode the other parent's genes. Is this how we should model OO inheritance? Shall we leave it down to the whim of the compiler to decide how the inherited members should mutate between generations? Hell, maybe we could even invent a new paradigm driven by natural selection! Since when did Java have mix-in inheritance? Scala, yes. Modern c++ design by Andrei Alexandrescu and you can see that MI has it's uses.I kind of like shallow MI over deep SI. Deep MI witb virtual inheritance is not recommended by your doctor. +15 A: Here's a good bunch of strange C features: http://www.steike.com/code/useless/evil-c/ +4 A: I once wrote a programming language that had a "strfry" operator: "hello world"? # => "wdo rlholle"  Useful, eh? strfry ==> "stir fry" ? If you're cooking! ;) Like C? http://www.gnu.org/s/libc/manual/html_node/strfry.html PHP has a str_shuffle function... @Ken: Yeah, but having it as a unary operator is WAY more useful. PHP even weirder. <?=!(0);?> returns 1 Eh? How is that weird? I mean, it looks like Perl at first, but then you realize what it does, and then it's not weird at all. +52 A: Oracle has a couple of SQL WTF issues. 1. Oracle's treatment of empty strings as null. 2. Treatment of null values in a "<>" comparison. create table wtf (key number primary key, animal varchar2(10)); insert into wtf values (1,'dog'); insert into wtf values (2,''); insert into wtf values (3,'cat'); select * from wtf where animal <> 'cat';  The only row returned is the (1,'dog') row. I *wish* SQL Server treated empty strings as NULLs. After all, what is a practical difference between the two? My DB is full of CHECK (Name <> ''). The problem is that treating NULL as different from '' is also a WTF. Perhaps the solution would be to never have NULL strings but always empty, but I bet that would be a WTF, too. It's probably a problem with no good solution. The practical difference between the two is that '' is a value. NULL is not. ok, what is the definition of 'value'? Andrey Shchekin: What is the meaning of the life? A value is a known quantity, amount, or measured value, numeric or otherwise. For example a "special instructions" field could be '' if there are no special instructions, and NULL if that field has not yet been filled. The string '' should no more be treated as NULL than should the integer 0. Andrey Shchekin, try this: NULLIF(field, ''). It assigns NULL if the value '' is found. It's like a brother to ISNULL(field, '') which assigns a value '' if NULL is found. WHAT!? I am so glad we don't use Oracle. That is frightening. +1 for treating '' as Null, -1 for null values in '<>' comparisons. You can not determine if a 'unknown' value is not equal to an unknown value. "comparisons with Null can never result in either True or False, but always in a third logical result, Unknown" - http://en.wikipedia.org/wiki/Null_(SQL)#Three-valued_logic_.283VL.29 @Mark Roddy: Just use SELECT * FROM wtf WHERE ISNULL(animal, '') <> 'cat', the same way that is done in any RDBMS. @Ben Blank -- Did you #undef NULL or something? _The string '' should no more be treated as NULL than should the integer 0_ I have seen more cases when 0 is logically different from NULL than cases when '' is. Actually, I have yet to see a single business case when '' is a valid value for a nullable string field and is different from null. Even on the language level it makes sense for the empty sequence to be the same as null value. There are cases when these two carry different meaning, but I do not think these cases are good API and good practice. @Andrey: NULL has special properties in SQL. SELECT * FROM t1,t2 WHERE t1.c1=t2.c2 will not match lines where c1 and c2 are NULL, even though they are the same. It means something more like "unknown." If you don't know the age of two persons (p1.age=NULL and p2.age=NULL), it doesn't follow that they have the same age. Oracle is funny about empty strings and NULL values. For some comparisons, an empty string is null. For others, it is not. The thing is very inconsistent.This is one of the things that causes me the most grief when writing things that work on multiple DB's. @niXar well, but what is the actual in-life situation when you do know when value of something is ''? I know NULL has strange comparison rules, but what could be c1 and c2 so that it made sense for two '' to be equal? @Andrey Shchekin: *recursive* mentioned above a use case for differentiating between an empty string and NULL. In any scenario, NULL means no value has been supplied, whereas an empty string is a value of zero length. Just like in many imperative languages, an array reference could be null or a reference to an array of zero elements. This difference can sometimes be important. **If a data member has zero length, then its length and content are known. If it is NULL, its length and content are unknown until it is retrieved/calculated/prompted for/whatever.** @Andrey Shchekin: Real world example: Middle name. NULL - Middle name is unknown. Empty string - Person has no middle name. Where text is concerned, NULL means "we don't know this value yet." The empty string means "we know this doesn't have a value." If you have a list of cars, it's valuable to know which ones don't have license plates and which ones haven't had their license numbers entered yet. It's also valid to assert that two cars whose license numbers you don't know yet don't have the same number on their license plate, but that two cars without license plates do. Back before SQL Server 7, empty strings were stored as a single space so as to avoid this problem. Of course this just changes which two values are confused, but a string containing a single space is much less common compared to NULL. create table wtf (key number primary key, animal varchar2(10)); insert into wtf values (1,'dog'); insert into wtf values (2,''); insert into wtf values (3,'cat'); select * from wtf where animal || 'x' <> 'cat' || 'x'; +23 A: Other weird things: In C++ overriding a virtual method hides all other overloads of that method. In Java this does not happen. This is very annoying. Example: http://codepad.org/uhvl1nJp In C++ if a base class has a public virtual method foo() and a subclass has a private method foo(), this private method overrides the other one! This way you can call what is a private method outside of the class just by casting the subclass object pointer to a superclass object pointer. This shouldn't be possible: it's a violation of encapsulation. The new method should not be treated as an override of the old one. Example: http://codepad.org/LUGSNPdh In PHP you can define functions to accept typed parameters (e.g. objects that are subclasses of a certain interface/class), the annoying thing is that this way you cannot use NULL as the actual parameter value in this case. Example: http://codepad.org/FphVRZ3S Ah yeah! That really annoys me about PHP not allowing null..! Actually, if you provide the type-hinted parameter the default value of null, then it means that the value can be either null or an instance of the specified class. point two is better explained in this same thread: http://stackoverflow.com/questions/1995113/strangest-language-feature/1995315#1995315 @EvanCarroll The other answer you've linked shows another different problem. What's explained here is completely different ;) Re: private foo() overriding public foo(), this is by design and A Good Thing. Otherwise changing access qualifiers could silently change which methods are called. That it can be subverted in the way described is unfortunate, but the lesser of two evils. NULL->eat *should* throw an error! Why is this abnormal? @Talvi Watia, I'm not sure what you mean in this context. NULL in an object means empty, and unknown if undefined. A child element normally should not exist. In the example at http://codepad.org/FphVRZ3S, there is a child element being called from $obj... return $obj->eat(); ... below when you call foo(null);, you should actually instead call foo();, rather foo($var_obj); by creating it first. Inserting NULL as the function parameter just won't work because it doesn't exist (yet).see: http://php.net/manual/en/language.types.object.php *If the value was NULL, the new instance will be empty.*
Regarding PHP: you constrained what type the argument should be (implements Eatable). You gave it a value that does not satisfy the constraint (NULL). What, other than throw an exception do you want it to do in this case?
@Zak I want it to as behave similarly to all the other languages where parameters are constrained to types. For example Java which allow you to pass null values.
@Andrea Zilio - what advantage does that get you? Actually trying to call null->eat() will throw an exception as well, and moves the error farther from the incorrect code (imagine the call to $obj->eat() buried a couple function calls deep). I'm not up to date on PHP, but typed parameters appear to exist to simplify debugging in the event of runtime type errors; allowing arbitrary nulls would reduce its effectiveness for that purpose. @Zak Typed parameters has two advantages in my opinion: by using them you have a form of implicit documentation (the function is more self-explanatory on its usage), moreover the type checking you usually have to do manually becomes automatic.Since there are cases where it is needed to pass null values to certain arguments, making null values not acceptable in combination with typed parameters exclude those functions or methods to the aforementioned benefits that typed parameters usually provide. Allowing null values only when null is set as the default value may be an acceptable trade off. @Andrea Zilio It seems a bit strange to me that PHP, a language known for being very liberal with types is so strict in this situation. It is not, however the only language that won't allow values of arbitrary types to also be null. For example, values can only be null in OCaml, Haskell, F# and Scala using an Option or Maybe type, though it can sneak in through .NET/Java interop in the latter two. It actually seems very strange to me that languages with static typing would allow nulls without an explicit declaration, but I'm getting off-topic now. @Zak I agree that an explicit declaration to allow null values would be great even in Java, c++ or other languages... PHP included :) +83 A: My biggest most hated feature is any configuration file syntax which includes conditional logic. This sort of thing is rife in the Java world (Ant, Maven etc. you know who you are!). You just end up programming in a c**p language, with limited debugging and limited editor support. If you need logic in your configuration the "Pythonic" approach of coding the config in a real language is much much better. Amen........... What is this "Pythonic approach" you speak of? Is it writing the config file in python and doing "import MyConfigFile" ? phkahler -- The usual way is to "eval" the config file. Tcl re-invented that long before Python was born and Lisp invented it before that. So let's not call it Pythonic, let's call it Emacs-ish. Let's just call it Right. AMEN. If your configuration or build language is turing complete, you're doing it wrong. I'm looking at you CMake / autotools. Rake, SBT FTW!!! This is exactly what Lua was designed for, originally A: either in java (this is an if statement that results in assignment) result = (Boolean condition) ? (if Boolean is true) : (if Boolean is false);  or data Nat = Z|S Nat deriving Show nattoInt Z = 0 nattoInt (S a) = 1 + nattoInt a buildNat 0 = Z buildNat a = S (buildNat (a - 1))  in Haskell... I still don't quite get how this defines the natural numbers (I understand the THEORY perfectly :-p) The first is the trinary if operator. Why is it a strange language feature? I use it in multiple languages a lot. Really? You understand the theory but you don't get a simple inductive definition of the natural numbers? @Dykam: trinary is the language of the neo-fin dolphins. ;-) Oops, meant ternary indeed. @Martinho Fernandes no... I understand the THEORY. I have never paid enough attention to the SYNTAX to understand what each part of the statement means. @Mechko: I thought you knew Haskell. I'm sorry, then. The first line defines Nat as a type isomorphic with the natural numbers: it's the set of values that are either zero (Z) or the successor of a Nat (S Nat). For example 1 would be S Z, 2 S (S Z), etc. The rest is just sugar to be able to print Nat values (deriving Show), and functions that convert actual numbers to Nat and Nat values to actual numbers, using recursion. Oh, by the way, ifs in Haskell work the same way as the *conditional operator* in Java: result = if condition then 42 else 23. +1 A: FORTRAN isn't a really WTF moment but rather it's more a "Why do I need to type all this garbage moment" IF(12 .gt. 11) THEN // Do some magic ENDIF  The ".gt." threw me off when I was playing with the language for a bit until I realized it was the ">" symbol. Oh how I love not being a biology major and having to dabble in this crap day to day I personally like the fact that whitespace is not significant so IF(12.GT.11)THEN and I F ( 1 2 . G T . 1 1 ) T H E N are identical. How many 'C' bugs have been caused by "if (a=1)" ? @D. Shawley - That reminds me of Apple BASIC, where any sequence of letters that matched a keyword was interpreted as that keyword, and spaces were automatically added between tokens. This meant that you could write the entire line of code with no spaces at all and the editor (if I can call the BASIC command line an editor) would format it for you. FORTRAN predates both ASCII and EBCDIC, and was first implemented on a computer with a 6-bit character set. So you couldn't count on < and > being available, hence the need for substitutes.More recent versions of Fortran do support the < and > operators. +1 for using the word dabble. @D.Shawley whats the real advantage, that whitespace is not significant? (there is none) +6 A: Unary operators in INTERCAL (AND, OR and XOR). Since when are AND, OR, XOR unary operators? They need at least two operands which also could be given implicitly, which might be the case in intercal From http://en.wikipedia.org/wiki/INTERCAL#Operators:"Contrary to most other languages, AND, OR, and XOR are unary operators, which work on consecutive bits of their argument; the most significant bit of the result is the operator applied to the most significant and least significant bits of the input, the second-most-significant bit of the result is the operator applied to the most and second-most significant bits... and so on."That said, all of INTERCAL is an intentional WTF. +19 A: As an NHibernate enthusiast, I was thrilled when I heard about become from Smalltalk... e.g. a become: b  it literally changes the a object into b, which makes it trivial to write lazy-initialized proxies because all references to a will now reference b. Pretty neat! I think it qualifies as a strange language feature in that no other language has this ability to my knowledge. Whenever somebody says "no other language has this", I tend to mentally append "... except Common Lisp": http://www.lispworks.com/documentation/HyperSpec/Body/f_chg_cl.htm :-) Wow! As a C# guy, I am baffled by language features like that! Think of the hoops we jump through with dynamic subclassing and whatnot to imitate this behavior :) You can do this in Objective-C, see NSProxy (http://developer.apple.com/mac/library/documentation/cocoa/reference/Foundation/Classes/NSProxy_Class/Reference/Reference.html) One *can* do this in C#, but not without some weird code. An implementation of this behavior would require quite a few hundreds lines of code...(for it to be usable, I mean). @mookid: it's a shame that someone didn't think of features like this 20 years before C# existed... oh wait... @D.Shawley exactly! :) become: for Python: http://wargle.blogspot.com/2009/07/smalltalks-become-in-python.html This worked in 'traditional' smalltalk implementations because everything was doubly indirected through an object table. I do recall reading somewhere that become: on some ST implementations is pretty inefficient. In practice writing a 'generic' proxy mechanism that traps #NotImplemented tends to be more useful for persistence or other mechanisms that require this type of proxy arrangement. Ruby strings have a method #replace that does this, but that's only for strings. +88 A: In JavaScript: 2 == [2] // Even stranger 2 == [[[2]]] // And down-right nutty var a = { "abc" : 1 }; a[[[["abc"]]]] === a["abc"]; // this is also true  Luckily the kind folks at stackoverflow.com explained the whole thing to me: http://stackoverflow.com/questions/1724255/why-does-2-2-in-javascript That’s why you should use === instead. This is useful btw, if you have a function that returns a number and you want to return some additional metadata with it, you can return [number] with some additional fields added. Simple code will never know it is not a real number, and other code can get the required metadata. @Andrey except that if I ever have to maintain code that does what you suggest, I would very soon wish death upon its author. @Andrey, that's a great idea! You can also use Number(n) to do something similar. Unfortunately in both of our solutions === breaks =(. @Breton unfortunately there was once a use for that, when two Array wrappers wanted to pass information between each other while staying within Array contract when only one was applied. +1: I've considered myself a knowledgeable js programmer, and I've never known about this :D This is because [2] is casted to a string, and [[["abc"]]] is casted to a string, too. It still shows poor design, IMO... +29 A: Tri-valued logic of nulls in ANSI SQL. I neither agree nor disagree with this I know someone made a comment but it doesn't show up in the query results. I actually like this 3-valued logic, though it may bite the innocent. Given that SQL has NULLs, 3-VL seems a better idea than failing the statement or making up some incorrect rules. +28 A: Java; making all object instances be mutexes. Well, to be fair, the synchronized statement would be a lot harder to use if that wasn't the case. What is the problem with shipping a mutex class with the JVM that could then be used in every synchronized statement? What would be more difficult then? Maybe he hates multi core/cpu systems. Uh, maybe he hates adding overhead to *every single object you allocate*, or is observing that if you're locking on a per object basis you're almost certainly doing it wrong, or that it could've been accomplished with a generics library instead of burdening the core language syntax or ... Since 1.5 there has been a dedicated class: java.util.concurrent.locks.ReentrantLock but it could have been a separate class from the beginning. Most objects don't need built-in locks, especially immutable objects. @finnw - that makes no difference. Java still allows any object to be used as a mutex, and it is impossible for the JIT to determine that an object can never be used as mutexes. Therefore, the runtime system **must** reserve space on every object for representing the mutex. +92 A: I always wondered why the simplest program was: class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); } }  Whereas it could be: print "Hello World!"  Maybe this is to frighten computer science students in the first place ... In any program you need an entry point ... Actually, the entry point is the first line of the file ... In witch language? What about arguments? What about programs with 2 files? What about functions? In some languages, "Hello World!" is a valid program. @SoMoS: in most dynamic languages such as Python, Ruby, or Perl print "Hello World!" or some minor variation (e.g. puts instead of print) is a valid and complete program. Makes sense if you have used Java for any amount of time. Since every method and variable must be a member of some class in Java, which class would the "improved" one-line statement belong to? Oh yeah forgot to mention, Groovy is a derivative of Java. Both code snippets you posted would work. I haven't used it yet but it looks really cool. @Loadmaster: the implication was that "all code belongs in a class" or "all code belongs in a function" are unnecessary constraints You still forgot the package declaration directive.. @Jimmy: That is how strictly-OOP languages work. This is a piece of crap.. no, OOP is not your average structured/unstructured type of programming. BlueRaja: The code in the answer is not strict OOP. To be strictly OO, you'd need to instantiate an object and call a method to ask it to do something. Just because a language enforces the use of objects, does not mean it is being used for proper object-oriented programming. It is perfectly possible to program procedurally in Java or C#. That's what static methods are for. What the OP is saying is, there should be an implied class and parameterless method, like there is in the Perl example. I love people who think OOP means that everything should be an object. @BlueRaja: in .NET everything all code has to be inside a class/struct methods as well. That doesn't stop boo (a .NET language) from having print "Hello World!" as its hello world program. In JSP (and other languages) a Hello World program can be written as Hello World!. I love you too, Tor! (-1) has nothing to do with. @tor valamo: and I hate people who think every object should be a instance of a class Hey, in APL 'Hello World!' is how the program would go. Must be much easier to use than this "Java" thing! Used to frighten and also to prepare learners for understanding what the particular language is all about: Java->OO, C->low level/procedural, PHP->scripting/create html, etc. Technically, PHP's program is also simply Hello World!. Just as bad sometimes for those picking up a second language are those examples that use a generic print 'Hello World!' and lead you to believe "Oh good, it's exactly the same, this'll be easy." I've seen worse... Like the Win32 C version of "Hello World" :P http://www.paulgriffiths.net/program/c/srcs/winhellosrc.html +140 A: In Java: int[] numbers() { return null; }  Can be written as: int numbers() [] { return null; }  Wow! I wish I could be a fly on the wall when that array syntax was designed! I hate to say this but the WTF one is a consistent extension of the C type system. If C functions were allowed to return arrays then that's what it would look like.The nicer one is a consistency violation to make it more readable. Much like "const char * var" vs "char const * var". @Adam - It actually makes sense when you consider that variable declaration similarly allows both "int stuff[]" and "int[] stuff". They just let the same rules work for method declaration. @tolomea: I might misunderstand what you are trying to say, but your given example of consting either the pointer of the content of the pointer is actually a syntactical difference, not only some kind of violation to make it more readable. @lImbus: Actually, const T* and T const* are equivalent, it's T* const that consts the pointer. Also, I hate sans fonts. I'm embarrassed to admit that I routinely used C style array notation in Java for the first couple of years of Java development, mostly out of muscle memory. I agree, this isn't that strange if you are a C programmer. After all, numbers()[2] is a legal statement. +503 A: JavaScript truth table: '' == '0' //false 0 == '' //true 0 == '0' //true false == 'false' //false false == '0' //true false == undefined //false false == null //false null == undefined //true " \t\r\n" == 0 //true  Source: Doug Crockford Good thing Javascript has the === operator, then. So what purpose does == serve in the eyes of the language designer? Confusing people. @Chris S: I think it's supposed to do what people expect most of the time. This is one of those examples where the Javascript designers where trying to outsmart the programmers. Which is okay to do for a language but they are not constant with doing this type of thing at all so you usually don't expect this kind of thing when it hits you. You are more likely to expect they type of thing that say Java or C would do. If this happened in say something like Ruby you'd be "ah..., okay..., i see...". In Javascript you usually curse. Distinguishing the '==' operator (call it "looks like") from the '===' operator (call it "is identical to") only makes sense in a weakly-typed language. Everything has a defined string representation, for example, which can be handy but is a source of confusion when feeling out syntax for the first time. It'd be nice if == had the meaning of ===, and then there was another operator, something like ~= that allowed type coercion. The worst part is that == isn't even an equivalence relation since it's not reflexive: ''=='0' is false, but 0=='' is true. @Adam your example shows that it is not commutative. If it wasn't reflexive it would mean that 0==0 is false. @Otto Actually, since we're geeking out, his example shows that == is not symmetric. At the moment, I don't seen how commutativity would be specified for a binary relation. Yes, symmetric. But I don't think there is nothing wrong with commutative binary relations. Quick example: for booleans (a != b) != c <=> a != (b != c) (!= is exclusive-or for booleans). @Tom That's associativity; http://en.wikipedia.org/wiki/Commutativity#Symmetry stupid language Another Javascript weirdness:255 == { valueOf:function(){ return “0xFF”; } } // true This is the essential problem of a language designed by a committee and grown bit by bit organically. Consider English. If you think javacsript was designed by committee then you need to go back and read the history again. I love javascript, but this scares me. Fortunately I rarely need to distinguish between my falsy values any way other than if(!value) or if(typeof value == 'undefined'). I will be using === more often from now on. fortunately, I never learned javascript. After this post, not planning to either. @TM I'm not sure that'd be as nice as you think. There's a lot of people that rely on == without realizing it when they do getAttribute() and get a string value but compare against an int value. This language should be renamed to WTFScript, to warn the unwary. @WTFITS: Don't forget about the === operator which does have sane semantics. Other than this and a couple other WTFs, JavaScript is actually a really cool language and definitely worth learning, in my opinion. A: COMEFROM is the weirdest, and probably most useless, language feature I ever saw. Runner-up would be the ternary operator, because it violates rule #1 of optimization. And it does more harm than it solves problems. It does more harm because it makes code less readable. Not really a language feature, but interesting/awesome use of features is Duff's device. Care to explain how the ternary operator is an example of optimization? How's COMEFROM useless (other than it being part of INTERCAL)? Have you seen Threaded-INTERCAL? COMEFROM is used to create threads. I think the ternary operator is pretty nice. In a lot of situations, I think it cleans things up more than it hurts. Because it saves you having to write (a<b) and (b<c) ? ( a<b<c is *a* ternary operator in Python, anyone who writes *the* ternary operator needs to get out more ) There are lots (well, probably not lots, but you get the idea) of ternary operators out there. Any operator that takes three arguments is a ternary operator. The sole ternary operator in C-like languages is the *conditional operator*. COMEFROM is a duplicate, ternary is useful, and duff's device... yeah that's cool. +8 A: Java's access modifiers are a recent WTF to me (as I had to learn a bit of it). Apparently packages are more intimate than class hierarchies. I can't define methods and attributes that are visible to sub-classes but not to other classes in the package. And why would I want to share the insides of a class to other classes? But I can define attributes and methods that are visible to every class inside the package, but not to subclasses outside the package. No matter how hard I think about this, I still can't see the logic. Switch over the access modifiers and make protected act like it works in C++ and keep the package private modifier as it is and it would make sense. Now it doesn't. The logic is pretty obvious to me: not a class, but a package is a unit of maintenance. Hiding members from subclasses effectively reserves the right for the maintainer to remove or rename them without breaking code in subclasses, which is pretty useful if those subclasses are in a different package, and were probably written by completely different people at a completely different time and place. The package maintainers may not even know the subclass exists at all. So only one person can update a package? Considering how large even some Java base packages are, that's a tall order. @Makis: "the maintainer" is the group that's responsible for the package (perhaps it should have been "the maintainers"). Programmers writing subclasses outside this group shouldn't have to worry about package internals. Well, I still don't understand why that is better. Unless we keep packages really small, the problem is the same as in any application development: what you want to use OO for is exactly what this is countering. I always considered this strange too. The only reason I could thought up is the strict order of modifiers:public > protected > package > private @joppux: protected is not strictly > than package. Package allows access from places protected doesn't and vice-versa. +1 A: In retrospect, FORTRAN's computed goto is pretty odd. Wikipedia tells me some BASICs outdo it. Another famous favourite is Algol 60's call by name parameter passing. You sir must be very old. Not as old as FORTRAN though. +8 A: Perl is full of odd but neat features. IF may be used before or after the statement like this: print "Hello World" if$a > 1;
if ($a > 1) { print "Hello World"; }  The same is true for foreach: print "Hello$_!\n" foreach qw(world Dolly nurse);

Ruby allows the same if-structures. It's one of my favourites from that language.
Ruby allows this, but personally I think that consistently putting the "if" first makes code easier to read. It's just as grammatically pleasing, anyway, and you don't have to reorder if you need to add an else.
I actually like the if modifier as it makes the programs more expressive and readable. it lets you place the more important part of the statement (the condition or the action) before the other so it is prominent. Like any feature, it is useful if used judiciously and not abused.
fyi, this is called mutator syntax, and is syntactically awesome: last unless defined $row Good thing I can control myself, or I would start to rant on Perl... odd, sure. Neat? Not by a... okay, I shut up. I miss that 'reverse if' syntax in other languages (c/c++). This syntax is taken from functional programming. Perl tries to be as multi-paradigm as possible, and with this allows for a number of functional programming bits.This is one of them.Having a good deal of experience in functional programming, I don't really see it as a strange feature, but as a nice addition from a different paradigm section. +44 A: Java has a whole freakin book about them. Java Puzzlers I like those kinds of books. +12 A: In Perl you can do: my$test = "Hello World";
substr($test, 0, 5) = "Goodbye"; print$test;


Is this possible in other languages?

Wow, I really want to learn Perl now after reading all these cool tips.
I'm not really sure these were intended to be "tips"...
So what does it print? Goodbye World I assume?
Ruby: test[0,5] = 'Goodbye'. You could roll your own in C++ (and presumably many other languages supporting OOP).
It's possible in VB6: Mid(test, 0, 5) = "Goodbye"
This is called lvalue sub syntax; but for simplicity and great justice, you can also use the three argument version substr() and eliminate the equalities. There are some other wierdnesses though with the core library. my $foo = "foobar"; my @args=(0,3); substr($foo, @args ) = "bar"; what will $foo be here, is it the same ass substr($foo, 0, 3 )... Enjoy!
Ancient (for common internet definitions of) BASIC dialects had this already (and that's pretty much where VB* has it from).
That's quite useful!
The Idea behind is that you do a direct replacement of literals. Think of it as using the backspace or delete key to erase the characters in question, and then fill them with your replacement text.
It's possible in C++, IIRC.
+44  A:

I was taken by surprise that you can change a class's inheritance chain in Perl by modifying its @ISA array.

package Employee;
our @ISA = qw(Person);
# somwhere far far away in a package long ago
@Employee::ISA = qw(Shape);
# Now all Employee objects no longer inherit from 'Person' but from 'Shape'

Argh. That's true? Really weird!! :)
This is also possible in Objective-C too, if I remember correctly. I think KVO in Cocoa/GNUstep works by dynamically subclassing the observed object at runtime to intercept accessor methods. The object's isa / class_pointer is changed to the newly created subclass.
In some respects, it's no odder than changing the index variable inside a for loop. Of course, most languages don't expose the object-oriented aspects quite as much (see the Common Lisp Meta-Object Protocol).
@David: yeah, that's because most languages don't have object-oriented aspects grafted on to the language as an afterthought.
It's called meta-programming. Being able to change classes (by adding parents, methods, etc) as part of the program. Very useful for things like debugging (like adding a Logger parent class to any existing class) and extending.
I'm failing to see what's weird -- it's merely a dynamic language doing what it was told to do. And it enables lots of useful things like Class::MOP.
A:

I've always wondered about the purpose of this function in the Math class of the Java Core library:

static double expm1(double x);  // Returns e^x - 1.

e^x - 1 occurs a bit much in statistics.
Maybe, but you could always use exp(x)-1 instead of expm1(x), it doesnt even have more letters.
You should try using this other cool feature called Javadoc. ;) "Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^x than exp(x)." http://java.sun.com/javase/6/docs/api/java/lang/Math.html#expm1%28double%29
(2^32 - 1) might overflow a 32 bit unsigned with the intermediate value, but a function could be written to do the right thing in this case.
e^x-1 is a function which *very* often turns up in physics and engineering and also very often x is quite small. In that case the obvious Math.exp(x)-1.0 is very imprecise. For small x you get 1.0000000yyyyyy as result of Math.exp(x) with yyy... the desired result. As you see the leading 1.0 does nothing than wasting accuracy.
+42  A:

I love the fact that this sort of thing is fine in JavaScript:

var futureDate = new Date(2010,77,154);


and results in a date 77 months and 154 days from the 0th day of 0th month of 2010 i.e. Nov 1st 2016

Oh my gosh, that's horrible. Before the computer calculates the date for me, I have to calculate the date for it!
I actually like that.
And something's supposed to be wrong here? It's just auto-normalizing dates. While it doesn't really make much sense used this way when the numbers are the result of math it can be useful.
I didn't say something was wrong - I said I loved it...
one program that I once worked on had this "feature" on the timestamp class, but only for hours/minutes/seconds. Days/months/years were confined to their normal ranges. It caused me a lot of grief when people would enter times like "25:70:99" and it would convert them into something on the next day instead of throwing an error like I expected. I agree that this feature can be useful, but it should be opt-in.
Noted. ˙˙˙˙˙˙˙˙
I don't like that.
+91  A:

Perl has lots of strange quirky features, loved by some, hated by others. There are a few I find particularly WTF-ish:

• automatic list flattening, i.e., how (1, 2, (3, 4)) is the same as (1, 2, 3, 4);

• how every operator or function in the language can behave in six different ways depending on the context;

• the more than a hundred operators and their complex precedence rules. Fortunately Mark Lentczner came up with The Periodic Table of the Operators (Perl 6);

• the multiple variable namespaces:

• $var is a scalar named var; • $var[41] is the 42nd element of an array named @var;
• $var{'foo'} is the element with key 'foo' in the hash named %var; I loved the image! You had me at 'Perl' One should point out the operator chart is for Perl 6 while the final point is Perl pre-6. @Richard: You mean Perl 6 will unify the namespaces? Nice. Re: the final point, the sigil used for a variable ($, @, or % etc) indicates what type of value is being returned. Since the 41st element of an array is a scalar value, var[41] is preceded by a $. It was confusing for me at the beginning, but as I understood the reasoning (not that I totally agree with it) I became used to it. I am glad Perl 6 is doing away with this confusion. You're just doing it wrong: (1, 2, [3, 4]). List references are more like the array-type structures that most programmers are used to, I think; just-plain-lists are something many languages don't have, and people are just unsure how they work. They're not really contained, and will mix with each other freely. This is *extraordinarily* handy when combining them all together though. @listABC = (@listA, @listB, @listC) @fennec: There used to be a time (before Perl 5) where auto-flattening lists was all you got, and you had to hack around with typeglobs to create hierarchical structures. Thank god no one else designing languages thought auto-flattening-lists was something other languages should have. What makes your usage example any better than something like @listABC = concat(@listA, @listB, @listC)? @MF it makes it easier to insert some non-list elements in the middle. Happens all the time when constructing command-line or argument lists. (which I'm doing at the moment, and am grateful to Perl for) @JB: I'm not saying the ability to flatten lists is not useful. What I find weird is the *auto* part. I still fail to see what's wrong with concat(@listA,$scalarB, @listC).
"how every operator or function in the language can behave in six different ways depending on the context" -- There are exactly three contexts you should care about, list, scalar, and void (and void you really only care about if you screw something up). It can confuse a beginner at first, but it doesn't take long to get used to and becomes a very powerful feature once you have.
"[...] can behave in six different ways depending on the context" ??What's there beside the 'wantarray' ?
A:

Hi, check out this link for some fun: http://computersight.com/programming/five-strangest-programming-languages/

+105  A:

I'm surprised that no one has mentioned Visual Basic's 7 loop constructs.

For i As Integer = 1 to 10 ... Next
While True ... End While
Do While True ... Loop
Do Until True ... Loop
Do ... Loop While True
Do ... Loop Until True
While True ... Wend


Because sticking an ! in front of your conditional is way too complicated!

You forgot the best: While ... Wend ???? Is that even a word?
wow, I didn't even know about the version without the Do! that's just excessive!
They should have made it "While and Whend", since there are some people who do pronounce the word "while" with the voiceless labialised velar approximant. And of course it lines up nicer, and code that lines up is nice.
Why are you acting so wheird?
Wow. I get kinda nostalgic when I think about it. The first time I ever used VB was back as a 9-year old. I'm from sweden, and wasn't very proficient in english back then. Now, there's a swedish word called "vänd" which basically means "turn back" and that is pronounced similarly to "wend". Because of that I thought it made a lot of sense... :)
Wend? I like the fi (endif) and esac (endcase) from bash et al.
TeX also uses \if and \fi.
Well, while/until do look nice, the same way the Ruby has if/unless. Until Ready is often easier to read and understand than While Not Ready. However N ways of doing each of while/until are indeed an overkill.
! isn't not in VB, it's "Not". Or is it? Yes, not is not !, but Not.
@dreamlax: Bash uses case and esac :). Anyway, I always thought Wend should have been Wendy.
VB also has the iterate-over-a-collection loop For Each foo In foos ... Next foo
Yes, "Wend" is an English word, meaning to go or proceed along some course or way (http://www.google.com/search?q=define%3A+wend). I'm not sure if that helps or hurts.
Pretty sure it was wend since Qbasic...
@mmyers: "wend" in VB and "wend" in English have two very different definitions. VB's "wend" means "repeat" or "go again", but "wend" in English doesn't include any sort of repetition at all. If anything, I think Wend should have been a replacement for goto. On Error Wend FixIt
When all we really ever wanted was For Each...
@dreamlax: +1 for "voiceless labialised velar approximant"
I don't see the problem.
I also thought Wend was short for While End
I remember wend from locomotive basic on the old amstrad cpc days.
BBC Basic had Repeat Until, While Wend and For Next. Wend is BASIC for "End While" from an era when the parser couldn't cope with two-word statements.
in common lisp "loop" is actually a sub language embedded in the lisp language, with constructions like (loop for element in list1 and element2 in list2 collecting (* element element2) until (= element 0))
Feels like I am in bed with a girl... :)
wend they add this to VB?
+102  A:

The many name spaces of C:

typedef int i;

void foo()
{
struct i {i i;} i;
i: i.i = 3;
printf( "%d\n", i.i);
}


Or with characters:

typedef char c;

void foo()
{
struct c {c c;} c;
c: c.c = 'c';
printf( "%c\n", c.c);
}

How the hell does this compile unambiguously!?
+1 Tag identifiers for enums and structs is the most confusing part of C imho. Few people understand why the idiom to typedef a pointer to a structure looks the way it does.
It compiles because every one of those i's has an unambiguous namespace due to context.
@Andrew doesn't make it more readable
@jae: for sure, it's unreadable. But still unambiguous.
+4  A:

To alternate between things in many languages:

boolean b = true;
for(int i = 0; i < 10; i++)
if(b = !b)
print i;


on first glance: how can b really not be equal to itself!? This acctually would print odd numbers only

You are using "=" instead of "==". So b will get the value non-b each time. It will print odd number (once every 2 number) just as you say
If there's a += operator, why don't we have a != operator too?!? ...oh, wait. :)
+17  A:

Common Lisp's format function has an option to print numbers as Roman numerals.

In INTERCAL that is the only form of output you'll ever get.

This is a vicious slander on CL's FORMAT, which has **two** options for printing numbers as Roman numerals: one prints 4 as IV; the other prints 4 as IIII.
Format also has the option to display numbers in English, or to specify looping through a format argument through usage of format characters.
Why do they even bother supporting incorrect Roman numerals?
IIII is not "incorrect", it was in use as late as 1390, it just doesn't comform to modern ideas of "proper Roman numerals". So, essentially, a variant rather than an error.
+378  A:

Fun with auto boxing and the integer cache in Java.

Integer foo = 1000;
Integer bar = 1000;

foo <= bar; // true
foo >= bar; // true
foo == bar; // false

//However, if the values of foo and bar are between 127 and -128 (inclusive)
//the behaviour changes:

Integer foo = 42;
Integer bar = 42;

foo <= bar; // true
foo >= bar; // true
foo == bar; // true


Explanation

A quick peek at the java source code will turn up the following:

/**
* Returns a <tt>Integer</tt> instance representing the specified
* <tt>int</tt> value.
* If a new <tt>Integer</tt> instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Integer(int)}, as this method is likely to yield
* significantly better space and time performance by caching
* frequently requested values.
*
* @param  i an <code>int</code> value.
* @return a <tt>Integer</tt> instance representing <tt>i</tt>.
* @since  1.5
*/
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}


Note: IntegerCache.high defaults to 127 unless set by a property.

What happens with auto boxing is that both foo and bar the same integer object retrieved from the cache unless explicitly created: e.g. foo = new Integer(42), thus when comparing reference equality, they will be true rather than false. The proper way of comparing Integer value is using .equals;

Took me a couple of seconds to see why... java must keep a pool of Integer instances for values between -128 and 128, otherwise it allocs a new Integer, right?
that is correct
however keep in mind that if you specify new Integer(42) it will not be using the instance from the pool so foo == bar will evaluate to false
I always use ints instead of Integers if possible, but if I had to use Integers for some reason, should I just use .equals() instead of == ?
@MatrixFrog: yes, they are objects.
@Mike Akers: Highly unlikely.
What's more puzzling, is that Java is able to break the laws of mathematics by making 1000 both greater and less than itself!
@Gaurav: Actually that's exactly what happens (except 128 is not required to be pooled). And you can always implement it yourself: http://thedailywtf.com/Articles/The-Integer-Cache.aspx
@Gaurav, see the java api if you don't believe it: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Integer.html#valueOf%28int%29or go into Integer.java and take a look at the source code
http://thedailywtf.com/Articles/The-Integer-Cache.aspx
So glad I'm a C# programmer.
Best of all, you can use reflection to make 42 equal to whatever you want!
Can someone explain why you need a pool of integers?
Can someone explain why you would make a pool of integers for a subset of integers only!?
I find it more interesting that the programmers of JAVA decided to use an - assumably - modifiable value dubbed IntegerCache.high, but only 1 line ahead, they decide it's better to hardcode the 128 (instead of using IntegerCache.high+1).
@all - yes auto(un)boxing is one of the dodgier things in Java - Introduced in Java1.5 because people still hadn't gotten over their obsession with [email protected] - because the offset is based on the low value. If anything they need a new IC.low variable.
@monokrome: That 128 is there to rebase the array so the pooled instance of -128 is at index 0, -127 at index 1, 0 at index 128, and so forth. Writing IntegerCache.high+1 would be a *bug*.
monokrome: The flexible cache size was initially introduced in performance releases. The max cached value is important in certain macrobenchmarks (database IDs I guess). Avoiding changing the offset allows for smaller code changes, and simpler code.
@Will: C# has some very similar gotchas. See http://blogs.msdn.com/jmstall/archive/2005/03/06/386064.aspx
@spookylukey: The big difference is that in C# you don't need to box integers all the time, while in Java you have to do it as soon as you start using generics, which is... lots of times.
Strange feature, ya, problem, no, anyone comparing Objects with such operators have more to worry about than inconsistent results.
@Will: So glad I use Python ;-)
You use 'equals' in Java.
What's worst about this, and my primary complaint against this feature, is that if you refactor from primitives to Integers, and your tests don't explicitely try values outside of the cached range, you'll have a series of bugs that only show up in production. Not cool.
Java wasn't designed for bad programmers, or lazy ones that use a class without bothering reading its documentation.
Thats the result of premature optimization.
@Jason Oh yes, my first thoughts exactly... Lots of sneaky bugs.
The big problem given Java's goals is that the range 127 and -128 is just a minimum. The spec allows an implementation to cache a bigger range if it wishes. This would make the above test code behave differently on different implementations. So much for write-once, run-anywhere.
@spookylukey - all those C# examples use an integer variable x and it is not necessary to know what range the value of x is within to predict the result.
+19  A:

One of my favorites in C++ is the "public abstract concrete inline destructor":

class AbstractBase {
public:
virtual ~AbstractBase() = 0 {}; // PACID!

virtual void someFunc() = 0;
virtual void anotherFunc() = 0;
};


I stole this from Scott Meyers in Effective C++. It looks a bit weird to see a method that's both pure virtual (which generally means "abstract") and implemented inline, but it's the best and most concise way I've found to ensure that an object is polymorphically destructed.

It may be implemented inline but it's probably not really going to be inlined because it is virtual.
That's correct--it's strictly a matter of conciseness and clarity.
@shoosh:...unless the compiler can actually know from the context the real type of the object being destroyed. AFAIK only GCC knows how to do this optimization, though.
+31  A:

My favorite weirdness in C is 5["Hello World"], but since that was already posted, my next-favorite weirdness is the Windows versioned-structure initialization hack:

void someWindowsFunction() {

/* do stuff with header */
}


That one, subtle line accomplishes the following:

2. Concisely sets the "size" member of the structure, without hardcoding a size constant (since many Window structures, including BITMAPINFOHEADER, follow the convention of specifying the size of the structure as the first member}
3. Declares the version of the structure (since many Windows structures, including BITMAPINFOHEADER, identify their version by the declared size, following the convention that structures definitions are append-only)
4. Clears all other members of the structure (a C standard behavior when a structure is incompletely initialized).
Actually, I find this to be an elegant solution, not a WTF at all.
At what point did I say it was a WTF? The original question asked for "surprising, weird, strange or really 'WTF'". The surprising thing to me was how expressive one line can be when it combines a little-used but well-defined language behavior with a simple coding convention.
+4  A:

One unexpected feature was the trailing commas in enum def lists and array initialization lists in C, C#, Ruby, etc.

string[] foods = { "tofu", "grits", "cabbage", }

public enum ArtPeriod {
Modern,
Romantic,
}

I find that extremely cool and useful, not really "strange".
I agree that it's useful. It was strange to me because it was unexpected and given the years and years of syntax errors in my coding history, I never would've expected those to be valid.
I don't know whether to up-vote you for pointing this out or down-vote you for adding something that is not strange.
I always use the trailing comma. That way someone can add/remove/comment one more enum value in the middle or end easily.
Very useful when generating a list using a script. It removes the need to bother removing the trailing comma.
Not strange. Strange would be Internet Explorer's insistence for generating errors or outright crashing when it encounters trailing commas (all other javascript interpreters are tolerant towards trailing commas).
re: ChaosPandionI guess my comment would be, "How many years did you code in one of the above languages and never know that the trailing comma feature existed?" For me, mere mortal, it was easily like 15 years. I think using something for 15 years and suddenly finding a new feature you might have never dreamed was syntactically valid qualifies as "surprising".
I agree, ruiml, I didn't know this, and I find it surprising.
+4  A:

In Javascript, I believe the following are equivalent:

a['title'] = "Syntactic sugar is good for yr teeth.";
a.title = "Syntactic sugar is good for yr teeth.";

It is not a WTF, it is very useful (and logical as well).
Useful maybe, logical hardly imo.
why? because it's not exactly like C or PHP?
@Richo: Definitely logical.
I thought it was neat. But it was a surprise. Seriously, I had been coding in Javascript for 6 years before I learned about that. That's why I posted it. It was a surprise.
Lua will do this as well.
It makes the syntax a bit nicer if you know at design time what data member you're asking for but still allowing dynamic access with the array syntax.
+52  A:

In fortran (77 for sure, maybe in 95 as well), undeclared variables and arguments beginning with I through N (the "in" group) will be INTEGER, and all other undeclared variables and arguments will be REAL (source). This, combined with "whitespace optional in certain cases" resulted in one of the most famous bugs.

As told by Fred Webb in alt.folklore.computers in 1990:

I worked at Nasa during the summer of 1963. The group I was working in was doing preliminary work on the Mission Control Center computer systems and programs. My office mate had the job of testing out an orbit computation program which had been used during the Mercury flights. Running some test data with known answers through it, he was getting answers that were close, but not accurate enough. So, he started looking for numerical problems in the algorithm, checking to make sure his tests data was really correct, etc.

After a couple of weeks with no results, he came across a DO statement, in the form:

DO 10 I=1.10


This statement was interpreted by the compiler (correctly) as:

DO10I = 1.10


DO 10 I = 1, 10


After changing the . to a , the program results were correct to the desired accuracy. Apparently, the program's answers had been "good enough" for the sub-orbital Mercury flights, so no one suspected a bug until they tried to get greater accuracy, in anticipation of later orbital and moon flights. As far as I know, this particular bug was never blamed for any actual failure of a space flight, but the other details here seem close enough that I'm sure this incident is the source of the DO story.

I think it's a big WTF if DO 10 I is taken as DO10I, and that in turn, because of implicit declarations is taken to be of type REAL. And it's a great story.

F90+ has this "feature" as well, but you can suppress it with the IMPLICIT NONE statement. Also, the implicit typing applies to function names as well; I spent a particularly unpleasant evening trying to figure out why an INTEGRATE function I had written for a numerical methods course would always return 0.
Thanks for the comment about F90+ and function names. I knew about IMPLICIT NONE, and hopefully everyone in the fortran community knows that they should use it :-)
GOD is REAL, unless declared INTEGER.
implicit none is backported to a number of fortran 77 compilers too.
This made me shudder -- the ability to rename alphanumeric variable names without changing program semantics is just so ingrained in me. This makes about as much sense to me as having undeclared variables be INTEGER or not depending on whether the current line number is divisible by 7.
Yeah, we've come a long way since then in terms of programming languages. Although I've known people who like programming in Fortran: it's still very common in scientific programming circles.
Fortran is, I believe, the oldest language in general use today, predating Algol (still around in renamed descendants like Pascal), Lisp, and COBOL. Later versions have tried to reduce the number of oddities, but it's hard when you want backward compatibility.
FORTRAN, The first compiled language which is still in use today, has always predefined the variables by the first character. D is double precision REAL*8, i,j,k,l,m,n are INTEGER (*2 or *4), and the rest of them are REAL*4
@Dave: yes. The problem happens when implicit declarations and concatenation of tokens end up in hiding a bug.
Fortran ignores *all* whitespace! DO10I=1.10 and D O 1 0 I = 1 . 1 0 are treated the same!
I think you and the compiler better agree on what the code should do when you're dealing with (expensive) space missions :-)
+3  A:

Another C-ism.

int i= 0;
while( i != 12 ) {
/* Some comment
i += 1;
/* Another comment */
}


Why doesn't it work? Lint will tell you. The C compiler, however, usually passes over this blithely. As did I.

That was a real WTF moment when I figured out what was wrong.

This problem is easy to detect with a good IDE, but it can be difficult in legacy systems...
I don't get what is odd about it?
Or how it's a feature. =P
@Dykam: run it through lint. @Erik: The multi-line comment as a feature of C is not unique. However, some languages (like Python) don't support multiline comments to avoid this problem stemming from the feature.
Can someone explain what the problem is? Naturally I would assume that i += 1 is not executed as it's in a Multi-Line comment (Which isn't a strange concept to me), but I also vaguely remember some rules about not allowing nested comments. But the Syntax Highlighting on SO is exactly how I would perceive it - are Multiline Comments really such a big "WTF?" to people?
@Michael Stum: Yes, multi-line comments that are incorrectly terminated are a total WTF. Syntax highlighting, BTW, is very new technology. And it does help. However, many of us have been programming for decades prior to the invention of syntax highlighting.
This is why you don't use a text-editor to do an IDE's job.
@BlueRaja: When I learned C, IDE's hadn't been invented. Seriously. When I learned COBOL the word-processor hadn't been invented. It's nice to say that "tools fix this problem". They don't fix the problem. They expose the problem a little more clearly. The problem still exists, and related problems in languages like Java still cause WTF moments when helping n00bs.
I like that the code highlighting here on SO makes the problem quite clear!
What I used to rely on was a compiler or lint message (can't remember which at the time) that would flag a /* inside a comment as a warning. It was a good warning to pay attention to.
@David Thornley: Nice if you have such a warning. Epic WTF when I didn't have such a warning.
Especially dangerous with pointers: x = *p/*q;.
uhh.. I don't get it, is it that when viewed without syntax highlighting the programmer *thinks* it was already closed or what?
@Support - multilanguage SO. Try it in a non-syntax highlighting editor. Tell me what you see.
my editor will show WTF if I try // comment... */ instead of */ being on its own line, as the close-comment can skip if its commented. another nice-to-have.
@S.Lott, that's what I thought, :)
+2  A:

Here's one I thought was weird:

In C/C++ you can have as many semicolons as you want at least in the MS C++:

int main(void)
{
cout<<"Hello World";;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;
return 0;;;;;;;;;;;;;;;;;;;;;;;
}

It s just closing a void statement :3. More languages support this.
That's got nothing on #define EVER ;;. You know.... for(EVER){ ... }. *i run away and hides now*
It's the equivalent of asm's NOP function ("No Operation") which simply does... nothing. I would expect the compiler to optimize this away though. I've seen this used many many many years ago in a loop intended to cause a delay: "for(int i = 0; i < 2000000000; i++) ;" which basically does nothing but increment i. (Never do stuff like that though, it will hurt you later: http://www.merlyn.demon.co.uk/pas-r200.htm#R200)
it's not the equivalent of nop - nop has side-effects such as skipping a cycle which might help the CPU to cool down a bit. C\S* languages simply don't generate any machine code for void statements.
@fennec - I prefer #define ever (;;) so I can say for ever { ... }. I also like #define forever while(1) so I could make the same statement work as both forever { ... } and do { ... } forever;
+3  A:

Variable variables in PHP

An odd feature in PHP which allows you to create and assign variables from the content of other variables (warning, untested code):

$a = 'Juliet'; $$a = 'awesome'; // assigns a variable named Juliet with value 'awesome' echo 'a'; // prints Juliet echo '{a}'; // prints awesome echo 'Juliet'; // prints awesome  Alright, let's say we have something like this: bob = 'I\'m bob'; joe = 'I\'m joe'; someVarName = 'bob';$$someVarName = 'Variable \'bob\' changed';  How about some fun with all kinds of indirection: $juliet = 'Juliet is awesome!';
$func = 'getVarName' echo '${$func()}'; // prints 'Juliet is awesome!' function getVarName() { return 'juliet'; }  String references. Perl will do that too, but will issue a warning if you use strict (or specifically use strict 'refs'). But I prefer symbol table games: $a = 1; *b = \$a;$b = 2; Now guess what $a is? yep! (serves you right for using package globals!) This is a feature I really like in PHP. @MDCore, really? Why, because you like to shuffle your brain matter? Any shell language can do this, and many others can do this via some read operation that returns a symbol based on a string. It is useful for implementing reflective features in dynamic languages. +14 A: I'm surprised no one mentioned the REALLY ugly switch-case implementation im most C-like languages switch (someInt) { case 1: case 2: System.out.println("Forgot a break, idiot!"); case 3: System.out.println("Now you're doing the wrong thing and maybe need hours to find the missing break muahahahaha"); break; default: System.out.println("This should never happen -,-"); }  The good thing is newer languages got it implemented right. I like Delphi's handling of the case statement. A single line breaks automatically, a begin starts a block of text that breaks automatically after the end. +1 OH GOD YES - when will they learn, it's always best to make the common case the default (no pun intended)?It would make much more sense (without breaking ANY optimizations) to leave the break out, and have a "continue" keyword for the RARE occasions that we want to actually continue onto the next case. Oh, I really hate that newer languages have changed the behavior. Now when I mix loops and switch in them and put break there out of habit I get the bug I could never find looking at the code. @BlueRaja: continue has useful behaviour inside a switch (as does break), so overloading either of those words to mean either "fall through" or "leave the switch" is, in my opinion, a bad idea. I would actually say the *bad* thing is that newer C-based languages (C# and Java) did *not* do it right. They kept the same bad C-style switch statement, with a few improvements (fall-through disallowed) but still using that horrible syntax. The one thing I prefer about VB.NET over C# is its superior Select Case statement where each case block is a true block of code, not just the span of lines between a label and a break statement. @Chris: Yes I know; they could use any keyword they wanted. The point is that there should be *some* keyword needed for fallthrough, not for escaping. Since fallthrough is not allowed anyways in Java/C#, I don't see why they don't just make the 'break' statement optional (they can't disallow it due to backwards compatibility). Fallthrough is actually allowed in Java. I hate the C# switch syntax. Delphi has it right. Its always bugged me that {statement;statement;} was never enough and break was needed.. Duff's device _rules_. +1 A: In C#, why is this not legal? public class MyClass<T> where T: Enum { }  It'd be pretty cool to be able to add extension methods on Enum's along with Func<T> where the T would be the enum you're extending so that you can get type inference on that enum. Re the comment: Yes, you can extend an actual enum, but here's the difference: You CAN do this: public static void DoSomethingWithEnum(this Enum e) { //do whatever }  but what if you want to take a Func with your method that would be the same type as your enum: public static void DoSomethingWithEnum<T>(this T e, Func<T,bool> func ) where T: Enum { //do whatever }  That way, you can call your method like so: DayOfWeek today = DayOfWeek.Monday; today.DoSomethingWithEnum(e => e != DayOfWeek.Sunday);  or something like that. You get the idea... THAT'S not possible, and I'm not sure why... You can use *actual* extension methods to extend an enum. For your specific example (DayOfWeek), I would extend the DayOfWeek enum explicitly (this DayOfWeek e) rather than the base Enum type. Then you wouldn't need the generic type (or the constraint) at all. Then you would specify a Func<DayOfWeek, bool> - and all would be well. The example was just an example to prove my point. What if you want to create some method that can work for any enum? What then? http://stackoverflow.com/questions/1331739/enum-type-constraints-in-c/ Heh, I'm not the only one :-p @SLaks: be sure to read the comments in Eric's answer. He actually made a mistake in saying the CLR does not support it. It is in the spec and there is a working implementation of a library with such constraints (http://code.google.com/p/unconstrained-melody) +3 A: Perl's sub not having a real parameter list, just the @_ array. Also, sub's auto-flattening the parameters that are passed into it. I don't understand why this is a persistent feature; this reflects what I had to do as a kludge on my TI-86 BASIC years ago because the language wasn't featured enough. http://search.cpan.org/dist/MooseX-Method-Signatures/lib/MooseX/Method/Signatures.pm Perl may be a bit dated, but at least you can bolt on named/positional arguments, type checking and constraints, and optional params with nothing but a few modules! @rjh: Yes, but adding in modules to support what was a core element of quality languages in the *60s* seems quite silly. @Paul: it also allowed Perl to do things like my %args = @_; or my ($foo, $bar, @rest) = @_; or in fact, handle arguments any way you like. It's the same for OO - mostly do it yourself, but very flexible. That's Perl for you. +1 I've always thought this defeats self-documentation of code. @rjh As Paul said, quality languages in the 60s. And yes, it allowed Perl to do things... other (saner ;P) languages had absolutely no need for. ;) +33 A: In Forth, anything that does not contains spaces can be an identifier (things that contain spaces take a bit of work). The parser first checks if the thing is defined, in which case it is called a word, and, if not, checks if it is a number. There are no keywords. At any rate, this means that one can redefine a number to mean something else: : 0 1 ;  Which creates the word 0, composed of 1, whatever that was at the time this was executed. In turn, it can result in the following: 0 0 + . 2 Ok  On the other hand, a definition can take over the parser itself -- something which is done by the comment words. That means a Forth program can actually become a program in a completely different language midway. And, in fact, that's the recommended way of programming in Forth: first you write the language you want to solve the problem in, then you solve the problem. Wow. That's pretty crazy. Is it useful? or is it just a pain? Well, I never encountered any programs redefining numbers themselves -- just because it is possible doesn't mean it is a good idea, after all. There are words starting with numbers, though, such as 0BRANCH. As for taking over the parser, that's pretty common, as the language is pretty much geared towards building DSLs. I was trying to think back to the mid-80s when I used Forth. You nailed it with the definition taking over the language. Since it was right around the place and time of the Homebrew Computer Club, there were some real characters messing around with Forth and the kit computers like the Z80 S100-bus. Later Forth was an alternative to 6502 assember on Atari 2600 and Commodore 64 -- darn kids nowadays have NO IDEA that TOTAL ADDRESSABLE RAM was 64k. That's it! +588 A: In JavaScript, the following construct return { id : 1234, title : 'Tony the Pony' };  returns undefined is a syntax error due to the sneaky implicit semicolon insertion on the newline after return. The following works as you would expect though: return { id : 1234, title : 'Tony the Pony' };  Even worse, this one works as well (in Chrome, at least):  return /* */{ id : 1234, title : 'Tony the Pony' };  Here's a variant of the same issue that does not yield a syntax error, just silently fails: return 2 + 2;  Now this is a good example. Semicolon insertion is one of the most evil parts of JavaScript. You always run into problems when you design language features around the assumption that your users will mostly be idiots. Ya gotta love that: commenting out invisible code! thats what you call useful and fun! Awesome feature! A+++ would program again! I actually had that problem, being c# developer myself, I put the brace in new line. Took me hours to realize what was the problem. Even when I've solved the issue I didn't know what was the problem until I read your answer! I think this answer is bogus. Both the first and the last are SyntaxErrors, at least in Firefox. Jason Orendorff: You're right it actually yields a syntax error due to the unexpected JSON. I corrected it and provided an example that does actually return undefined silently. The third example indeed doesn't work on Firefox but it most definitely works on Chrome. This is a well known artefact, not bogus at all unfortunately. I'm learning Javascript right now, and this one is a big WTF to me. Semicolon insertion? You have to be kidding! (+1 BTW) These are so called bad parts of JS, to avoid these every javascript developer should read the good parts of Douglas Crockford. "Feature"? I think this item belongs on "strangest language *bugs*". Kyralessa: Implicit semicolon insertion is supposed to be a feature that makes working with javascript easier for non-programmers. It's not a bug, it's a feature! Really! Why are people voting for this? This will happen in any language with significant newlines, like Ruby and Python for example. Why would anyone produce this code knowing newlines are significant? That sounds like more of a cultural problem than a language problem. If people didn't think they were supposed to use semicolons, they wouldn't be confused to find their statements are also delimited by newlines where possible. I never end lines with semicolons (except empty for-loops, which expect a statement) because two statement delimiters is redundant. Might as well complain about parenthesis in lisp or indentation in haskell or python - it's part of the syntax, and it's there by design. I cannot understand how this could ever achieve the up-votes it has. It can only surprise people who try to use C-style when programming in Javascript. I wish people would give up on the very concept of "preferred" style and use the style natural to the language/project they are programming in. I agree with the last couple of comments. You shouldn't be opening curly braces at the start of a line anyway (in any language), and if you know that semicolons at the end of a line are optional, then this behaviour becomes incredibly obvious. I wish people stopped telling other people what to do. We're all grown-ups, you see. @DrJokepu...WTF .. realy O_o!!! If you're not supposed to use C style when programming in JavaScript, then it was rather perverse of the JavaScript language designers to choose a C-style syntax. @Nick Retallack, @mcv: I think what makes it confusing is that only *some* newlines are treated like semicolons, and others aren't. For instance a = myFunc[newline](1) is not the same as a = myFunc;(1). In the first case a equals the value returned by myFunc(1), but in the second case a equals the *function* myFunc. @mcv: Also, I disagree with you on not using opening braces at the start of a line in *any* language. This is a perfectly valid convention to use in most C-style languages, and (combined with tabbing) has the advantage of lining up each opening brace with the matching closing brace. Moreover, some college computer science departments require it. However, I agree that it's a bad idea for JavaScript in particular, because of semicolon insertion. You may want to watch Dough Crockford's video about this, minute 32: http://goo.gl/zM5t Tight JavaScript syntax is not a style preference, it's good web development. C/C++/C#/Java are compiled. JavaScript is not. Every space is another byte (two for windows line breaks) for the user to download. Extend that to HTML/CSS, and it adds up. Some DotNetNuke pages have 20% page weight (not including images) from excess whitespace; they use 4-spaces where tabs should be. There's a growing population of mobile users surfing at modem-like speeds, prompting Google to add page weight/download time as criteria for search engine ranking this year - it's time to give a crap. @Matt: Fair point, however I believe that these days, in production environment, you would only serve JavaScript that has been preprocessed by tools such as JsMin and Closure Tools anyway, so the original source code doesn't really resemble the actual JavaScript that has been served. +21 A: Some 20 years ago, when I last dabbled in MUMPS, the implementations had some curious limitations. While hosts MUMPS was becoming ever more popular, MUMPS was traditionally a self-hosted language: computer language, operating system and database in a single package. MUMPS was essentially about its database. Essentially, a huge multidimensional hash table, supported by a B* tree that made for very fast access. There wasn't any barrier between the language and the database either: if you wanted something to be stored there, you just prefixed the variable with a symbol indicating it was to be persisted to the backing store. On the other hand, a filesystem was almost non-existent, and support for it even less so. About the only thing one could do was to load a program into memory from a file, and send whatever was in memory back to a file. And one had better clear the buffer before loading, otherwise it would get mixed with whatever was there first. So, considering its self-hosting nature and the extremely hostile file system, one could wonder how these programs were edited. The editors, as a matter of fact, were written in MUMPS itself -- so how could the editor store the program in memory without written over itself? Well, the trick was the ability to execute the contents of a variable as source code. An editor, then, loaded itself into variables, executed itself in them, cleared the memory, and then loaded, saved and edited files in memory, all the time executing from variables. Add to that the fact that all commands could be shortened to their first letters (except the Z commands, shortened to two letters, that mostly handled the filesystem), and curiosities like the fact that IF (I) set a variable which was then consulted by ELSE (E) -- and, of course, could be overridden by any intervening I, or by the program itself. On second thought, I think the whole language was a WTF. And, yet, it had a strange attraction. MUMPS is famous on The Daily WTF. I think the question is more about weird *features* instead of the ways languages which make a freakishly demented hash of things, though.... ;) Read 'A Case of the MUMPS' on thedailywtf.com: http://thedailywtf.com/Articles/A_Case_of_the_MUMPS.aspx Luckily modern implementations are much better than this. BTW, I'm familiar with that Daily WTF article and it's quite out of date (perhaps 10+ years old) and also, IMO, not entirely truthful. Just to make it clear, I *like* MUMPS. But I have also seen the worse of it. Or, rather, seen something bad enough to have felt pity for those who _have_ endured the worse of it -- maintaining badly written, single-letter commands, legacy MUMPS code. It's actually oddly high level for such an early language. If it just had better structured programming features (Intersystems is trying at least) then it could be a pretty good language. RE the if-else, they've proposed adding a then statement that would preserve the value of$TEST and restore it at the beginning of the next line, thus protecting you from the hazard of having it change on you; but I don't even know if the proposed future standard will ever happen.
And IMO, single-letter commands aren't so bad. There are only a few commands anyway, it's not that hard to remember them. Single-letter *variables* are bad, though. And tag interfaces that pass around information in arbitrarily named variables rather than explicit parameter passing. Those practices are (no longer) allowed where I work.
But the best thing about MUMPS is not having to scrap and rewrite your code every 10 years because your language of choice is no longer supported. The language has had phenomenal longevity.
Ok, I'll grant the one letter commands. It's just that whenever I see one letter commands, everything else is also one letter.
My most un-favorite variable name is probably %.
+8  A:

In C:

warning C4013: 'myfunc' undefined; assuming extern returning int


I remember for some reason not seeing warnings (too much of them in some legacy code?) and puzzling over why conversion from int causes compiler error where non int-returning function is used.

Compiler assuming such stuff was quite unexpected.

The compiler has to assume *something* about undefined symbols in order to continue parsing. The most reasonable guess for an undeclared function is one returning int taking unspecified parameters.
I am ok with parser assuming that while parsing, but later, when all symbols are being resolved, it should cause an error instead of being propagated through the full compilation pipeline.
-werror on GCC, isn't it? That should solve some problems for you...
+12  A:

In JavaScript, seeing !!a for the first time (as a way to convert to boolean).

Good thing you haven't run across ~~a for int coercion then.
Well you can do int by +a which is also shorter.
Also in C, C++, Perl, Tcl. The WTF would be: what language DOESN'T do this? (I suppose a language with proper TRUE and FALSE types/objects)
JavaScript has proper true/false objects. On the other hand, Perl doesn't, so !! is not that useful in Perl.
@Andrey Shchekin: +a doesn't do int coercion, it only does number cooercion.
+9  A:

Perl filehandle-style operator calls.

In the beginning, there was

print "foo", "bar", "baz"; # to stdout
print STDERR "foo", "bar", "baz";


Notice the ostentatious lack of a comma so that you know that's a filehandle to print-to, not a filehandle to print in a stringified manner. It's a dirty hack.

Language upgrade rolls around, they make proper OO filehandles and turn x FOO y, z, abc into FOO->x(y, z, abc). Kinda cute. The same print statement effectively runs

STDERR->print("foo", "bar", "baz");


Mostly you notice this when you miss a comma, or try to run something like hashof $a,$b, $c (subroutine call without parentheses) and forget to import the hashof function into your namespace from its utility package, and you get a weird error message about "Can't call method 'hashof' on via package 'contents of string$a'".

oh god, the horror is beautiful. : )
Dealing with filehandles in Perl is inconceivably awkward. They are not scalar values or objects, but a 3rd category that lacks decent syntactical support. So, a bunch of Perl modules like IO::Handle were created to make them more sensible -- except these objects don't work everywhere a real filehandle would. *It's a good thing programmers don't need to work with files much.*
+20  A:

In JavaScript:

alert(111111111111111111111) // alerts 111111111111111110000


This was quite damaging to some 64bit keys I passed back and forth in JSON.

Treating it as a floating-point value of some sort?
Yes, I think so, if you add some more 1111 it would be more obvious.
All numbers in ECMAscript are Nubmbers which is an IEEE float.
+4  A:

VBScript's With blocks:

With xml.appendChild(xml.createElement("category"))
.setAttribute("id",id)
.setAttribute("keywords",keywords)
With .appendChild(xml.createElement("item"))
.setAttribute("count",count)
.setAttribute("tip",tip)
.appendChild(xml.createTextNode(text))
End With
End With

How is the With block a strange feature? Useful for setting many properties on data classes.
I agree, it's handy. I guess I just meant "strange" in the sense that it is unique. JavaScript has a with() { } block, but it doesn't really work the same (or well).
A unique feature is not necessarily strange.... I wish C# and other languages had this feature as well.
VB6 has With too.
+10  A:

VBScript's date/time literals (why is this still so rare?):

mydate = #1/2/2010 5:23 PM#

If mydate > #1/1/2010 17:00# Then ' ...


Edit: Date literals are relative (are they technically literals, then?):

mydate = #Jan 3# ' Jan 3 of the current year


VB.NET, since it is compiled, does not support relative date literals. Date only or time only literals are supported, but the missing time or date are assumed to be zero.

Edit[2]: Of course, there are some bizarre corner cases that come up with relative dates...

mydate = #Feb 29# ' executed on 2010-01-05, yields 2/1/2029

Scala has XML literal notation. def xmlString = <xml>foo bar <b>baz</b></xml>
_why is this still so rare?_ because literal date is not needed often -- time span literals would be more useful.
My issue with DateTime Literals is that they can be ambiguous - mydate = #10/9/2009 18:35# - October 9 or September 10? Nowadays I'm guessing it's always mm/dd/yyyy, but for non-US users it's always very odd to have a date not in dd/mm/yyyy format. In languages that have a Date constructor, you at least can always refer to the signature, but I guess it's not that different from just looking it up in the help or memorizing it. On the other hand: A whole language construct for Dates seems very "heavy". I can understand why Visual Basic has it (Office VBA), but I wouldn't see much use i.e. in C#
@fennec: So does VB.NET 9, now that you mention it.
@Andrey Shchekin: I don't know, I tend to use them often enough for it to be worthwhile. Keep in mind VBScript uses relative time literals, so #Jan 5# is 2010-01-05 today. Timespan literals (beyond simple count of seconds) would be nice, too, though.
@Michael Stum: Agreed. ISO 8601 should probably be used, just to keep things clear. I guess the relative weight of language features depends a great deal on how it impacts the programmer personally.
Don't know about VB, but in FoxPro, date literals were interpreted at compile time based on the current user DATE setting, which could be changed with SET DATE DMY, SET DATE MYD etc.
+11  A:

In Python:

>>> a[0] = "hello"
NameError: name 'a' is not defined
>>> a[0:] = "hello"
NameError: name 'a' is not defined
>>> a = []
>>> a[0] = "hello"
IndexError: list assignment index out of range
>>> a[0:] = "hello"
>>> a
['h', 'e', 'l', 'l', 'o']


These slice assignments also give the same results:

a[:] = "hello"
a[42:] = "hello"
a[:33] = "hello"

I agree that the a[0:] and a[42:] should raise an IndexError - but both the a[:] and a[:33] style make sense and can be usefull.
If a[:33] can be useful, why not a[42:]? Don't see the big difference. (And a[:] is of course incredibly useful)
+4  A:

Dozens of things in Javascript can make your eyes water.

The scoping of local variables, as just one simple example:

function foo(obj)
{
for (var n = 0; n < 10; n++)
{
var t;        // Here is a 't'
...
}
t = "okay";     // And here's the same 't'
}

Scoping is my biggest headache in JacaScript...
Am I going mad here? Am I the only one who expects this "t" variable to be in scope as it was defined in this function??! I don't expect "t" to be global or accessible from any other function, but in the same function?! Yes!
@Maltrap: t is defined in an inner block, as delimited by { and }. In pretty much every other modern language, stuff defined inside a block stays inside that block. Likewise I could argue that t is defined in the global/window object and should be accessible globally. JavaScripts behavior is very odd as it applies scope to some {}-Blocks and not to others.
what you need is something like (for(...)(function(){ var t; ... })();), if you want scoping doing well
Function scoping rather than block scoping. Meh.
@Maltrap: I also expect this to work the way it does since my other favourite language also does this.
@Cheung: That makes my eyes water.
In good Javascript, you should have only one var statement per function, usually at the top of the function. Only functions create a new "scope" in Javascript, and not things like for loops and if statements or {}'s.
@strager: Yes. Thus "good" Javascript is not conceptually compatible with almost every other block-scope language.
JLint for your javascript global problems...
+2  A:

In Bash, variables can appear to be both scalars and arrays:

$a=3$ echo $a 3$ echo ${a[@]} # treat it like an array 3$ declare -p a    # but it's not
declare -- a="3"
$a[1]=4 # treat it like an array$ echo $a # acts like it's scalar 3$ echo ${a[@]} # but it's not 3 4$ declare -p a
declare -a a='([0]="3" [1]="4")'
$a=5 # treat it like a scalar$ echo $a # acts like it's scalar 5$ echo ${a[@]} # but it's not 5 4$ declare -p a
declare -a a='([0]="5" [1]="4")'


ksh does the same things, but uses typeset instead of declare.

When you do this in zsh, you get substring assignment instead of arrays:

$a=3$ a[2]=4          # zsh is one-indexed by default
$echo$a
34
$a[3]=567$ echo $a 34567$ a[3]=9
$echo$a
34967
$a[3]=123 # here it overwrites the first character, but inserts the others$ echo $a 3412367$ a=(1 2 3)
$echo$a
1 2 3              # it's an array without needing to use ${a[@]} (but it will work)$ a[2]=99          # what about assignments?
$echo$a
1 99 3

+2  A:

In Common Lisp, arrays with zero dimensions are strange, and naturally, they have read syntax.

? (aref #0A5)
5

+5  A:

This is a lack of a feature which is weird: Python has no switch statement (although workarounds exist).

The really weird part: somehow you never miss it.
Perl too. There are workarounds, but they are all more verbose and less clear.
Actually Perl does come with switch (http://perldoc.perl.org/Switch.html). However this was a "source filter" and with 5.10 the new given/when (borrowed from Perl6) were added (http://perldoc.perl.org/5.10.0/perlsyn.html#Switch-statements)
Lua doesn't have it either...
You could have a condition dictionary: each key is a literal, each value is a lambda, and if an input value is equal to a key, execute its lambda and break.
+219  A:

APL (other than ALL of it), the ability to write any program in just one line.

If that line isn't WTF, then nothing is!

And here is a video

I love APL. Ah, the joys of spending an entire afternoon to write half a line of code! The first thing I'll do when I get a keyboard where I can program what letters are displayed is to reacquaint myself with APL again.
@Daniel - WHY?!
Yes, but if your productivity is rated by lines of code per day, this will make you look like a terrible programmer!
Looks like a language for Greeks.
I like that, Esko. Yes, there are a lot of geeky greeky letters in it.
APL is a terminal disease. (anon?)
@Erik: There's joy to be found in writing code which is solely about what you want, and not about how to get there. Of expressing your code as a single expression. It's like the ultimate perfect katana cut. Of course, in a real fight I'd rather have a gun.
@jay:productivity is rated by lines of code in the same way productivity is rated by weight in aircraft design!
Wow, why aren't code golfers all over this?
Yeah, like a hole-in-one! I love golf and programming and if I can do it in one shot ... by all means why not ... except maybe for the fact that when you get a hole-in-one you are supposed to buy all your buddies a drink (not the other way around).
@Daniel: You spend an entire afternoon to write a line of code... and an entire week to *read* a line of code. ;-)
APL is designed to be written, not read.
APL would be awesome to see in a sci-fi action movie. I can imagine someone sitting at a three-color terminal muttering "Reshape the enemy missile vector...transpose...pi times logarithm...grade up--and--execute!" followed by explosions and cheering.
+156  A:

The JavaScript octal conversion 'feature' is a good one to know about:

parseInt('06') -> 6
parseInt('07') -> 7
parseInt('08') -> 0
parseInt('09') -> 0
parseInt('10') -> 10


More details here.

If I'm not mistaken, Python does this too but they took it out in version 3.
perl still does this, perl -E'say 010'
Got stuck on a bug that all the numbers worked except 8 and 9!! Was going crazy!!! Thanks Brian!
That's crazy shit.
This is a feature. All numbers starting with 0 is considered as a hexadecimal. Of course, bugs ensue.
And that's why parseInt takes an (optional) extra argument :).
leading 0 means octal number. since 8 is not a valid octal digit, the result must be 0.
You mean there are languages where this isn't true?
Python (2.x) throws a SyntaxError on 08 (or any other leading-zero number that is not really octal). 3.x just doesn't allow leading zeroes, period. (But it has prefixes 0b for binary and 0o for octal in addition to the usual 0x for hex. Now I only have to overcome my hate for "print as a function"... ;-)
... and parseInt('010') -> 8 just to confuse you.
This one got me too once.
Changed in ES5: "The specification of the function parseInt no longer allows implementations to treat Strings beginning with a 0 character as octal values."
you should always pass the base parameter when parsing integers.parseInt('08') == 0whereas parseInt('08', 10) == 8
This actually makes sense. Maybe parseInt('09') should have thrown an exception.
+5  A:

MySQL enums, specifically their ability to confuse the living hell out of unprepared coworkers.

CREATE TABLE foo (
....
dispatched ENUM('0','1') NOT NULL DEFAULT '0',
)


Then:

UPDATE TABLE foo SET ..., dispatched = 1;


Oops, dispatched was set to ZERO instead, because the 1 wasn't quoted. This really annoyed someone who worked on my code; I use plain old INTs now.

On a related note, even if you add an empty string option to your enum, e.g.

blah ENUM('','A','B') NOT NULL,


If you assign an invalid value to blah, MySQL will use a secret hidden empty string value to represent the invalid value, which will be difficult to distinguish from the one you added yourself. Yay!

How about TINYINT(1), BIT or (perhaps best of all) BOOLEAN rather than ENUM('0','1')?
Indeed, I used TINYINT(1) -- MySQL doesn't yet have a BOOLEAN type.
It has a type BOOL which is an alias for TINYINT(1).
You don't even need to declare the empty string in the list of possible values. From the doc "if you insert an invalid value into an ENUM (that is, a string not present in the list of permitted values), the empty string is inserted instead as a special error value." i mean wtf, you explicitly list the set of possible values, specifically BECAUSE you want any other value to be an error..
+9  A:

Easy pickins, Erlang is full of them. For example, 3 forms of punctuation,

a_function(SomeVariable) ->
statements_end_with_commas(),
case PatternMatching of
0 -> now_we_end_with_semicolon;
true -> except_the_last_one
end.

%%  Function definitions end with periods!

I guess I should add that this isn't a language feature, per se, more of an odd choice in syntax. If I had to pick an odd language feature of Erlang, it would be the representation of strings as lists of integers. Meaning [80,97,117,108]. => "Paul". I wonder what implications this had for Facebook Chat, if any?
A C string is also just a list of integers, sort of.
+14  A:

Ok, since question will be in intermittent mode, I'll join to the "fun"

Go ( aka Issue9 ) use of upper case for visibility:

• If you name something with uppercase it will have public access.

• If you use lower case it will be package-protected:

Visible outside the package:

func Print(v ...) {
}


Not visible outside the package

func print( v ... ) {
}


You can find more in this original answer.

+1 for referring to the language as Issue 9. :-D
Haven't they changed it to Issue #9 yet? Anyway, I actually like it. Then again, i don't mind using identation for delimitting blocks either.
What is "Issue #9" referring to?
+158  A:

Let's have a vote for all languages (such as PL/I) that tried to do away with reserved words.

Where else could you legally write such amusing expressions as:

IF IF THEN THEN = ELSE ELSE ELSE = THEN


(IF, THEN, ELSE are variable names)

or

IF IF THEN THEN ELSE ELSE


(IF is a variable, THEN and ELSE are subroutines)

-1 because I actually like this feature. It allows me to invent syntax in tcl.
... or C++/CLI, which came out in 2005 (IIRC).
That is fantastic, it really illustrates that it is a UI decision, not an implementation one, that helps the user distinguish between the different levels of foreground and background.
I really laughed out loud when reading this... +1
buffalo buffalo buffalo buffalo buffalo buffalo buffalo.(See Wikipedia if you don't get the reference.)
@quark: that's a separate answer to this! ;) ... (and yes, you can program with english, just deploy it as .ppt to other developers. ;)
@quark, you're missing a buffalo
@RoadieRich one group of buffaloes is not explicitly from Buffalo, they are just nondescript buffalo.
Or FORTRAN, in which there were not only no reserved words, but whitespace was not significant (the END statement was defined as a card with 'E', 'N', and 'D', in that order, and spaces everywhere else). Parsing an IF statement was tricky, since IF( could mean either the start of one of the varieties of IF, or an assignment to the IF array.
I saw some sign makers outside a Ben and jerrys ice cream factory factory the other day. I critiqued their work, I told them there wasn't enough space between ben and and and and and jerrys.
A:

C# yield statement, not weird but pretty useful.

http://msdn.microsoft.com/en-us/library/9k7k7cf0(VS.80).aspx

A:

This is nothing strange or surprising, but it is something that made me always say WTF:

Case sensitivity in syntax, or in identifier names.

Most languages that have it just seem to have it because C has it. There is no good reason for it.

It's especially scary for loosely-typed declaration-free languages like Python, which will silently create a new totalsum variable, when really you meant totalSum.
I used to think that way, but I've come around to the fact that forcing all instances of the same identifier to use the same casing avoids some problems with later readability/maintenance when someone decides they will add code using a different "spelling". The modern IDE (Intellisense) feature of typing only a few letters of each identifier to type it out helps a lot. However as said, in declaration-free languages case sensitivity is suicide.
Case sensitivity is not implemented in a language so you can use totalsum and totalSum for different variables. It's there so you don't use it for them both for the _same_ variable. It makes all references to a variable consistent which is a good thing. It's just a side-effect that you can use it for similar-but-different variable names. TRWTF is when people do use it for that purpose.
David: No one intentionally uses totalsum and totalSum as two separate variables. That's the point; it's painfully common to mistakenly use the wrong variable name, it's very tricky-to-debug, and is entirely the fault of the pointless case-sensitivity of the language.
@BlueRaja: You're right, in languages where a variable doesn't need to be declared before using it this problem becomes far more sinister. But I have seen variables with different cases but the same name being used in Java. In my perfect world I would have 2 constraints: (1) variable names are case-sensitive AND (2) variable names cannot be the same as other variable names (ignoring case). That way variables names always look exactly the same and cannot be confused with other variables.[For clarity: there are 2 Davids commenting here. Mine was the third comment.]
(First David here) The totalsum/totalSum problem is one that exposes a larger issue, that of consistent naming schemes. It's actually getting consistent naming in a case insensitive language that helped opened my eyes to the long term benefits case sensitivity has for enforcing good coding habbits (making the job of maintenance programming a lot easier).
In Common Lisp, variable names are case-sensitive (which is really the only way to do it that internationalizes well - case-folding in general is a real can of worms), but the standard reader will upper-case them. (Since CL is an ANSI standard, we don't have to worry about German "ss" or Hungarian "sz" or Turkish "i".)
@scrapdog: Jeez, what makes programmers so lazy these days? Hitting shift is complicated? Stressful? What? Because FORTRAN was case insensitive, this is the way to go? Or Basic? Good Lord. If you don't like case, type everything in lower (or upper) case. And deal with the un-readability of the resultant code. Or let future programmers deal with it.
@xcramps:It has nothing to do with economy of keystrokes. And it has nothing to do with my preference of case. It has only to do with how identifiers are interpreted.Case sensitivity in identifiers affords the programmer the ability to use the same word, differentiated only by case, for two or more different variables. A benefit not worth the cost of the problems it causes.This adds to confusion, it doesn't ameliorate it, it introduces many more ways to shoot oneself in the foot, and it *detracts* from readability.
Of course, a good compromise would be to enforce case-sensitivity, while allowing only one instance of a particular word to exist. In other words, once you define "myIdentifier", you can only refer to it as "myIdentifier", and furthermore, this would preclude "MyIdentifier" and "MYIDENTIFIER" from being defined.
...that uppercase and lowercase are two different sets of numbers in ASCII and UTF-8 is probably why...
-1 Case folding for i8n char sets is not always obvious.
+17  A:

In python, the "compile time" (or declaration time) evaluation of function arguments can be confusing:

def append(v, l = []):
l.append(v)
return l

print append(1)
print append(2)

>>> [1]
>>> [1,2]


The intention might have been:

def append(v, l = None):
if l is None:
l = []
l.append(v)
return l

print append(1)
print append(2)

>>> [1]
>>> [2]


This behavior is useful for things like caching, but it can be dangerous.

A bonus feature: tuples with mutable contents:

a = (1,2,[3])
a[2][:] = [4] # OK
a[2] = [2] # crashes

+1, I would say this is THE major wtf of Python
To be a major WTF it'd have to be something that commonly causes problems.
@Roger Pate: Every single Python programmer gets bitten by this at some point, after which they have to constantly keep it in the back of their mind. That is exactly what constitutes a language-gotcha ( http://www.ferg.org/projects/python_gotchas.html#contents_item_6 ).
You can't return l.append(1). You have to l.append(1); return l because list.append returns nothing.
Thank's Chris, fixed.
+14  A:

All it would take would be ONE extra line of code on Microsoft's part:

public void AddRange<S>(
IEnumerable<S> collection
) where S : T

Not really a language feature insomuch as it is a framework feature. Pedantic, I know...
I would call it a framework design oversight - but it's definitely a WTF
It works with C# 4.0 due to new co- and contravariance features.
Because Interface variance and co-variance did not appear before framework 4, and it did NOT take 1 line of code.And yes, it feels like it should work, but if you think about it it makes perfect sense that it does not by default.
@Denis: Try it yourself. That single line of code *does* solve *this* particular example because it is basically mimicking covariance (or contravariance, I never know which one is which).
Microsoft didn't do it back in .NET 2.0 because it would require you to specify the generic parameter S every time you used AddRange<S>(). Only with the introduction of type inference (alongside .NET 3.5) were you able to omit the type parameter and so the syntactic baggage was no longer a consideration. But by then it was too late. A neat trick nonetheless.
@Allon: no, that doesn’t use type inference and hence already worked pre-3.5.
+9  A:

When I was in college, I did a little bit of work in a language called SNOBOL. The entire language, while cool, is one big WTF.

It has the weirdest syntax I've ever seen. Instead of GoTo, you use :(label). And who needs if's when you have :S(label) (goto label on success/true) and :F(label) (goto label on failure/false) and you use those functions on the line checking some condition or reading a file. So the statement:

H = INPUT :F(end)


will read the next line from a file or the console and will go to the label "end" if the read fails (because EOF is reached or any other reason).

Then there is the $sign operator. That will use the value in a variable as a variable name. So: ANIMAL = 'DOG' DOG = 'BARK' output =$ANIMAL


will put the value 'BARK' on teh console. And because that isn't weird enough:

$DOG = 'SOUND'  will create variable named BARK (see the value assigned to DOG above) and give it a value of 'SOUND'. The more you look at it, the worse it gets. The best statement I ever found about SNOBOL (from link text) is "the power of the language and its rather idiomatic control flow features make SNOBOL4 code almost impossible to read and understand after writing it. " the name of the language alone deserves an upvote here Perl has all those features... PHP allows that aswell,$animal = "dog"; $dog = "bark"; echo $$animal; I should've also mentioned that my university didn't have a SNOBOL compiler. Instead, we had a SPITBOL compiler. What's wrong with metaprogrammability? The one time I wrote a class assignment in SNOBOL, it wasn't any fun at all. That language desperately needs better control structures, and that's far more important than having only one sort of statement (including label, main variable/value, pattern matching part or all of the former, equal sign, value to assign, and labels to jump to). @slebetman: I guess... META IS MURDER? @Kris It would be more useful as an array animal[dog][bark]=sound; or class animal->dog->bark=sound; I heard a SNOBOL anecdote of smartass programmers who used to bring their stacks of SNOBOL cards to the card reader, make a show of dropping them all on the floor, picking them up in a random pile, and drop the whole lot into the reader. SNOBOL would happily run their program as intended with no problem, while the other languages on the machine would invite the programmer to spend the evening manually sorting cards. Before anybody goes hating on SNOBOL, you have to remember that it dates from 1962, roughly corresponding to Fortran IV; long before structured programming was invented. If you want structured SNOBOL, I'd recommend Icon (created by the same team that created SNOBOL). +18 A: In FoxPro, if I remember correctly, every command can be abbreviated to 4 characters and everything else is ignored, so READ, READY, READINESS is all the same - whatever is after the first 4 characters is ignored. The guy who explained it to me liked that feature, but I thought it was creepy. +1 for creepy. lol i laughed too +1 Early Infocom games (text adventures) used to have a similar limitation. So if you tried to reference an object the game didn't expect, sometimes you'd get a hint about an item that would surface later in the game. As in:> STEAL THE JACKET> You can't see a powerful looking jackhammer here! +5 A: In Java, int x = 010; This assigns x to have the value 8. Any integer preceded with a zero in Java is presumed octal. Should have stated: "In many programming language..." because it's the same in C/C++, Perl, PHP, Tcl, Javascript, Ruby, Python ...I say it's C's fault. This is the n-th dupe of "In [insert-favorite-or-hated-language-with-octal-literals-here] 010 is 8". Please delete and improved the original answer. What Martinho said. @slebetman Though I *do* have to mention that Python 3.x removed it. Yes, it doesn't interpret a leading 0 as octal (you can use the "0o" prefix for that, similar to "0x"). In fact, a number with a leading zero is an error. A: here is my 2 cents. In c++: int* t = new int(15); delete t;  what's strange about this? I think he's getting () and [] confused? Heh, int(15) casts 15 as an integer. So the line of code actually sets t = 15, rather then a pointer to an int[] of size 15. So when you delete t, it will cause an error. @Chad this will not give an error on a conforming compiler, while int(15) indeed casts 15 to an integer, new int(15) will create a dynamically allocated integer and assign the value 15 to it. t will be a pointer to an integer containing 15 Thank you Pieter. Thanks everyone else for throwing dirt at me. This is a WTF feature which you probably did not know. +1 A: In SQL Server you may end up with a nasty surprise if you use select * in your production code. Using select * is not considered as a good practice anyway but it is good to know of some of the interesting behaviour. See question “select * from table” vs “select colA,colB,etc from table” interesting behaviour in SqlServer2005 for more details x=mysql_num_rows(result); over 4 billion queries served! +244 A: Quoting Neil Fraser (look at the end of that page), try { return true; } finally { return false; }  (in Java, but behaviour is apparently the same in JavaScript and Python). The result is left as an exercise to the reader. EDITED: As long as we are on the subject consider also this: try { throw new AssertionError(); } finally { return false; }  +1. For some reason, I find this hilarious and can't stop giggling. Thankfully C# doesn't allow such madness... Control cannot leave the body of a finally clause This returns, false, does it? It may look like a WTF (and possibly it is one), but I live by the rule: Finally always wins, unless you crash the Machine before. @Richard E - even when an unchecked exception is thrown? @michael: yes, it does return false. To my dismay when I first met this.. here I was, thinking that once you return the stack is "discarded". But you're right, finally always wins. I wonder if you can insert some clever trick here, like fooling the compiler and yet executing other code. To be fair, I blame TDWTF's nice explanation for remembering that finally always wins unless you yank the power cord: http://thedailywtf.com/Articles/My-Tales.aspx +10I was staring at it, flabbergasted and with a racing mind if I ever used a finally return in my code. And, by the way, I changed the "return inside finally block" warning of my IDE immediately to an error. @kdgregory - yes, even when an exception is thrown as the purpose of the finally is to clean up memory and other resources (i.e. call dispose, unlock things, or do something that must always be done regardless, maybe set a static variable), and then because an exception is thrown, no value needs to be returned as the function earlier in the callstack won't get the result (exception will either be caught, or that function will be exited out of as well due to the exception) I'm not sure I get you, Grant. Are you saying that the return in the finally clause will get executed in the sense that it puts a return value onto the stack, but this return value is then discarded when the stack continues to unwind upon exiting the finally block? I'm not sure what the code should return in this case. But I'm absolutely sure that you must not put return in finally clause. javac does lint this code. @J.F. Sebastian: I totally agree. I can't think of a single valid use for return in a finally. Well, i'll predicate that with saying that it depends on what the language tells you about what happens when you return or throw or any other thing. Hmm... After thinking about this for a bit, I actually understand it. when the return statement has completed, the function is no longer active. Since the finally clause has to run, it follows that the return true statement *has not executed* when return false is encountered. The function returns at that point. A compiler might notice that a return statement cannot raise an exception, so it is safe to rewrite it to put it after the finally clause. @Token: I found a use the other day. I was sad when C# didn't let me do it, but now I guess I understand why. Actually, it wasn't really a good use... I just put the return below the block :\ Even if you can't return in a finally what would the following code do: bool x = true; try { return x; } finally { x = false; } @Chris Just tested this in LINQPad (for C#) and it returns true. On the other hand if you change the code toTestClass x = new TestClass();x.Value = true; try { return x; } finally { x.Value = false; }where TestClass is a reference class then the Value property will be set to false before control returns to the calling method. So it would appear that the value is copied to the stack when the return is hit, but the finally block is still called (as you'd expect). @Martin - The same thing happens for the equivalent situations in Python. This seems rather odd that a minor implementation detail can affect how the results of a try / finally block work. Just remember that finally does exactly what it says. if halt; doesnt stop the madness, maybe exit; will.. :) FYI, Its a compile time error in C#. Control cannot leave the body of a finally clause This is awesome. Simple and brilliant It is NOT true that control cannot leave the body of a finally clause in C#. See section 8.10: "If an exception is thrown during execution of a finally block, and is not caught within the same finally block, the exception is propagated to the next enclosing try statement. If another exception was in the process of being propagated, that exception is lost." (Checking for "return" statically is just a special case.) Java, Common Lisp, Python, et. al. all behave this way. This is not a WTF. Its just logical, because finally, will always execute it's code and so it overwrites everything, that's in its way. Just tried the equivalent in Delphi, and it won't compile - same as C# ([Error] Unit1.pas(26): Cannot BREAK, CONTINUE or EXIT out of a FINALLY clause) +14 A: ## x = x + 1 This was very difficult to digest when I was a beginner and now functional languages don't use it, which is even more difficult! If you don't see how this is strange: Consider the equals sign as a statement of assertion instead of an assignment action, as you used to do in basic algebra, then this is the equivalent of saying "zero equals one". Did you come from a math background prior to programming? @Erik You are right :) ! You can write x = x + 1 in a functional language if you wish. http://codepad.org/7n69C5KC @jleedve But its still gives impression that 0 = 1 :) +1 because this threw me a bit when I first started as well. I found this odd before I started programming, several years ago... Now I got used to it, and I actually like it. One interpretation is that this is really x'' = x' + 1, but time is implicit in programming (bottom to top of source code), while it must be made explicit in math. Does anyone know if this is why Wirth made := the assignment operator in Pascal? @GreenMatt: Wirth probably took it from ALGOL, which might well have had := to avoid the above. +1 I never had a strong math background, so this wasn't too hard for me to get used to, but I can see how it would be. ...and all the variants... like x++; or x.=1; in PHP. (not x.='1' BTW, completely different statement!) Yes, I strongly prefer := for assignment and = for equality checking. @David, @GreenMatt - Algol used :=, as apparently did BCPL. For whatever reason Thompson and/or Ritchie decided to use = and == for B, and then C. Also note that old line number BASICs you needed to use LET X=X+1 As per above, maybe ':' was hard/impossible to type on the PDP7 and 11 keyboards! Yeah, I picked up programming before algebra even, and I totally agree that this syntactic tradition is a pedagogical problem. F# (and I think OCaml) uses <- for assignment and = for constant declarations and equality, which I think is much more clear. Pascal's := irked me at first too, until I tried teaching C# to beginners and discovered that the = not being equality was extremely frustrating to them. +2 A: In Visual Basic 7 and above I found the implementation of short-circuit logical evaluation to maintain compatibility with legacy Visual Basic <=6 code a bit of a WTF: A: You can throw anything throwable in Java. class YourBoss extends Throwable { } public class Main{ public void main(String[] s) throws YourBoss { try{ throw new YourBoss(); }catch(Exception e){ }catch(Error e){ } } }  Well, _obviously_. There's nothing preventing you from writing class YourBoss : Exception in C#, either. CLR (but not C#) actually permits throwing any object, not just one inheriting from Exception. ... and with catch(Throwable t) you can also catch everything throwable and thus even prevent the termination of a thread (see ThreadDeath). Yes, but will always extends from Exception (or even RuntimeException). I've not seen nobody to extends Error (except VM guys) and Throwable. In C++ you can throw ints. I'd love to see if anyone has tried to (mis)use the Throw/Catch facilities of Java by subclassing Throwable and Catching it somewhere down the stack trace. I'd hate to see it in real life though. When main to my knowledge shan't ever throw exception, I'll be glad if you tell why it can. Ummm... isn't that the very definition of "throwable" - that it can be thrown? @David: Not a regular dailywtf.com reader, huh? :) +3 A: C#, namespace reslove order for example. namespace foo.bar.xyz{ public class Foo{ Exception e; // you'll get compile time error here.... } }  Because namespace foo.bar.Exception{ class HowDoMyWayException : ApplicationException { // because someone did this } }  Hmmm, I wouldn't exactly call this a feature. How is the compiler supposed to know the difference? It don't have to know the difference. But it should be a warning, and error only if duplicated "CLASS / STRUCT" name. If you would have done System.Exception it would be fine. +60 A: In PHP function names are not case sensitive. This might lead you to think that all identifiers in php are not case sensitive. Guess again. Variables ARE case sensitive. WTF.  function add(a, b) { return a + b; } foo = add(1, 2); Foo = Add(3, 4); echo "foo is foo"; // outputs foo is 3 echo "Foo is Foo"; // outputs Foo is 7  Classes aren't case-sensitive either. they should add a compilr option in php.ini to parse case-sensitive ! A: Anything will autometic pluralizes or singularizes any class and member names. Linq-to-Sql, for example This isn't really a programming language feature - more of a tooling feature. +4 A: in X++ (Microsoft Dynamics AX): 1) the need of a semi-colon (;) on a separate line to separate variable declaration from statements (at least up to version 4.0)  int i; int myArray[5]; ; i = 1;  2) array indexes are 1-based, so you are not allowed to read from an array using index 0 (zero) like in  int myArray[5]; ; print myArray[0]; // runtime error  this is not strange, but you are allowed to use the zero index on the left hand side of an assigment, like in  int myArray[5]; ; myArray[2] = 102; myArray[0] = 100; // this is strange print myArray[2]; // expcting 102?  what happens? The array gets initialized to it's default value, no matter what value was used in the assignment. The above code outputs 0 (zero)! Thats a terrific way to trip up people... A: Modula-2 doesn't have elseif or else if; it has elsif Some languages have elif instead (I think Python is one). PL/SQL has elsif too Perl uses elsif. ksh has if ... elif ... else ... fi. And case ... esac. +8 A: In C#, this should at least generate a compiler warning, but it doesn't: public int Something { get { return Something; } set { Something = value; } }  When called, it causes your app to crash, and you don't get a good stack trace, since it's a StackOverflowException. It's simple recursion, and one could write a perfectly valid recursively evaluated property. While the compiler could potentially be hard coded to catch some very simple cases of infinite recursion, to enforce it as a *rule* in the language would require a solution to the Halting Problem. Are you a bad enough dude to solve the Halting Problem? This particular case is simple, though. If the property does nothing but get or set itself (you'd need more than that for a valid use of a recursive property), generate a warning. I've seen too many developers and even whole teams stuck on a "mysterious crash" because of this issue, which is very hard to spot in a large code base. I think this issue is considered fixed in the current version of the language. You should be using auto properties if your property is trivial. Mehrdad: Since auto properties can't have an initial value, the typical solution is to implement the property yourself. VB .NET will raise an ERROR in this case. @Gabe auto-implemented properties can have an initial value, you just assign them in the class constructor. Dan Diplo: You mean assign them in *all* the class constructors (or make sure you chain them all with :this()). A: Java's Integer class's base-conversion static methods. :P Very few languages have this functionality built right in, it seems. How does it differ from base conversion in C/C++, Python, or any other languages? I'm not sure I understand but is this meaning autoboxing? I meant simple base-conversion functions - such as Hexadecimal to Binary, or Binary to Decimal. Java has those right in the Integer class.PS. Nice to see someone from Portugal around here :D +1 A: A Fortran compiler that I used years ago had the interesting feature that: (a) Numbers were stored high-byte first; (b) Numbers were passed to subroutines by address; (c) There was no compile-time checking of length. So you could write a program like this: (Excuse me if I mess up the syntax. It's been a long time since I've written Fortran.) INTEGER*2 FUNCTION TIMESTWO (INTEGER*2 N) RETURN N*2 ... THEN CALL THIS SOMEWHERE WITH A LONG INTEGER ... INTEGER*4 I, J I=42 J=TIMESTWO(I)  The final value of J is ... zero ! Why? Because the passed in value is 4 bytes, but the called function looks at only the first two bytes. As the first two are zero, it doubles the zero and returns it. This return value is then converted back to four bytes. This was very mysterious when I first encountered it. Almost every number I passed in to certain functions got interpreted as zero! A: Perl's CORE::open and standard library having elements of object orientation masked with a procedural interface: open ( my fh, '>', 'foobar' ); open is a constructor that operates on the reference returned by my(), and takes the arguments '>', and 'foobar'. Moreover, that being an object that is a blessed typeglob (meaning it can't hold state inside the object). More information on my perlmonks post IO::File vs CORE::open here: http://www.perlmonks.org/?node_id=763565 +4 A: Perl's [, this was mentioned in another earlier post about generic perl variables, but it deserves specific mention with better explanation. It isn't used in the wild but what it does is change the starting index of an array and here is the clincher it works globally, such that [ will modify the whole running instance of perl. More information and a quick writeup of how you can use this and its implications ;) can be found in [ is under respected at http://www.perlmonks.org/index.pl/?node_id=480333 Why not put that special mention in that question (it's CW!) or comment on that question? We don't need more duplicates. Doesn't have to be global, just scope it properly: {local [=1; ...} A: Haskell's use of Maybe and Just. Maybe a is a type constructor that returns a type of Just a, but Maybe Int won't accept just an Int, it requires it to be a Just Int or Nothing. So in essence in haskell parlance Just Int is about as much of an Int as an apple is an orange. The only connection is that Just 5 returns a type of Maybe Interger, which can be constructed with the function Just and an Integer argument. This makes sense but is about as hard to explain as it can theoretically be, which is the purpose of haskell right? So is Just really JustKindaLikeButNotAtAll yea sorta, and is Maybe really a KindaLooksLikeOrIsNothing, yea sorta again. -- Create a function that returns a Maybe Int, and return a 5, which know is definitly Int'able > let x :: Maybe Int; x = 5; <interactive>:1:24: No instance for (Num (Maybe Int)) arising from the literal 5' at <interactive>:1:24 Possible fix: add an instance declaration for (Num (Maybe Int)) In the expression: 5 In the definition of x': x = 5 > Just 5 Just 5 it :: Maybe Integer -- Create a function x which takes an Int > let x :: Int -> Int; x _ = 0; x :: Int -> Int -- Try to give it a Just Int > x Just 5 <interactive>:1:4: Couldn't match expected type Int' against inferred type Maybe t' In the second argument of ()', namely Just 5' In the expression: x Just 5 In the definition of it': it = x Just 5  Good luck reading this, I hope its right. It makes perfect sense in a statically typed language for a function expecting arguments of type Foo to refuse arguments of type Bar. Just is a function a -> Maybe a, Nothing is a Maybe a, fromJust is a function Maybe a -> a. Hope this helps. This makes sense but is about as hard to explain as it can theoretically be. If it was called NotJust and NotJustOrNothing, I would think it would be massively easier to comprehend. The only WTF is how you're totally missing the point. I don't know your background, but take String in Java, for example. It is actually a "Maybe" String, because it can be String or null. Unfortunately, the compiler does nothing to prevent you from using it as a String, which cause the dreaded null pointer exception. Well, Haskell doesn't have null. If you do something that may or may not return a result, such as getting the index of a character in a string, then you return Maybe Integer. The receiving code uses pattern match to distinguish between Just Integer and Nothing. +4 A: In c# Math.Round(2.5)==2  That's called "banker's rounding" and is pretty much standard and expected. You can always use Math.Round() method overload with additional parameter to specify other ways of rounding. "Standard and expected" depends on audience. Programmers are rarely bankers, but good to point out what is happening. I think there is an overload to Math.Round that allows you to specify if you want MidpointRounding or AwayFromZero. It's called "banker's rounding", but it's not just for bankers. If you've ever done any statistics (or banking for that matter) you know how useful this form of rounding can be. A: In c++ const char* wtf() { char buf[100]; return buf; } string s = ... + wtf() + ...;  creates interesting values in s. Partly string, partly stack contents, mixed with zeroes so that s.length()!=strlen(s.c_str()). The strangest thing is that compiler has absolutely no problems with returning pointers to stack - compiler programmers's hand would probably fall off if he would have added a warning there. TMS2810 DSP you can't modify the flash control registers while executing from flash. TI copies a register-set function to RAM and then calls it to init these registers. They reserve the space in a section call "ramfuncs". I created a local variable array and copied the function there to execute it. That way I didn't have to worry about where in RAM the function was - it took stack space only until the calling function returned. Imagine your wtf() copies wtf2() into buf[] and the calls it. It was very useful in that one situation. That's why we have '#pragma warning(disable:xxx)'. So we can ignore otherwise helpful warnings in some special cases. Trying to read uninitialized memory gives random results, film at 11. +34 A: In JavaScript, undefined is a global variable whose default value is the primitive value undefined. You can change the value of undefined: var a = {}; a.b === undefined; // true because property b is not set undefined = 42; a.b === undefined; // false  Due to the mutability of undefined, it is generally a better idea to check for undefined-ness through typeof: var a = {}; typeof a.b == "undefined"; // always true  omfg. how did I not know about this? the wheels in my head that think evil obfuscation thoughts are spinning very fast right now... void(0) is a more reliable way of getting the undefined value. However, read my answer to see why this is a bad idea as well. (in short, void(0) isn't doing what it looks like it's doing). "undefined" is not a reserved words. It's a variable name, which happens to be undefined. Being undefined is a type, shown by typeof. This also goes for Infinity and NaN. This will be changed in Firefox 3.7, by the way: http://whereswalden.com/2010/01/12/more-es5-backwards-incompatible-changes-the-global-properties-undefined-nan-and-infinity-are-now-immutable/ A: What datatype is foo? SELECT TOP 1 NULL AS foo INTO dbo.bar FROM sys.columns --trivial  Why does everything go to zero? SELECT CAST('' AS int), CAST('' AS datetime), CAST('' AS float)  ...except this SELECT CAST('' AS decimal)  What language is this? SQL?? +4 A: Another vote for JavaScript: parseInt('08') == 0  because anything with a leading 0 is interpreted as octal (weird), and invalid octal numbers evaluate to zero (BAD). I discovered this one August when code I hadn't touched in months broke on its own. It would have fixed itself in October, as it turns out. Octal support has apparently been deprecated, so future generations of JavaScripters will not have this rite of passage. This is a dupe, please delete and improve the other answer. A: In all languages today: TypeA a = (TypeA)some_operation_returning_TypeB(1,2,3); // TypeB is not inheriting TypeA  fails on runtime with "Cast to TypeA failed exception"-message (or similar). What this tells us is just how lazy programmers really are. There's no way for them to produce message "Failed to assign variable 'a' of TypeA with a value 'some_operation_returning_TypeB(1,2,3)' of TypeB". Noooo.. their motto is "thy who makes mistakes must suffer". That may be because TypeA might not be easy to initialize. Maybe it's constructor takes a string that doesn't exist in TypeB? One could argue that implicit "casts" (=simple mappings between equally named fields) to a type with a parameterless constructor should be possible (in fact, the existence of tools like AutoMapper tell us that there is a need for that). Actually, official Mapping Support as part of a language would be quite cool. Oh wait, actually you were complaining about the message being too unspecific. Yes, that sucks too. Sorry, not all languages. Scala will say "type mismatch", follow with the type expected and the type wanted and indicate the exact point of the code where the incorrect type was found. If asked to, it will then show the decision tree it used to verify whether the types were compatible or not. So, go complain about specific languages. Also, it fails at compile time, unless you explicitly tell it to take a hike, and that you know what you are doing. Well, actually compile-time errors are the good ones. They are 100% reproducible. :) Daniel: still sounds like too much work - reading the error, reading filename, reading line number, figuring out the character/column location of error.. All I need is the expression that is being casted incorrectly. So I can search all occurrences of it and ensure same error cannot happen anywhere in the program. It shows the expression giving the error. That's what I meant by "the exact point of the code". If you have a = b + c and it's c that's causing the trouble, it will show that expression and point to c. The exception comes from the cast, not the assigning of object a. At the point of the exception, it really doesn't know it is ALSO trying to assign the value to a particular object. Yes, especially .net-runtime doesn't seem to know anything about anything sometimes. Yesterday received an error "Object reference is not set to an intance". No line number, no file name, no function name, just a stupid text mocking you for your mistake. (Although it might be that this lack of information is caused by custom exception handling, will have to check.) @AareP: If you don't have debug symbols (those .pdb files you might have seen around), either because you compiled without them (aka release mode) or simply deleted them, there's no way you can know line numbers or file names. As for method names, you can always see the stack track of an exception, unless you intentionally lose it with custom exception handling. "Object reference is not set to an instance" is the message of a NullReferenceException, which is probably the most embarassing an pointless exception you can have. @Martinho Fernandes: I have .pdb files, compiling without optimization, using Debug-switch, fetching last Exception.InnerException, and my exception.StackTrace still ends at "Control.MarshalledInvoke". There is some filenames and line numbers, but not the ones responsible for the exception. Apparently things like Form.Invoke() screw up exception handling. Also loading new assemblies (for example with Type.GetType) never shows you the real problem. Error message is always "Failed to find module." (not even saying which module it can't find), even though there are tens of reasons why dll-files wont load. There's a utility for troubleshooting loading problems "fuslogvw", but even that fails to show anything sometimes.. grrr... +4 A: In Perl, objects are just blessed refs, so changing the class of an object at run time is a piece of cake: package Foo; sub new { bless {}, _[0] } package Bar; package main; my foo = Foo->new; ref(foo); # => "Foo" bless foo, 'Bar'; ref(foo); # => "Bar"  I was surprised that other languages can't do this. What a useful feature! You can do something similar in C++ but using pointer hacks. Just cast a pointer to a class to void* and then cast it to a pointer to a different class. My C++ is rusty but I don't think what you've described would have changed the class of the object itself; just of this particular pointer to the object. In Python you don't have to do bother doing this. Who cares what class an object is? haha None of what you guys commented is really equivalent to the perl thing, which is leaving the object entirely intact but changing the class of it. +8 A: In javascript (and java I think) you can escape funny characters like this: var mystring = "hello \"world\"";  if you want to put a carriage return into a string though, that's not possible. you have to use \n like so: var mystring = "hello, \nworld";  that's all normal and expected- for a programming language anyway. The weird part is that you can also escape an actual carriage return like this: var mystring = "hello, \ world";  The same as good old C syntax. But remember that standard HTML expects CR+LF ("\r\n") newlines. @Loadmaster: sure you didn't mean HTTP? afaik HTML is line-separator-agnostic It's quite handy, actually, when you need to define a veeeeery long string without messing with string concatenation operators. @Helen except that it kind of breaks down if you want to minify or do any other sort of automated whitespace manipulation. +52 A: I've always been a huge fan of the PHP error thrown when using two colons in a row out of context: Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /path/to/file/error.php on line 3 The first time I encountered this I was absolutely befuddled. +1 for PHP errors not in English (in this case hebrew). IIRC, that's a double-colon or :: symbol. Weird name though. http://en.wikipedia.org/wiki/Paamayim_Nekudotayim#PHP Yup, first time I got it, I had to wikipedia it to figure out what was going on. I speak Hebrew and I didn't understand that the first time I saw it! I really want to show this to a "Jews did 9/11" conspiracy nut. They'll think it's proof that the Web is secretly run by Zionists. The translation is something along the lines of "double dots, twice". i.e. ->NULL-> exception error. But at least you can Google for it when you see it, I mean it's a pretty unique term :) A: In MySQL string comparisons are case-insensitive. > SELECT * FROM blah WHERE foo = 'BAR'; > SELECT * FROM blah WHERE foo = 'Bar'; > SELECT * FROM blah WHERE foo = 'bAr';  Are all equivelent. Not only that they will match any value of foo that looks like 'bar' (e.g. if foo = 'bar' it will match for BAR, baR, bAR, etc.). this is by design and configurable Most of these strange language features are by design. Why point it out for this one? Like said, it is configurable, not a definite decision made by the developers. There's nothing weird about making it configurable nor the selected default. A: # PHP PHP has inconsistent handling of overloading for instance variables and methods. Consider: class Foo { private var = 'avalue'; private function doStuff() { return "Stuff"; } public function __get(var) { return this->var; } public function __call(func, array args = array()) { return call_user_func_array(array(this, func), args); } } foo = new Foo; var_dump(foo->var); var_dump(foo->doStuff());  The dump of var works. Even though var is private, __get() is invoked for any member which doesn’t exist or is inaccessable, and it returns the correct value. This is not the case for doStuff(), which fails with: Fatal error: Call to private method Foo::doStuff() from context ”.”  I think a lot of these work in C-style languages, but I’m not sure. 1. Pass a here document as a function argument: function foo(message) { echo message . "\n"; } foo(<<<EOF Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc blandit sem eleifend libero rhoncus iaculis. Nullam eget nisi at purus vestibulum tristique eu sit amet lorem. EOF );  2. You can assign a variable in an argument list. foo(message = "Hello"); echo message;  This works because an assignment is an expression which returns the assigned value. It’s the cause of one of the most common C-style bugs, performing an assignment instead of a comparison. # Python In Python, mutable default function arguments cause unexpected results: def append(thing, collection=[]): collection.append(thing) return collection print append("foo") # -> ['foo'] print append("bar") # -> ['foo', 'bar'] print append("baz", []) # -> ['baz'] print append("quux") # -> ['foo', 'bar', 'quux']  The empty list is initialized at function definition time, not call time, so any changes to it persist across function invocations. # MySQL Case Sensitivity MySQL has really unusual case sensitivity rules: Tables are case sensitive, column names – and string values aren't: mysql> CREATE TEMPORARY TABLE Foo (name varchar(128) NOT NULL); DESCRIBE foo; ERROR 1146 (42S02): Table 'foo' doesn't exist mysql> DESCRIBE Foo; +-------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------+--------------+------+-----+---------+-------+ | name | varchar(128) | NO | | NULL | | +-------+--------------+------+-----+---------+-------+ 1 row in set (0.06 sec) mysql> INSERT INTO Foo (name) VALUES ('bar'), ('baz'); Query OK, 2 row affected (0.05 sec) mysql> SELECT * FROM Foo WHERE name = 'BAR'; +------+ | name | +------+ | bar | +------+ 1 row in set (0.12 sec) mysql> SELECT * FROM Foo WHERE name = 'bAr'; +------+ | name | +------+ | bar | +------+ 1 row in set (0.05 sec)  -1. One per answer. Check duplicates too. +53 A: In javascript, void is not a keyword, it is not a type declaration, nor is it a variable name, and it is also not a function, nor is it an object. void is a prefix operator, similar to -, --, ++, and !. You can prefix it to any expression, and that expression will evaluate to undefined. it is frequently used in bookmarklets, and inline event handlers, as in this somewhat frequent example: <a href="javascript:void(0)">do nothing</a>  the way it's used in that example makes it look like a function invokation, when really it's just an overly clever way of getting the primitive undefined value. Most people don't really understand the true nature of void in javascript, and that can lead to a lot of nasty bugs and weird unexpected things happening. Unfortunately, I think the void operator is the only truly guaranteed way to get the undefined value in javascript, since undefined, as pointed out in another answer, is a variable name that can be reassigned, and {}.a can be messed up by Object.prototype.a = 'foo' update: I thought of another way to generate undefined: (function(){}())  eh, a bit verbose though, and it's even less clear that returning "undefined" is its purpose. I usually create normal divs/spans with an onclick event and a css style of cursor:pointer (or something like that) I just use href="#somemeaningfulfragmentid", and when I assign a click handler I get it to return false. I can often encode some useful things in the fragment id that I can retrieve in the click handler. Then if javascript is disabled, the link can still do something useful if there's an element with a cooresponding id- The browser can scroll to it. Alternatively, the link points to a regular page that reproduces as best as possible the javascript functionality. I thought it was normally done like this: (function(){})(), with the parentheses in different places @Eric I invite you to look at the edit history for my answer. @Eric "There are some people who would put the golden paren around the function, and not around the whole invocation. That doesn't make sense to me, because what we're trying to tell the user is: look at the whole thing. Putting parentheses around just part of it is, I think, counter productive. I think the whole thing needs to be wrapped in parens." -Douglas Crockford. also <a href="" onClick="return undefined">do nothing</a> same thing, and why would you need it? @hasen j: add tabindex=0 to those elements, otherwise they won't be keyboard-accessible. @Talvi Watia that onclick handler shouldn't make any difference. The jQuery library does it this way: (function(, undefined){})(jQuery); @Adam Lassek yeah! I discovered that a while back! strangely, jslint complains about that pattern. @Breton Well, Crockford has been pretty clear that jslint is merely his opinion about javascript code. I think it's perfectly safe to ignore if you understand exactly why you're doing it. Why not just use a variable, like this? var foo; Variables are assigned the default value of undefined, regardless of what the variable "undefined" is. The same goes for function arguments, as already noted. +7 A: Reading a line from a text file in Java. BufferedReader in = null; try { in = new BufferedReader(new FileReader("filename")); String str; str = in.readLine(); if (str != null) { ... } } catch (IOException e) { ... } finally { try { if (in != null) { in.close(); } } catch (IOException e) {} }  Ugh. Although I admit it is not strange...just evil. :-) A shorter, more idiomatic version: try { BufferedReader in = new BufferedReader(new FileReader("filename")); try { String str = in.readLine(); while (str != null) { str = in.readLine(); } } finally { in.close(); } } catch (IOException e) { e.printStackTrace(); }  So much code and you still got it wrong. ;) The close() call would better be inside a finally section to make sure the file handle gets released also in case of an exception is thrown. Fair enough, fixed. Hopefully. :-) Now it does not compile because 'in' can be uninitialized; so you have additionally to initialize it to null and check it in finally (3 more lines!). More than that, close() errors should be handled too! Don't initialise it to null, take the resource acquisition out of the try-finally. I added how I would write it. I left the other version in though, cause that it is so hard to get right is exactly the point. Perl's while(<>){print;} never looked better. @sarnold - security!!! +4 A: In C++, you can do: std::string my_str; std::string my_str_concat = my_str + "foo";  But you can't do: std::string my_str_concat = "foo" + my_str;  Operator overloading is generally subject to WTF. Actually the Visual Studio 2008 compiler supports this just fine. Not sure how they do it though. You can have a operator+(const char *, std::string) function, which will allow "foo" + my_str. In an operator overload, you need at least one user-defined type (class, enum, etc.), but it needn't be the first one. Operator overloading is usually not a good idea, but it can be very useful on occasion. This answer is plain wrong, you can indeed do what you claim you cannot. Operator overloading is generally sensible. +6 A: In javaScript, NaN is a global variable. And undefined! (15chrlmtislame) +7 A: For me it's definitely the PLEASE modifier in INTERCAL. If PLEASE does not appear often enough, the program is considered insufficiently polite, and the error message says this; if too often, the program could be rejected as excessively polite. I really love this one, but I'd like to know the definition of too often and not often enough? @Richo: in C-INTERCAL the correct amount is between one-third and two-thirds. I've used please as a shell alias for sudo. INTERCAL is not ment to be a serious language. It's more of an exotic joke language. Just look at READ OUT and WRITE IN instructions. +6 A: The most weird feature I know of is from C++ world : SFINAE. The worst is that it happens to actually be very usefull, extensive use of SFINAE in BOOST is proof enough for me. +4 A: In ColdFusion arrays start at 1. That's how most languages did it before C rose to such prominence that it began influencing all the other new languages. You can certainly argue that starting from 1 is more logical and intuitive. This may not be the real reason for the decision, but C's need to start from 0 seems to stem from the equivalence between array indexing and pointer arithmetic rather than any philosophical argument that counting from 0 is better. It works just as well either way -- we're just trained to start from 0 now. In Perl arrays start at [ -- default 0, but it's variable. It's also much easier to create multidimensional arrays if indices start at 0, 'a[i*n+j]' vs 'a[(i-1)*n+j]'. You see similar indexing in fortran. And Matlab also starts at 1. +17 A: MUMPS. There are lots of WTF features, I've picked one, the if statement. (Note that I'm using a rather verbose coding style below in order to accomodate those who don't know the language; real MUMPS code is usually more inscrutable to the uninitiated.) if x>10 do myTag(x) ; in MUMPS "tag" means procedure/function else do otherTag(x)  This is similar to saying in Java: if (x > 10) { myMethod(x); } else { otherMethod(x); }  Except that in MUMPS, the else statement isn't syntactically part of the if block, it is a separate statement that works by examining the built-in variable TEST. Every time you execute an if statement it sets TEST to the result of the if statement. The else statement actually means "execute the rest of line if TEST is false, otherwise skip to the next line". This means that if x was greater than 10 and thus the first line called myTag, and myTag contains if statements, then the behavior of the else depends not on the if in the line above it but on the last if evaluated inside of myTag! Because of this "feature", MUMPS coders are generally taught write the above code like this to be safe: if x>10 do myTag(x) if 1 else do otherTag(x)  The if 1 at the end of the first line ensures that TEST is set correctly before control proceeds to the next line. (BTW, the spacing here has to be just so, with two spaces after the else and one space in all the other places. The spacing is odd but at least it's very orthogonal once you understand the pattern.) This is the most staggeringly bad piece of language design I have seen yet. My heart goes out to you and your fellow MUMPS programmers. At least the irritation of those quirks is moderate somewhat by the small size of the language. TBH what really gets me is that MUMPS has a very powerful type abstraction -- efficient sorted n-ary trees -- but they are not first-class objects. There is no other aggregate data type. The language lacks reference or pointer types so you can't, e.g., build a tree from the bottom up. This makes some algorithms very awkward to implement. That's absurd! Absurd I tell you! A: Not so long ago, when I first descoverd the C Language in my CS class, it was very strange to see the way pointers behaived. we just wrote programs and guess what it would do, until they get the right behavior pointers are the most natural thing in the world :P Sometimes I feel at a loss that I never had a "Aha!" moment with pointers. Somehow pointers always felt natural to me. Same goes for recursion. A: The C preprocessor and its usages. Specifically preprocessor metaprogramming and using the preprocessor to generate portable code -- total mindfcuk. +129 A: Duff's device in C! In C one can interlace a do/while with a switch statement. Here an example of a memcpy using this method: void duff_memcpy( char* to, char* from, size_t count ) { size_t n = (count+7)/8; switch( count%8 ) { case 0: do{ *to++ = *from++; case 7: *to++ = *from++; case 6: *to++ = *from++; case 5: *to++ = *from++; case 4: *to++ = *from++; case 3: *to++ = *from++; case 2: *to++ = *from++; case 1: *to++ = *from++; }while(--n>0); } }  wow, never seen this before WTF!!! That's one I didn't know! Duff's device is probably a good reason for the switch statement not having a break by default ;-) However, I did not yet see any other good use of interlaced switch and loop - but probably there is one. Oh wait, yes, there is another use: coroutines and protothreads. I will remember this. Oh, man. So many mysterious cornors of a language. It's part of the hacker's test, in fact. :-) This is so wrong. You jump from outside the loop straight to the middle of the loop, right? You never actually come across the do{ .So what would happen if you put the while() behind case 0: ? Does it still loop? Or is that exactly why the while needs to be at the end?C suddenly feels like a interpreted language to me. @frunsi: "Duff's device is probably a good reason for the switch statement not having a break by default" - Always make the common case the default. I would not exactly say this is the common case.. @mcv probably easiest if you try to read it as assembly code, i.e. the while at the end is a (conditional) JMP back to the do, which explains why you can skip the do and still end up in the loop. this only works for n > 0, am I right? @afriza: yes, this code looks like it will go wild for n==0.. Do keep in mind that Duff's Device generally produces WORSE code than the normal looping statement for modern compilers, which know how to (better) loop unrolling than you can do by hand. @frunsi: Duff himself, publishing it, claimed something like this: "This definitely provides an argument in the discussion whether switch should fall through by default, but I'm not sure if the argument is for or against it." @SF.: yes true, in a no-default-fall-through world, duff's device could probably also work (with a fallthrough or continue keyword). and in that world most other code using a switch statement would be shorter. however, it is too late to change that for C and C-like languages (everyone except newbies expect the default-fall-through nowadays). +1 I _love_ this feature. I do wish the case_is_valid_in_subblock worked for nested switches though... This technique can also be used to implement stackless threads in C, as in the Contiki operating system: http://www.sics.se/~adam/pt/ +24 A: An amusing side effect of Python's everything-is-really-a-reference: >>> a = [[1]] * 7 >>> a [[1], [1], [1], [1], [1], [1], [1]] >>> a[0][0] = 2 >>> a [[2], [2], [2], [2], [2], [2], [2]]  you asked for 7times the same object not 7 times for a copy. I think this is normal, not WTF normal yes, but I know I've been bitten by this one a few times Not coming from a Python background, that really threw me off. +1 You can use this code in Ruby, it does the same thing. Try def x(y, z=[]): z.append(y); print z +2 A: I think this one isn't actually a "language feature" (C) and I'm quite possibly being widely ignorant in posting it, but I couldn't figure why this happens, so I'll ask. If it turns out to be related to some odd language feature.. well, it really made me "WTF", so it's worth this place. int a = 0; int *p = &a; printf("%d, %d, %d.\n", *p, (*p)++, *p); // Outputs "1, 0, 0.\n" on MinGW's GCC 4.4.1  Why? -- edit Just got it, and it's not big deal. I can sense the C++ gurus laughing at me now. I guess the order in which function parameters are evaluated is unspecified, so compilers are free to call them as they wish (and I think I've read that one somewhere in boost's documentation). In this case, the argument statements were evaluated backwards, probably reflecting the calling convention of the function. +62 A: powerbasic (www.powerbasic.com) includes the compiler directive: # BLOAT {bloatsize}  this increases the size of the compiled executable by <bloatsize> bytes. this was put in the compiler in case people creating the executable don't like the small size of the generated executable. it makes the EXE seem bigger to compete with bloated programming languages:) Haha yuk. I've heard about developers deliberately slowing down some operations (e.g. a search) because it helps people believe that it is really doing something. Similar thing I guess. This reminds me of something I read recently. They were testing an FPS and decided to increase the number of hit points the bad guys had. Then they asked the testers how they AI was, and they swore it was much smarter. But the AI hadn't changed, just the hit points. People have a certain narrative about the world in their heads, and if you understand and match their expectations they will just assume it validates their narrative. I used to add a lot of extra slowdown to my programs to make them look like they were doing something complicated. Back in elementary school, that is. Funny ...................... +7 A: More of a platform feature than a language feature: on the iPhone, create an infinite loop with a few computations inside and run your program. Your phone will heat up and you can use it as a hand-warmer when it's cold outside. I don't think that that is very good for the phone, though... +1 for best use of iPhone other than paperweight or thrown missile +26 A: Some early dynamic languages (including, if I remember correctly, early versions of Perl) hadn't figured out what was good dynamism and what was bad dynamism. So some of them allowed this: 1 = 2;  After that statement, the following would be true: if(1 + 1 == 4)  or perhaps: 2 = 2.5; then if(2 + 2 == 5) What would 2=1; 5=2; 5+2=? Is it 3? Or 2? +17 A: In C, the sizeof operator does not evaluate its argument. This allows one to write code that looks wrong but is correct. For example, an idiomatic way to call malloc(), given a type T is: #include <stdlib.h> T *data = NULL; data = malloc(sizeof *data);  Here, *data is not evaluated when in the sizeof operator (data is NULL, so if it were evaluated, Bad Things would happen!). This allows one to write surprising code, to newcomers anyway. Note that no one in their right minds would actually do this: #include <stdio.h> int main() { int x = 1; size_t sz = sizeof(x++); printf("%d\n", x); return 0; }  This prints 1, not 2, because x never gets incremented. For some real fun/confusion with sizeof: #include <stdio.h> int main(void) { char a[] = "Hello"; size_t s1 = sizeof a; size_t s2 = sizeof ("Hi", a); printf("%zu %zu\n", s1, s2); return 0; }  (The confusion is only if one is confused about arrays, pointers, and operators.) also used a lot in c++ for SFINAE stuff in templates Doesn't this just boil down to the fact that sizeof is a compile time operator? @Dykam, yes it does, and you are absolutely right. Given that, the answer is obvious, but it still "seems" strange, particularly because the operator, unlike other operators, is a word, and almost looks like a function call. Rather than casting to int, you should use %zu to print out size_t types. @Chris: I was being lazy: I know that s1 and s2 are small enough to fit in int. I did the cast because %zu is C99 only. One benefit of sizeof() not evaluating its innards is that it allows you to create a macro expanding to an array followed by its count: #define STRING_ARRAY(...) ( (const char *[]){__VA_ARGS__} ), (sizeof( (const char *[]){__VA_ARGS__} ) / sizeof(const char *)) +6 A: In PHP, you can reference variables using a sigil and a string literal or variable containing the name of the variable, for example: {'foo'} = 'test'; echo foo;  This will print "test". The strange thing about this behavior is that you can also use non-strings as variable names, for example: {array()} = 'test'; echo {array()}; {NULL} = 'test'; echo {NULL};  Now we have variables named array() and even NULL! All containing the string "test". {array()} actually becomes Array (because converting an array to string always returns Array). So you cannot use actual arrays here. If only this worked in .js, {===}='==';, then == would finally be correct. +32 A: In JavaScript, you can use a double bitwise negation (~~n) as a replacement for Math.floor(n) (if n is a positive number) or parseInt(n, 10) (even if n is negative). n|n and n&n always yield the same results as ~~n. var n = Math.PI; n; // 3.141592653589793 Math.floor(n); // 3 parseInt(n, 10); // 3 ~~n; // 3 n|n; // 3 n&n; // 3 // ~~n works as a replacement for parseInt() with negative numbers… ~~(-n); // -3 (-n)|(-n); // -3 (-n)&(-n); // -3 parseInt(-n, 10); // -3 // …although it doesn’t replace Math.floor() for negative numbers Math.floor(-n); // -4  A single bitwise negation (~) calculates -(parseInt(n, 10) + 1), so two bitwise negations will return -(-(parseInt(n, 10) + 1) + 1). This is very interesting! Also note that, for some reason, function parseInt(x, 10) is about 3 times slower than Math.floor(). Bitwise operators will truncate their inputs to signed 32 bit values. Math.floor(4294967295.1) == 4294967295; parseInt("4294967295.1") == 4294967295; (4294967295.1 | 4294967295.1) == -1; That’s right, @rpetrich. I should’ve mentioned that. I updated the answer with a link to [the performance test case on jsPerf](http://jsperf.com/rounding-numbers-down/4). How does something like this even get discovered? +2 A: In Lisp you can copy a list, and you can copy a vector, and you can copy a struct, and you can copy a CLOS object... ... but you cannot copy an array or a hash table. Isn't LISP a WTF language anyway?) ) ) ) ) ) ) +2 A: JCL Conditional execution. //STEP02 EXEC PGM=PROG02,COND=(4,GT,STEP01) .  This features allows you to run or not run a step depending on the return code from previous steps. Quite a nice feature really. Except for a couple of small features which turn the logic inside out and backwards. First the step does NOT run if the condition is true. Secondly the 4,GT,STEP01 actually means "if the return code from STEP01 is greater than 4" So the whole thing means "Do not run this step if the return code from STEP01 is greater than 4". Which is the almost but not quite the same as a naive interpretation "Run the step if 4 is greater than the return code from STEP01". Given that only time you ever look at these things seriously is about 2.30 am with a frantic nightshift operator at the other end of the line this double ambiguity leads to serious headaches. Been there--done that. I know exactly where you're coming from. +7 A: That's because sizeof is not a function, it's a macro. It's not a macro, it's an operator. But that doesn't explain the discrepancy. +3 A: not that this is heavily used, but syntax of C++'s "return reference to static-size array" is weird: struct SuperFoo { int (&getFoo() const)[10] { static int foo[10]; return foo; } }  ofc, in above case method can be declared as static const A: Perl. print "Foo\n" unless foo; +19 A: In PHP, a string is as good as a function pointer: x = "foo"; function foo(){ echo "wtf"; } x(); # "wtf"  Unfortunately, this doesn't work: "foo"();  PHP has a crap load of these syntax inconsistency, like you can't do this, function()[index] The one that bothers me the most is string interpolation. You can interpolate any variable that starts with a , but modules don't start with . String is also good as class name: ob = new className(); @Kendall Hopkins: You can define function elem(array, key) { return array[key]; } to get round this and then say elem(someFn(), index); without PHP complaining. I've got a whole library of this stuff: http://github.com/olliesaunders/fluidics The real WTF is using " for function calls in PHP. ...and # instead of // for comments. You are you use {'foo'}() instead +5 A: C++: void f(int bitand i){ //WTF i++; } int main(){ int i = 0; f(i); cout << i << endl; //1 return 0; }  But does anybody ever actually use the iso646 stuff? well maybe some people would use it when they knew about these features... but these are mentioned nearly nowhere.But surely everybody has to learn to read and use the "normal" operators anyway, so its quite understandable they arent mentioned that often.The main intention behind these macros is (according to wikipedia): that some of the standard operators sometimes cannot be quickly or easily typed with some international keyboard layouts. So these macros were introduced .. They're not macros, but keywords. In C, they're macro's from <iso646.h>. And that header name tells you the real reason for their introduction: One ISO standard (646) specified a standard spelling, and at least two others (ISO C and ISO C++) build on that. Also at http://stackoverflow.com/questions/1995113/strangest-language-feature/2022131#2022131 ISO 646 was an early standard for national character sets, most of which didn't include all the characters needed by C. +12 A: In PHP "true", "false" and "null" are constants which normally cannot be overridden. However, with the introduction of namespaces in PHP >=5.3, one can now redefine these constants within any namespace but the global namespace. Which can lead to the following behaviour : namespace { define('test\true', 42); define('test\false', 42); define('test\null', 42); } namespace test { var_dump(true === false && false === null); // is (bool) true }  Of course if you want your trues to be true, you can always import true from the global namespace namespace test { var_dump(\true === \false); // is (bool) false }  If it was global, define("TRUE",false,false);define("true",true,false); would be echo(TRUE==false);//echos true and echo(true==false);//echos false... TRUE would then mean not really true, unless its lowercase. +7 A: In MUMPS you can have a GOTO with offset. If you have (my MUMPS is rusty...) some_label if x=1 do_something else do_something_else  Then the code  goto some_label+1  Will jump to the ELSE statement... My eyes... the goggles, they do nothing! +16 A: JavaScript dates are full of WTF. var d = new Date("1/1/2001"); var wtfyear = d.getYear(); // 101 (the year - 1900) // to get the *actual* year, use d.getFullYear() var wtfmonth = d.getMonth(); // 0 // months are 0-based!  Ever heard of Java's Date API? Same thing. Have to love backwards compatibility and 2 digit years. :-) Supposedly Joda time is *da bomb* man ;) Yeah, the people who wrote Java's Date and Calendar classes need to be shot. Joda time is a lot better, but still not quite where it needs to be. Beter use(TimeCategory) in Groovy. It fixes the Date class and adds cool stuff to Integer. new String[] { "jan", "feb", ... }[date.getMonth()]... might be an explanation for the behavior. But then, DAY_OF_WEEK is 1-based...I'd love to hear the reasoning for months being 0-based and days of week, 1-based. C's localtime and gmtime functions work the same way. +42 A: Python 2.x >>>True = False >>>True False  You can really make someone become crazy with this one. You can't do this in Python 3.x anymore. It gives a syntax error. Wow... :) This is weird. Hmm. I think this might be the answer to questions like "Why should I use Python 3?" (eg http://stackoverflow.com/questions/1921742/python-should-one-start-a-new-project-directly-in-python-3-x) reminds me of #define if while That's messed up, and hilarious. For twice the fun, True,False = False,True. What makes it doubly awful is that 1==1 afterwards still returns True. It wouldn't be such a big deal if True and False were simply consistent (global) labels +4 A: In Python: abs((10+5j)-(25+-5j))  Returns ~18.03, which is the distance between the points (10,5) and (25,5) by the Pythagoras theorem. This fact happens because Python has native language support to complex numbers in the form of 2+2j for example. Since the absolute value of a complex number in form of a+bj = sqrt(a^2+b^2), we get the distance while subtracting one complex number from another and then apply the abs (absolute) function over it. What is so strange about this? How else would you calculate the absolute value of complex numbers? The strange is, as I cited, the native language support to complex numbers, which brings some strange syntax constructions. +1 A: They allow you to break out of multiple control-blocks with a single break. JScript has them, too (not sute about JavaScript). A: C# has a feature called "extension methods", which are roughly analogous to Ruby mix-ins - Essentially, you can add a method to any pre-existing class definition (for instance, you oould add "reverse()" to String if you were so inclined). That alone is fine- The "Weird" part is that you can add these extension methods, with a method body and everything, to an interface. On the one hand, this can be handy as a way to add a single method to a whole swath of classes which aren't part of the same inheritance tree. On the other, you're adding fleshed out methods to interfaces, essentially breaking the very definition of an interface. Unfortunately you cannot do everything you can with Ruby mixins, especially adding per-instance state (without doing crazy stuff with dictionaries...). Also, extension methods do not break the definition of an interface in any way. You are not breaking the contract. You are not adding *anything* to the interface. The ability to call it as if it was part of the interface is just syntax sugar. Extension methods are just like any other static helper method, with that fine sugar on top. I think this is a pretty usefull feature. Although it doesn't fare well when ofuscating code. A: ## Try, except, else try: pass except: pass else: pass finally: pass  If no exception was caught the else part is executed. Makes sense, but at first I really hadn't any clue what it does. def show_square(string): try: n = int(string, 10) except ValueError: print "I can't do that, Dave." else: print n * n  Since I've learned this feature in Python, I'm really missing it in other languages. It doesn't seem useful; it's equivalent to putting the print n * n after the n = int(string, 10) No it isn't. The else block is only executed if an exception is raised but isn't of type (in this case) ValueError. @Chinmay Kanchi: That's wrong too, else block is executed if no exection where raised at all.If error happens in else block it isn't caught (as opposed to print n*n being put after n=int(...)) and if exception is raised and processed in except clause, else block isn't executed (as opposed to print being put after all try..except structure) I wouldn't really call this a "strange" feature.. its too useful in most languages. +3 A: ## Digraphs and alternative tokens C (ISO/IEC 9899:1999, 6.4.6/3) and C++ (ISO/IEC 14882:2003, 2.5) have a feature that is rarely used, called "digraphs" by C and "alternative tokens" by C++. These differ from trigraphs mainly because string literals containing them will never be interpreted differently. %:include <stdio.h> int main() <% int a<:10:> = <%0%>; printf("Here's the 5th element of 'a': %d\n", a<:4:>); puts("Evil, eh? %:>"); return 0; %>  C++ has many more, including and, or, and not which are required to behave as &&, ||, and !. C has these too, but requires that <iso646.h> be included to use them, treating them as macros rather than tokens. The C++ header <ciso646> is literally an empty file. It's worth noting that GCC implements support for this weird language feature, but lots of other compilers choke and die when trying to compile the above segment of code. this is essentially a dupe of this high-voted answer http://stackoverflow.com/questions/1995113/strangest-language-feature/1995134#1995134, since digraphs and trigraphs are very closely related. rmeador: Edited to show how it's not a dupe. +5 A: I'm fond of the lack of operator precedence in Smalltalk 2 * 3 + 4 * 5 = 6 + 4 * 5 = 10 * 5 = 50 instead of 2 * 3 + 4 * 5 = 6 + 4 * 5 = 6 + 20 = 26 This is due to the object nature of smalltalk and the fact that messages are passed left to right. If the message * is sent to the 2 with the number 3 as a parameter, the response of that message is 6. Pretty awesome, you can even monkey patch it if you're feeling evil. I like that. BODMAS is always confusing IMHO and most people use brackets anyway, so straight left-to-right execution is nice. Fine with me as long as you can use parens to specify precedence Weird. Not sure why someone would like this. Perhaps it's because I've got a bit of math nerd in me. +8 A: In SQL NULL is not equal to NULL So you can't do: WHERE myValue == NULL  This will always return false. NULL != NULL  It makes perfect sense. I have should have two values but I don't know what they are. Are they the same value? I DO NOT KNOW. @Tom: but Null is a defined value: the absence of anything else. There should be another value for this. @Tom if you don't know what it is, then what's it doing in the database? NULL should be denoted by 0/0 No, NULL is NULL. And it's not equal to NULL, because it's not really a value. And it doesn't mean "I don't know" it just means "There is no value for this column in this row". Really, SQL uses three-valued logic. So the result of a comparison can be true, false or NULL. The result of myValue = NULL is always NULL, and so is the result of myValue != NULL. The problem is there's more than one sensible way to define the meaning of NULL (as shown by the above comments) and those different meanings imply different semantics for things like equality tests. There is no way to satisfy all interpretations at once. The real WTF is using == in SQL. Comparisons to NULL make sense if NULL is interpreted as unknown. But SQL isn't consistent about that. (If it were, SUM would return NULL if any summed value is NULL.) The real WTF is that fact that it is valid sql, that returns nothing.It ought to be at least a warning. Use IS and IS NOT for comparing NULLs. A: Python's ternary operator In Python, the C ternary operator (C++ example: bool isNegative = i < 0 ? true : false;) is available as syntactic sugar: >>> i = 1 >>> "It is positive" if i >= 0 else "It is negative!" 'It is positive' >>> i = -1 >>> "It is positive" if i >= 0 else "It is negative!" 'It is negative!'  It's not really strange but a feature. The odd thing is the changed order (A if CONDITION else B) in comparison to the (IMO more logical) order in C (CONDITION ? A : B). IIRC it's justified by looking at first (True) value as primary and second value as fallback (like in x = int(x) if x is not None else 0). +2 A: Java Generics Are a WTF: List<String> ls = new ArrayList<String>(); //1 List<Object> lo = ls; //2  2: Is illegal (???) this is puzzling but you have to thing what could happen next: lo.add(new Object()); String s = ls.get(0);  We would be assigning an Object to a String reference, oh noes! And like this there a lots of gotchas around them. the same is true of templates in C++ and generics in C#, although I believe the next (maybe now current?) version of C# allows this. it's not a WTF, it's a consequence of the compiler not knowing if the template/generic parameter is covariant or contravariant I think Java screwed up a whole generation of programmers by making its arrays covariant. the real wtf with java generics is type erasure The worst part about java generics is that they didn't want to bother to extend the JVM so they just coded it all into the compiler... That in my opinion results in most of the generics problems in java. @rmeador: yes, C# 4 will have covariance and contravariance in interface type parameters. But IList<T> won't be one of the changes, because of the problem migsho showed. But IEnumerable<object> foo = new List<string>() will be legal, yes. A: In C, a[b][c] is exactly the same thing as c[b[a]]. this is a dupe of the current highest-voted answer... Kind of - this applies the a[b]==b[a] transformation twice. Could be useful in the real world. +20 A: In Scala, there are no operators, just methods. So a + b - c is actually the same as a.+(b).-(c). In this, it is equal to Smalltalk. However, unlike Smalltalk, precedence is taken into account. The rules are based on the first character, so an hypothetical method called *+ would have precedence over one called +*. An exception is made so that any method ending in = will have the same precedence as == -- meaning !! and != (non-hypothetical methods) have different precedence. All ASCII letters have the lowest precedence, but all non-ASCII (unicode) characters have the highest precedence. So if you wrote a method is comparing two ints, then 2 + 2 is 1 + 3 would compile and be true. Were you to write it in portuguese, é, then 2 + 2 é 1 + 3 would result in error, as it would see that as 2 + (2 é 1) + 3. And, just to top off the WTF of operators in Scala, all methods ending in : are right-associative instead of left-associative. That means that 1 :: 2 :: Nil is equivalent to Nil.::(2).::(1) instead of 1.::(2).::(Nil). Por essas e por outras que eu encontrei, tenho certeza que Scala não irá substituir, em grande escala, o uso da linguagem Java. Será como o Groovy. I hope otherwise, actually. On the WTF-meter, that's really small change compared to Java. I like that you can define right-associative operators. It is a type inferred functional language. +1 A: Reverse Polish Notation (RPN). That means the arguments precede the function. Or, in other words, you add two and two by writing 2 2 +. Languages featuring that WTF include Forth, Postscript (yes, of laser printers) and Factor. HP made a microwave oven once that had no Start button. To reheat macaroni at half power for 3 minutes, you'd press 3 [Enter] .5 [y^x] In what way is RPN a WTF? @David It is unusual, and completely different from standard convention. @Daniel: It isn't unusual where it's used, and a whole lot of things in computer languages are different from standard non-computer conventions. RPN has been used in some very popular calculators, so many people have some familiarity with it. Forth isn't exactly a mainstream language, but I don't see RPN as a WTF. @David "where it's used" kind of defeats the whole point of unusual. Nothing is unusual where it's used. Now, suppose you went to the university nearest of you, and inquired graduating CS students. What percentage of them do you expect to have seen it before, much less used it? @Daniel: Less so than maybe ten years ago, when a whole lot of engineers used RPN calculators. Since then, HP is no longer run by engineers. Still, one of the early iPhone calculator apps worked with reverse Polish (I bought it, as I dislike doing complicated things with infix calculators). Moreover, anybody who's taken a compilers class will be familiar with it. I think it's more common than you think. @David And each of those engineers probably thought "wtf?!" when they first saw it. RPN is different from what we're used to, but it's really easy to implement. It's not a WTF, it's a FTW (double entendre). +7 A: Forth has some strange things about its control structures. First, because it is a reverse polish notation language, the condition precedes the IF, as in: x 0 = IF  Now, to close the conditional block, one uses the keyword THEN: x 0 = IF ." Equals zero!" THEN  Now the real WTF begins. What IF does is compile a conditional forward jump, and place on a stack the address of the jump offset. When THEN is found, it pops that address from the stack, computes the actual offset, and then compile that. The ELSE, on the other hand, compiles an inconditional forward jump, pops an address from the stack, pushes a new address on the stack, computes the offset for the popped address, and then compiles that offset. Meaning the syntax is this: x 0 = IF ." Equals zero!" ELSE ." Not equal to zero!" THEN  The first and second statements are compiled like this: x LITERAL 0 = (0BRANCH) LITERAL offset SLITERAL" Equals zero!" (DOTQ) x LITERAL 0 = (0BRANCH) LITERAL offset SLITERAL" Equals zero!" (DOTQ) BRANCH LITERAL offset SLITERAL" Not equal to zero!" (DOTQ)  To compound the weirdness, that behavior is not hidden. It is part of the ANSI specification of the language, and can be freely be taken advantage of, either by constructing custom flow control structures or by combining them in interesting ways. For example, take Forth's WHILE loop: BEGIN x 10 < WHILE x 1+ to x REPEAT  The part between BEGIN and WHILE is arbitrary code, so you can actually have code execute before and after the conditional test in a single control structure. That's by design, but the following, though allowed, is not: BEGIN DUP 2 > WHILE DUP 5 < WHILE DUP 1+ REPEAT 123 ELSE 345 THEN  Which takes advantage of how each control flow word works to combine two WHILE statements, and, to boot, add a different post-loop code for each exit. And just to show I'm not kidding, I just copied that small snippet from a code on the Internet, with minor modifications to simplify it. +4 A: In MAXScript, all operators are treated equal. So, a = b + c sets a equal to b, then calculates the sum a+c, and discards the result. +15 A: Might have already been said (and maybe this isn't so strange to some) but I thought this was pretty cool: In Javascript, declaring the parameters a function accepts is only a convenience to the programmer. All variables passed through the function call are accessible by the keyword "arguments". So the following would alert "world": <script type="text/javascript"> function blah(){ alert(arguments[1]); } blah("hello", "world"); </script>  cmcculloh, it's a documented feature, nothing strange ;) Yep, I assumed a lot of these were documented... Maybe not. It's still a strange language feature imo. The real WTF here is that arguments are not an Array. Seems typical for allowing variable length arguments. Sort of like PHP's func_get_args() function, except you'd actually have to type out arguments = func_get_args();. And if you really don't like cluttering up function declarations with parameters and leaving everyone who reuses your code hating you, you can do this: function do_something() {list(var1, var2, var3) = func_get_args();} +1 A: In PHP, you have to explicitly reference globals and explicitly use this-> for class variables. Makes refactoring fun. You cannot promote a variable/argument to a global or a class member without finding all points of usage. have to? you could try ::... +6 A: In Java, if the value of x is NaN then x == x returns false and x != x returns true. This is in the definition of NaN, it should be true in any language which uses IEE floating point. If the value is not a number it cannot be equal to anything. Regardless of the reasoning behind it, when I see if (x!=x) ... my first thought is "WTF", so I'd say it qualifies for this topic :) By the way, the Eclipse compiler agrees this is a WTF - it generates a warning for it. Definitely an odd value and WTF worthy +123 A: The weird things C++ templates can be used for, best demonstrated by "Multi-Dimensional Analog Literals" which uses templates to compute the area of "drawn" shapes. The following code is valid C++ for a 3x3 rectangle #include"analogliterals.hpp" using namespace analog_literals::symbols; unsigned int c = ( o-----o | ! ! ! ! ! o-----o ).area;  Or, another example with a 3D cube:  assert( ( o-------------o |L \ | L \ | L \ | o-------------o | ! ! ! ! ! o | ! L | ! L | ! L| ! o-------------o ).volume == ( o-------------o | ! ! ! ! ! o-------------o ).area * int(I-------------I) );  don't work in GCC While Eelis' analog literals are great, are they a strange language *feature*, or just a strange way to *use* a feature? The real WTF will be the compiler error generated by one of those that is malformed. +1 Finally I dont have to put my ascii drawings in comments =) PHP = expanded debug. Reminds me of windows = assert(blue-screen-of-death) LOL How sick is that..wake me up again when there is a version of AnalogLiterals that supports turning the literal around the X, Y and Z axis in Eclipse...now that would give "visual programming" a new real meaning. Do the ordering of the o's and L's and |'s matter? +8 A: Inform 7. An example of a valid program:  Chomsky is a room. A thought is a kind of thing. Color is a kind of value. The colors are red, green and blue. A thought has a color. It is usually Green. A thought can be colorful or colorless. It is usually colorless. An idea is a thought in Chomsky with description "Colorless green ideas sleep furiously." A manner is a kind of thing. Furiously is a manner. Sleeping relates one thought to one manner. The verb to sleep (he sleeps, they sleep, he slept, it is slept, he is sleeping) implies the sleeping relation. Colorless green ideas sleep furiously.  Other silliness like this Turing machine simulator can be found. I think Inform 7 is used for telling stories @RCIX: What used to be called text adventures, and is now called interactive fiction by the relatively small community still involved, to be specific. Doesn't Inform employ the Oxford comma?! This is not English! A: Perl my %h1 = map { _ => 1 } qw/foo bar baz/; // construct an 'is_member' type lookup table my %h2 = map { "_" => 1 } qw/foo bar baz/;  the second line is a syntax error even though to even an experienced perl programmer it looks like it would be identical. The downside to perl always trying to do what you mean, not what you said. Why the downvote? @Rob: just a guess, but it might be helpful to explain *why* it's a syntax error. +5 A: In C++ you can call static methods from null pointers - behold! class Foo { public: static void bar() { std::cout << "WTF!?" << std::endl; } }; int main(void) { Foo * foo = NULL; foo->bar(); //=> WTF!? return 0; // Ok! }  That one caught me by surprise... Why the vote down? if you understand what a static method really is, this isn't a surprise you forgot to use ??! ;) @goga: true, but it's surprising to see what looks like a null pointer dereference (even though we know it's actually not). Actually, it is dereferencing a null pointer, so the behavior is not defined. It just happens that it doesn't do anything with the results of dereferencing, so the program doesn't crash. Also, in general there's no guarantee that dereferencing null will crash the program. The confusion is caused, in my opinion, by the fact that it is possible to refer to a static method with a pointer to an object and not only with the class name. In some implementations, you can call a *non* static method on a null pointer, provided that the method *could* have been static (i.e., is non-virtual and doesn't access any instance member variables). @GogaReiger party pooper :) +32 A: Inheriting from random class in Ruby: class RandomSubclass < [Array, Hash, String, Fixnum, Float, TrueClass].sample ... end  i wonder what the designer was thinking when he put that in... It seem more like a side effect of language design, nice example by the way Possible in Python too: class C ( random.choice([A, B]) ): ;-) Probably possible in most dynamic languages. For eg in Perl: package C; use base (qw/A B/)[ int(rand(2)) ]; +1 A: this made me stunning #define _ -F<00||--F-OO--; int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO() { _-_-_-_ _-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ -_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_-_-_-_-_ _-_-_-_-_-_-_-_ _-_-_-_ }  Note that the program relies on non-ANSI preprocessor feature, that _- is expanded to --F. In ANSI C, it is two separate tokens, so expands to - followed by -F. The output is therefore not the value of pi as the author intended. See http://stackoverflow.com/questions/841646/is-define-supposed-to-add-spaces-around-macros for more. There's the International Obfuscated C Code Contest for that purpose exactly to come up with weird C code that does actually work... http://www.ioccc.org -1. This is, IIRC, an IOCCC entry to calculate PI. What is the strange language feature here? but pi is not 0.267...compiled with gcc 4.3.2 @Roger: The *C preprocessor* is the strange language feature here. @Kai, the code relies on old preprocessor "features", see my comment above (the first comment to this post) for more. The center of area in an equilateral triangle to one point works better... ;) +1 A: Smalltalk: Have a class method in a class Test, that returns a constant string: method1 ^ 'niko'  You should expect that this method constantly returns the string 'niko' whatever happens. But that is not the case. s := Test method1  (Set s to 'niko'.) s at: 4 put: i.  (Set s to 'niki'.) s := Test method1  (Set s to 'niki' again.) So, what happens is that the second line of code permanently changed method1 to return 'niki' rather than 'niko', even though the source code of the method was not updated. You can do the same in Java, ie patch the content of an interned String at runtime. How?!Java Strings are immutable. ((char[]) String.class.getDeclaredField("value").get("niko"))[3] = 'i' A: The entire WhiteSpace language Esoteric languages can probably be ignored for this question. A: In C++, the following expression returns true: 1 == 2??!??! 'A' == 'B'?! false: true In gcc, trigraphs are ignored by default (<http://gcc.gnu.org/onlinedocs/cpp/Initial-processing.html>). You need to pass the -trigraphs option for this to compile. Trigraphs are already posted here: http://stackoverflow.com/questions/1995113/strangest-language-feature/1995134#1995134 A: int main() { cout << "LOL??!"; }  Trigraphs are already posted here: http://stackoverflow.com/questions/1995113/strangest-language-feature/1995134#1995134 Also, put codes in code blocks. +2 A: Something bizarre -- VBScript having both a Null keyword and a Nothing keyword (Null is missing data and Nothing is a missing object). Why not just have one keyword...? Most other languages seem to do fine with one! Visual Basic 6.0 and of course "Classic ASP" code (because it uses VBScript) have the same bizarrity. And in Visual Basic old and new we also have DBNull. The situation is improving however, as in Visual Basic.NET Null has at last gone away so that Null is unused and only Nothing and DBNull are used. VB.NET is still a pain in the arse. Character is a non-nullable data type (so it cannot be "Nothing") but it can be vbNullChar which is a not-null Object representing a Null Character value. Why not just let Character be nullable!? A: In C++, I find it strange and distasteful that "virtual" MI (multiple inheritance) allows the "diamond-shape" class hierarchy to "work" A : Base class, e.g. "Object" B, C: both derive (virtually or not) from Object and D: derives from both B and C  Problem: "normal" inheritance causes D to be 2 ambiguous kinds of A. "virtual" MI collapses B's A and C's A to a single shared base A object. So, even if your Wheel is an Object and your Left Front Wheel is a Wheel and your Car inherits four kinds of Wheel, your Car is still only one kind of Object with virtual MI. Otherwise, your Car is not an Object, but 4 Wheel-y Objects. This is one language feature that rewards poor class design, punishes compiler writers, and leaves you wondering at run-time where the heck the Object really is - and if any virtual MI baggage was misplaced. If you really need the diamond pattern in your class hierarchy, it can be accomplished with regular MI and an "AProxy" that delegates to the single A base.  A : Base class, e.g. "Object" AProxy: Base class, constructs with other A to bind to B : derives from A C : derives from AProxy D : derives from both B and C (passing B's A to C's AProxy at construction)  This requires a little more work for those that really like diamond MI and leaves the rest of us in peace with a more tractable set of language features. The problem here is that you are making a car inherit from a wheel. Is a car a type of wheel? No. A car *contains* four wheels. Using inheritance at all in this case is unjustified. +2 A: In MATLAB (interactive array-oriented language, currently TIOBE 20) there is a keyword end to denote the last element of array (it corresponds to NumPy -1). So this is a well known MATLAB syntax: myVar = myArray(end)  To get an element from the middle of array one would usually write: myVar = myArray( ceil( length(myArray)/2 ) )  Surprisingly the keyword end is not a keyword at all but is a kind of variable: myVar = myArray( ceil( end/2 ) )  that would be so handy That's a good one! There are plenty of WTFs in matlab. +4 A: PHP's list construct: array = array(0,1,2); list (,,x) = array; x == 2; // true  You are listing the array field names as id? Useful, not WTF! Try: array = array('id','field','value'); and... x == 'value'; // true. Great for queries! +7 A: in PHP the strings letters cannot be used like in C, you need to use ord() and chr() in order to convert from number to char and vica versa: "a" != 97, but ord("a") == 97. Although, there is one exception: for(i = 'a'; i < 'z'; i++){ print"i "; }  will print letters a to y. just like you would expect as if it was C style datatypes. however if the test condition is changed to "<=" it will not print a to z as you would think, but a to yz! (total 676 items printed) also if you change the 'z' to 'aa' which came out next after 'z' in the 676 items list, and change test condition to "<" again, you will see only "a" being printed out! not a to z as you would expect. And if you change the incrementor to i+=2 it will print only "a" again! only way to do that is to use i++, i++ in sequence, and now it works like expected. Nevertheless, this is a nice way in PHP to output combinations of letters a-z, although its very hard to actually use it. WTF! (15 characters) ZOMGWTF!! My already low opinion of PHP just cratered. "=UTF-8 vs '=ASCII. i will render as an integer/byte A: Don't know if it is a feature or not. For some, yes, but for others it might be an annoying behavior. Anyway, I think it's worth mentioning. In Python, the builtin function round() behaves a bit differently between Python 2x and Python 3x. For Py 2x, >>> round(0.4) 0.0 >>> round(0.5) 1.0 >>> round(0.51) 1.0 >>> round(1.5) 2.0  For Py 3x, >>> round(0.4) 0 >>> round(0.5) 0 >>> round(0.51) 1 >>> round(1.5) 2  I'm just not familiar with the way round() in Py 3x works with 0. Docs for round() in Py 2x and Py 3x. +17 A: In Ruby, 0 evaluates as true in conditional expressions. +1 because it can be a WTF, even though I think it's a good thing. Please do explain how 0 == true is a good thing. I'm not trolling - actually interested... Does any integer evaluate as false? In Ruby only false and nil are false. I suppose it avoids using a magic number for false, if for instance 0 is a valid result for a function it could still return nil on a error and be used in an if statement. so 0 != nil??? I think coercing numbers to booleans is a WTF - 0 should not be evaluatable as a boolean, it should be a type mismatch. In scheme nil 0 and #f are disjoint and only #f is false. @Richard, it's not just numbers. In languages like Ruby and Python, everything can be interpreted as a boolean. In Ruby, as Scott said, everything is true, except false and nil. In Python there are other false things, like (,) and [], but everything can be treated as a boolean. It's not just numbers. @MatrixFrog, Python and Ruby are dynamically typed languages, so it's not great surprise you can coerce anything into a boolean. I was thinking more of a statically-typed language like C (++/#/Obj), Java or even VB. @Richard: At least in C# (and I think Java too), it _already is_ a type mismatch. A: shift; sometimes you see it in the very first line of a perl method to get read of self pointer A: In ColdFusion Struct (aka Java HashMap) is passed by reference. You'd have thought other data type behaves like Java... Array is passed by value, wtf! List is just a plain old comma-separated string! ColdFusion is a stupid language :) oh well, but I still like it. :) +4 A: Feature: Bash, the Korn shell (ksh93) and the Z shell each allow subscripting arrays with variables with or without a dollar sign: array[index]=value array[index]=value  This, with the dollar sign, will produce the expected value of 10000: unset array for i in {1..10000} do ((array[RANDOM%6+1]++)) done unset total for count in {array[@]} do ((total += count)) done echo total  Strangeness: If you remove the dollar sign from RANDOM, the total will vary randomly, even to be greater than 10000. Similarly, this produces 3 instead of 2: a=1; ((r[a++]++)); echo a  And you can't use a dollar sign there because it's an assignment (a is on the lhs), although you could do it if you were using indirection, but the double evaluation still occurs. The Reason: With the dollar sign, the variable expansion is performed before the arithmetic evaluation so only gets done once. Without the dollar sign, it's performed twice, once to calculate the index for the lookup and again to calculate the index for the assignment (so, in effect, an assignment at one step in the loop might look like array[4] = array[6] + 1 which totally scrambles the array). +1 A: A very tiny thing that annoyed me in COBOL was that there was no dedicated modulo operation. Instead you could do a division specifying that you only wanted whole number results and store the rest in a different variable. Since COBOL is very sensitive when it comes to variables that means that you ended up with a variable you didn't really need, i.e. the actual result of the division. This is the story of how I once named a variable "USELESS" - that was the most appropriate name I could think of. I once wrote a PHP function which returned a reference, except when there was an error, it'd return null. Except you can't just return null; since that's not a reference to anything. This meant I had to define a variable, set it to null and return that. Of course, the variable was named thisIsAStupidFxxxingVariableIHadToDefineBecauseOtherwiseThisFunctionShitsItself. *(yes these were early days in my PHP development career)* you shouldn't have been passing null as an error, that's just ugly having your return value to both indicate error or valid results I suspect he understands that now In these kinds of situations, I name the variable "fcrt" for Fxxxing Compiler Requires This. A: In Unity, GameObject.Find("MyObject")  will return your object normally. However, if you do something like this: GameObject.Find("MyObject").active = false; //do other stuff if (GameObject.Find("MyObject").active) { //do stuff }  Then you will get a null reference. In Unity iPhone, this code will often work fine in the editor but will cause a SIGBUS when running from the iPhone. The problem is that GameObject.Find() will only locate active objects, so even if you're just checking to see if it's active, you are effectively calling if (null.active) . To make it work right, you've got to store it prior to making it inactive. GameObject obj = GameObject.Find("MyObject"); obj.active = false; //do other stuff if (obj.active) { //do stuff }  Arguably that's better practice anyway, but the way Unity treats inactive objects in general is quite weird. It appears to unload a large portion of the inactive object (textures, etc.) but not all of it, so inactive objects can still eat up a lot of memory. Don't know this "unity" but that sounds perfectly logical to me. How is it supposed to know what to unload from memory? It probably just makes guesses because you might want to reactivate them later... I'm sure you can delete them if you really want to free the memory. Yes, you can delete them. That functionality is not what's weird. It's that there is no way to locate an inactive object in order to completely delete it unless you stored it otherwise. It just doesn't match they way they encourage people to use their scenegraph. A: I find Javascript Date Object's love for the year 110 delightful.. Try it. <Script language ="JavaScript"> <!-- var now = new Date() var dia = now.getDay() var mes = now.getMonth() var fecha //Day of the week if(dia==0){ fecha="Domingo, "; }else if(dia==1){ fecha="Lunes, "; }else if(dia==2){ fecha="Martes, "; }else if(dia==3){ fecha="Miércoles, "; }else if(dia==4){ fecha="Jueves, "; }else if(dia==5){ fecha="Viernes, "; }else{ fecha="Sábado, "; } fecha = fecha + now.getDate() + " de " //Which month is it? if(mes==0){ fecha=fecha + "Enero" }else if(mes==1){ fecha=fecha + "Febrero" }else if(mes==2){ fecha=fecha + "Marzo" }else if(mes==3){ fecha=fecha + "Abril" }else if(mes==4){ fecha=fecha + "Mayo" }else if(mes==5){ fecha=fecha + "Junio" }else if(mes==6){ fecha=fecha + "Julio" }else if(mes==7){ fecha=fecha + "Agosto" }else if(mes==8){ fecha=fecha + "Septiembre" }else if(mes==9){ fecha=fecha + "Octubre" }else if(mes==10){ fecha=fecha + "Noviembre" }else{ fecha=fecha + "Diciembre" } //Year fecha = fecha + " del " + now.getYear() document.write(fecha); //--> </Script>  Script is in Spanish - sorry if you don't understand the code.. The idea is for you to see the year 110 result. .getFullYear() The getYear is getting the year since 1900. @nickf: That would fix [email protected]: I know, just trying to show a somehow 'funny' result. @Hobhouse: You didn't need the dozens of lines above then... now.GetYear() pretty much sums up your whole post. That has been a problem since Unix/C (ca. 1972) based its time structure on an epoch of 1970-01-01. It has since spread to many other languages, libraries, databases, and spreadsheet apps. A: c#.net add textbox1 to the form int x = 5; textbox1.Text = x; its work!!!  What's the strange feature here? The implicit cast to string? That's such a **common** thing. I don't see how it can be surprising. Also, what have forms and textboxes to do with anything? A: In J, most primitives (a.k.a. functions) are monadic (one argument) or dyadic (two arguments, one to the left, one to the right). But the amend primitive takes 3 (I think it's the only one, besides foreigns). It's understandable that it would take 3, but it just looks... wrong at first. vector =: i. 10 NB. Vector will be 0 1 2 3 4 5 6 7 8 9 (10) (0) } vector NB. Will yield 10 1 2 3 4 5 6 7 8 9  A: In J, foreigns (!:) are various functions bunched together. The left argument is a category, where as the right are often (but not always) incremental values for different... stuff. For example:  2!:55 NB. Close console 9!:10 NB. Set print precision 6!:0 NB. Actual time 6!:2 NB. Execution time 4!:3 NB. Loaded scripts  Of course, the smart thing is to wrap them, but some you just commit to memory. BTW, all of those are, come to think of it, triadic, with 2 arguments to the right and one to the left. None of the above will work unless you give them a final valid argument. +3 A: Forth can change the base of the numbers at any time: HEX 10 DECIMAL 16 - . 0 Ok  It need not be one pre-defined one either: 36 BASE ! 1Z DECIMAL . 71 Ok  A: Python (specifically, CPython) >>> x = 0 >>> x is 0 True >>> x = 256 >>> x is 256 True >>> x = 257 >>> x is 257 False >>> x = -5 >>> x is -5 True >>> x = -6 >>> x is -6 False  here is explanation of what is does. http://stackoverflow.com/questions/1504717/python-vs-is-comparing-strings-is-fails-sometimes-why/1504742#1504742 read up on internment to see why you don't get consistent results. +2 A: I can't believe this one isn't on here yet: JSF property access. In a JSF UI tag, you would put the value of a property from the server-side object into the interface by referencing it thusly: <h:inputText value="#{myObject.property}></h:inputText>  The thing is that Java doesn't support properties, so you have to write methods starting with get and set in order to link the UI object to the "property" on the server. public void setProperty(String property){...} public String getProperty(){...}  This confused me when I first learned JSF and I still consider it WTF-worthy... even though there's really no other way to do it until Java implements support for C#-style properties. This is common practice nowadays in Java world and you will never see C# syntax sugar properties in Java anyway. +4 A: Variables everywhere are taken as globals in Coldfusion, no matter where they are placed. <cffunction name="one" returntype="void"> <cfset var wtf="coldfusion"> <cfinvoke method="second"> </cffunction> <cffunction name="two" returntype="void"> <cfoutput>#wtf#</cfoutput> </cffunction>  And I just thought ColdFusion was bad because the code looks ugly. +6 A: In PHP: echo 'foo' == 0; // echos '1' echo 'foo' == true; // echos '1' echo 0 == true; // echos '0' foo = 'foo'; echo foo['bar'] // echos 'f'  PHP has some of the most annoying type coercion... If it's not clear above, true and false are equal to 1 and 0, respectively (and their names aren't case sensitive. TRUE or FALSE or True or False also work.) == != = ....sigh few semicolons missing A: In Python, every string contains the empty string. answer = input("Enter 'Y[es] or N[o]:") if answer in 'YyNn': # verify input process(answer)  Just hitting return at the above query will set answer to the null string, pass the if answer in ... test, and be processed as a correct answer. To put it more succinctly: >>> "ABCDEFGHIJ".__contains__("") True  As usual, Python's behavior here is mathematically and logically impeccable. As I recall from a long ago class in set theory: The empty set is a member of every set. It's still surprising on the few occasions when I've been bitten by it, but I wouldn't have it any other way. Huh? Of course it does. The same occurs in Java, and I imagine in most languages: "abc".contains("") is true, as is "abc".startsWith(""). Oops! Guess I forgot. It's been a while since I've done any Java code. Thanks for setting me straight. The empty set is a *subset* (not a member) of every set A: In awk, arrays start at index 1, which is confusing the least. +1 A: In Python, at least for me, this was very wft! the first time I saw it: >>> "ja " * 5 'ja ja ja ja ja '  You can multiply strings! WTF?? PS: I think this is because x * n means: n times x so, 5 times "ja " is "ja ""ja ""ja ""ja ""ja " and because you can concatenate strings like this: >>> "ja ""ja ""ja ""ja ""ja " 'ja ja ja ja ja '  That two codes have the same result (and maybe are just the same) The "explanation" might make it easy for you to remember string multiplication, but note that 5 5 != 25. In Python, two adjacent strings are combined to make a string - this is taken directly from C. Yes.. that's what I mean. I've never say that "5" * "5" is "25" no.. I've said that "5" * 5 is "5""5""5""5""5" that, and "55555" is the same string.. The asterisk isn't anything special in python (besides that it's a built in symbol). It doesn't mean "multiply this". You can specify it to mean whatever you want, simply by altering the __mul__ method of your class. "myclassinstance * something" is just another way of saying "myclassinstance.__mul__(something)". Ok. but for me it still very strange that stringinstance.__mul__(number) have that result (at least for me) Well, what *other* result would you expect from multiplying a string by a number? There really isn't any other logical output IMO. +3 A: Variable assignment in JavaScript can create global variables. If a variable is a assigned a value within a function and it is not declared as var in the same scope it is implicitly declared global. function foo() { x = "juhu"; // creates a global variable x! var y = "kinners" } foo(); alert(x); // alerts "juhu" alert(y); // alerts undefined  Note that the var statement can also be used after a value has been assigned to the variable: function foo() { x = 12; var x; // x is now local return x; } alert(foo()); // will alert 12; alert(x); // will alert undefined  +9 A: LOLCODE! The whole language itself. While not exactly a WTF thing, I've never come across a language which plays out in my head in a squeeky cartoony voice. Nor have I ever looked at code before and want to exclaim "aaaawwww cuuute!" This program displays the numbers 1–10 and terminates HAI CAN HAS STDIO? IM IN YR LOOP UPPIN YR VAR TIL BOTHSAEM VAR AN 10 VISIBLE SUM OF VAR AN 1 IM OUTTA YR LOOP KTHXBYE  Well, the language is ment as a joke, just as INTERCAL.I don't see such a great "weird feature in there"... +19 A: In JavaScript the result of a method can depend upon the style braces are placed. This is the K&R style, where braces are placed right after the method signature and after a return statement: var foo = function() { return { key: 'value' }; } foo() // returns an object here  Now, if I format this code to the Allman style, where braces are always placed on a new line, the result is different: var foo = function() { return { key: 'value' }; } foo() // returns undefined here  How come? In JavaScript the language places automatically semicolons at the end of each line if you won't do it yourself. So what really happened in the last code fragment was this: var foo = function() { return; // here's actually a semicolon, automatically set by JavaScript! { key: 'value' }; }  So if you'd call foo(), the first statement in the method would be a return statement, which would return undefined and would not execute other following statements. This is pretty good observation +1 for a good explanation, though this has already been mentioned earlier (http://stackoverflow.com/questions/1995113/strangest-language-feature/2003277#2003277). +2 A: In SQL server (MS at least): This will always evaluate to false: IF @someint <> NULL  Given: DECLARE @int INT SET @int = 6 IF @int <> NULL BEGIN Print '@int is not null' END ELSE BEGIN Print '@int is evaluating to null' END  The output will be: @int is evaluating to null  It must be written: IF @someint IS NOT NULL BEGIN END  Who put English majors on the SQL Team! :) A: Best of show entry in the Perl Journal's Obfuscated Perl Contest in 2000: #:: ::-| ::-| .-. :||-:: 0-| .-| ::||-| .:|-. :|| open(Q,0);while(<Q>){if(/^#(.*)/){for(split('-',1)){q=0;for(split){s/\| /:.:/xg;s/:/../g;Q=_?length:_;q+=q?Q:Q*20;}print chr(q);}}}print"\n"; #.: ::||-| .||-| :|||-| ::||-| ||-:: :|||-| .:|  Code fully explained by its author at http://mysite.verizon.net/les.peters/id2.html A: The fact that there is no encapsulation in C++ (or Java). Any object can violate the encapsulation of any other object, mess around with its private data, as long as it's the same type. For example: #include <iostream> using namespace std; class X { public: // Construct by passing internal value X (int i) : i (i) {} // This breaks encapsulation void violate (X & other) { other.i += i; } int get () { return i; } private: int i; }; int main (int ac, char * av[]) { X a(1), b(2), c(3); a.violate (c); b.violate (c); cout << c.get() << endl; // "6" }  This is actually immensely useful in some cases. I think that if you code your class to access private data in a different instance you probably know what you are doing and you have to go out of your way to pass a reference to the other class. Cloning is one such operation where this is necessary. +7 A: About 20 years ago I worked with a compiler for a language called Coral which allowed me to declare writeonly variables! It made sense, though, as they were global and used as a signalling mechanism. One process would write a value and another would read it. but if they're writeonly variables how does the other one read it? hmm, why two down votes? Don't you think that is a strange language feature? It seemed to me.RCIX. The variable was writeonly for the process which declared it so - just an annotation for the compiler to check it. It could be read-only or read/write for others. And, of course, it was a global variable, shared between compilation units. Or perhaps memory mapped IO. A: Two words: Lambda expressions Or phrased differently: Functional programming This style is a "write-only" language feature. A: The implict variables\constants and mutable constants in ruby +1 A: in Ruby ... i=true while(i) i=false a=2 end puts defined?(a) // returns true  How is that strange? I don't even know the language and that's clear. Implicit declarations like that aren't "supposed" to be narrowly scoped in any language supporting them. the "a" variable is defined inner of the while block and exists after the while block goes out I believe JavaScript does this too *unless* you put the var keyword before the declaration. Python also does this, and there's no way around it AFAIK... really screws you up when you *thought* you redefined the variable later in a different scope, but didn't, and its still using the same value from a previous loop...confusing as hell! in JavaScript, Python and Ruby only functions create scope +5 A: The following C# code throws NullReferenceException rather than print 1:  static void SomeMethod(string format, params object[] args) { Console.WriteLine(args.Length); } static void Main(string[] args) { SomeMethod("blabla", null, "Ok here"); // print 2 SomeMethod("blabla", null); // exception }  This is C#4.0?+char[15] Same in Java http://www.databasesandlife.com/java-varargs-inconsistent-behaviour-if-you-pass-an-array/ A: In C#, the following code generates compiler error "Cannot convert from method group to Delegate". Though the logic behind is reasonable, it still feels strange to me. control.BeginInvoke(delegate { DoSomething(); });  because you should write "control.BeginInvoke(DoSomething);" No, "control.BeginInvoke(DoSomething);" does not work either, unless DoSomething is a variable of any delegate type. A: In Python: i = 1 ++i print i  prints '1'. The line '++i' evaluates to +(+i) (Python doesn't support increment operators) A: In JavaScript: 2 == [2] // Even stranger 2 == [[[2]]] // And down-right nutty var a = { "abc" : 1 }; a[[[["abc"]]]] === a["abc"]; // this is also true Luckily the kind folks at stackoverflow.com explained the whole thing to me: http:/stackoverflow.com/questions/1724255/why-does-2-2-in-javascript This is an exact, copy-pasted duplicate of http://stackoverflow.com/questions/1995113/strangest-language-feature/1998050#1998050. Please delete it. A: 95 WTF moments in Java: http://www.javapuzzlers.com/ For example, System.out.println(12345 + 5432l); prints 17777. That's just from using a bad font, nothing to do with the language. 12345+5432 *does* equal 17777. Use a capital L for a long suffix if this confuses you. +2 A: This is not a strange feature, in fact it makes total sense if you think about it, but gave me a WTF moment nevertheless. In C++(and in C#), subclasses of a base cannot access private and protected members on the instance of the base. class Base { protected: m_fooBar; }; class Derived: public Base { public: void Test(Base& baseInstance) { m_fooBar=1; //OK baseInstance.m_fooBar = 1; //Badness //This, however is OK: ((Derived&)baseInstance).m_fooBar = 1; //OK } };  +8 A: String math in Perl is pretty weird.  perl -E 'string = "a"; string++; say string' b perl -E 'string = "abc"; string++; say string' abd perl -E 'string = "money"; string++; say string' monez perl -E 'string = "money"; string--; say string' -1  Very well-known, but still cool. Also, incrementing "z" gives "aa". +2 A: Subjunctive case in English. Oh wait, did you mean programming languages? Then using (macro) in C to bypass the preprocessor #define of macro(). E.g., if someone has #define free(...), (free)(...) will not be the same as free(...). "using (macro) in C to bypass the preprocessor #define of macro" -- it doesn't, it bypasses the preprocessor #define of macro(), but if the preprocessor #define of macro doesn't have an lparen then it doesn't get bypassed. Yes, well it's hard to type function macro vs. object macro on an iPhone. +4 A: In Python: >>> x = 4 >>> y = 1000000 >>> x is 4 True >>> y is 1000000 False >>>  Just try it if you don´t believe me! That's because small numbers are predefined or cached objects. So x = 4 actually is a reference to an already existing number, whereas y is simply to big to be stored by default, so both constants create new objects. +14 A: In C-like languages (including C itself), you can use the "goes down to" operator: for(x = 20; x --> 0;) { print x; } This will print the numbers from 19 to 0. Well...it's not really an "operator". x --> 0 is parsed as x-- > 0. Which is what makes it strange! http://stackoverflow.com/questions/1642028/what-is-the-name-of-this-operator A: A Java source file can end with the character \u001a (control-Z). In CP/M, a \x1A would mark "end of file"... I can't imagine it being used on a modern system though. Anyway, Python (v3 at least) also treats this as end of file. Quite a few C compilers still recognize this as well. Ctrl+Z as a text file terminator comes from all the way back in the days of CP/M, which was what MS-DOS was based on. Many apps still support this for some reason. +8 A: ## Bracket identifiers in VBScript VBScript has so-called bracket identifiers, which are identifiers defined enclosed in square backets, like this: [Foo]  They're quite handy, actually, as they allow you to name variables and routines after reserved words, call methods of third-party objects whose names are reserved words and also use almost any Unicode characters (including whitespace and special characters) in identifiers. But this also means that you can have some fun with them: [2*2] = 5 [Здравствуй, мир!] = [Hello, world!] [] = "Looks like my name is an empty string, isn't that cool?" For[For[i=0]=[0]To[To[To[0] [Next[To]([For[i=0])=[For[i=0] Next  On the other hand, bracket identifiers can be a gotcha in case you forget the quotes in a statement like this: If MyString = "[Something]" Then  because If MyString = [Something] Then is a perfectly legal syntax. (And that's why an IDE with syntax highlighting is a must!) More info on bracket identifiers in Eric Lippert's blog: Love the examples! Hm... In pure mathematics, [x] is sometimes used to denote a very "formal" interpretation of x, as in [0/0] and [∞/∞] (two interesting cases of limits of fractions). Although I am aware of no precise definition of [], I would say something like "I mean exactly what I write, but do not try to interpret it literally". Related? A: In Java, there is some inconsistency as to how Strings handle the == operator depending on how it was constructed. String a = "Hello"; String b = "Hello"; System.out.println(a == b ); // prints true. String c = new String("Hello"); String d = new String("Hello"); System.out.println(c == d ); // prints false  The behavior is consistent, as it only compares the references, a and b reference the same interned string while c and d reference two different string objects. Only compare java objects with == if you want to check for the same instance, if you want to compare two objects use c.equals(d). Using == to compare strings just asks for trouble Yep. You could do both, which might be slightly faster: c == d || c.equals(d). But you must call equals(), or intern both strings, to get the right result. This differs from C# behavior, BTW. +2 A: Here is one about python: >>> print 07 7 >>> print 08 File "<stdin>", line 1 print 08 ^ SyntaxError: invalid token  Ain't that a beauty? Especially unthoughtful when you think of how human write dates, which has the following effect: datetime.date(2010,02,07) # ok datetime.date(2010,02,08) # error!  (the reason is that 0x is interpreted as octal, so print 010 prints 8!) Yet another reason to switch to Python 3 -- "print(07)" is also a syntax error. Its always lucky number seven, isn't it? +4 A: In Matlab, the following may be surprising, especially if you are used to Python: >> not true ans = 0 0 0 0 >> not false ans = 0 0 0 0 0  There are two weird features here. The first one is that a b is interpreted as a('b'), so not true is interpreted as not('true'). The second weird feature is that not of any character returns 0 (presumably because there is no false or true in matlab, only 0 or 1). +5 A: javascript: parseInt('06'); // 6 parseInt('08'); // 0  Numbers prefixed with 0 are octals. yes, I'm aware of that, but it still seems strange :) and since most of the answers here are explainable anyway.. @Bozho What is strange about it? 8 is not a valid number in octal so it just wraps back around to 0. Remember that octal is 0 to 7. It's counter-intuitive, since when parsing Int you would expect it to do it in decimal notation and strip leading zeros.This has lead to alot of annoying bugs... who needs to ever parse octal numbers anyway? Other languages (more intuitively) default to decimal which can be overriden with radix parameter. Octals are represented with a leading zero since at least '78. this is a duplicate in this thread A: javascript: typeof null // object null === Object // false  typeof Object // function A: In Scheme there are no reserved identifiers. So, the following expression evaluates to 1: ((lambda (lambda) lambda) (let ((let 1)) let))  Note that there is a restriction on definitions within a given scope: no definition may redefine an identifier used to define identifiers within that scope, so the following is a syntax error: (begin (define define 1) define)  +8 A: Variable/function declarations in Javascript: var x = 1; function weird(){ return x; var x = 2; }  weird() returns undefined... x is 'taken' even though the assignment never happened. Similarly, but not so unexpectedly function weird2(){ var x; return x(); function x(){ return 2 }; }  returns 2. A: Well the first thing that came to my mind was 'noop', my brain did the same thing when I first came across it! A: Anything from VB/VB Script Anything? Including the fact that 2+2=4? That's really one weird language feature. @Martinho Fernandes: Psshh... we all know that equals fish... *sarcasm* +2 A: In php: easter_date — Get Unix timestamp for midnight on Easter of a given year int easter_date ([ int year ] ) +7 A: PHP as an entire language is mostly WTF. The langauge definition is defined,(see www.php.org) not by a grammar, or a standard, but by a bunch of "you can write this example" sections (can you write anything else, sure, just guess at the generalization), with honest-to-god user contributions saying "but it does this wacko thing ...". I periodically encounter glitches with a PHP parser we built. Here's the latest:  "abcA[define]def"  Now, PHP is a (truly bad) copy of PERL, and so it allows strings to be constructed with implicit substition of variables. X in the string says "plug the value of X into the string", equivalent to "abc" . X . "def" where "." is PHP's string-concatenate operator. A[7] in a string says, "plug the value of the seventh slot of array A into the string",equivalent to "abc" . A[7] . "def". Now, the language (website) clearly says "define" is a keyword, and you can't use it whereever you'd find an expression. So the above gem containing "define" does what? Throw a syntax error? Nah, that would make sense. No, what it actually means is:  "abc" . A["define"] . "def"  It does this ONLY if you write an thing that looks like an identifier (keyword or not!) in an simple array access in a string. Nowhere else in the language does this behaviour occur. What, writing "abcA["define"]def" was unreasonable so the PHP inventors had to throw this in? Give me a break. (To compound the felony, there's "complex array access in a string" and of course it works differently. Check out "abc{A[define]}def"; that is illegal according to the PHP website. (Turns out PHP arrays are associate hashes, so looking up an array (well, hash table) member by name isn't a terrible idea). The language is full of gotchas like this. If you like "gee, look what squirmy thing I found under my subroutine today", you should switch to PHP. That makes sense considering a['test'] and "a[test]" are also equivalent. But one does wonder why PHP has so many "features" that don't add any real benefit but just lead to unexpected or unpredictable behavior... It does? No it doesn't. The distributive law does not apply logically to quote marks, regardless of the fact that your example is valid in PHP. I agree, it is also full of useless junk. (In 5.x, they actually added 'goto'! What, the language didn't work before that? Have you seen the new, kewl, NOWDOC strings? What a waste of time. ) define isn't a keyword in PHP, it's a function. Sure, it's an incomprisable primitive too but it's still a function. I normally pretty careful. I'll swear I looked at this page http://www.php.net/manual/en/reserved.keywords.php when I wrote my diatribe and 'define' was in the list. Maybe I was on drugs, because it isn't there now. However, if you replace 'define' in my example by any of the official keywords listed, you get the same problem. I prefer my PHP with no define. I just keep a globals.php file. Keep it variables! I started disliking PHP the time I wrote a calendar. I left the off of a variable in my isLeapYear() function. Rather than being an error, it made the function always return true. +2 A: In PHP, the following: <?php foo = 'abc'; echo "{foo";  is a syntax error. If you actually wanted {, followed by the contents of foo, you'd have to use .: <?php foo = 'abc'; echo '{' . foo;  "{foo"; != '{foo'; != "\{\foo"; ......sigh A: I don't know if it's still true, but we discovered by accident that VS FORTRAN(66 or 77) will not support recursion. The recursion was accidental and our default F77 supported it beautifully, but when we took the source to an IBM - Whatta Mess. I recall being frustrated when I read somewhere in the texinfo files of g77 that the recursive keyword is not supported and that all recursion can be turned into loops. That's probably why we used a commercial compiler instead (which supported this as an extension to fortran 77). I guess this has to do with the fact that arguments seem to be passed as references to functions in FORTRAN. FORTRAN did not support recursive subroutines for decades. It has nothing to do with pass-by-reference, but by the way the call stack is statically allocated. VS FORTRAN is / was the "flagship" FORTRAN for IBM for both VM and MVS. I suspect that they didn't support recursion because of their policy that old code is still linkable and runable on their newest machines and at that point they still were supporting FORTRAN-H and allowing the two to be linked. I also suspect that this is no longer true (having been over 10 years since I worked with big blue) +4 A: C++1x Lambda's: [] (int x) { std::cout << x << std::endl; } ();  These can be abused for some odd syntax: [](){}();[]{[]{}();}();  This is completely valid C++1x. A: Processing (processing.org) is a language based on Java. In simple terms, processing compiler is Java preprocessor that translates Processing-specific syntax into Java. Due to the language's design, it has a few surprises: Processing's class are compiled into Java inner class, this causes some annoyance, like private variables that isn't really private class Foo { private int var = 0; // compiles fine } void setup() { Foo f = new Foo(); print(f.var); // but does not causes compile error }  also missing draw() function causes event handlers to not be called: // void draw() {} // if you forgot to include this void mousePressed() { print("this is never called"); }  +29 A: Perl has the yada yada operator (...). The so called “yada yada” operator of Perl 6 heritage is a shortcut to mark unimplemented code: if (condition) { ... }  is the same as if (condition) { die "not yet implemented" }  Incredibly helpful though. IE: try finding unimplemented code? ack '\.{3}' +3 A: In Java (Actually, I have wrote this on different SO post recently) :  int x = 1 + + + + + + + + + + + + + 1; System.out.println(x);  This is weird! Why does it work? It's a sequence of unary positive signs, so it's like 1 + +(+(+(...+(1)...))) +2 A: In C++, the ability to create a protected abstract virtual base pure virtual private destructor. This is a pure virtual private destructor that is inherited from a protected abstract virtual base. IOW, a destructor that can only be called by members or friends of the class (private), and which is assigned a 0 (pure virtual) in the base class (abstract base) that declares it, and which will be defined later/overriden in a derived class that shares the multiple-inherited base (virtual base) in a protected way. +6 A: Found while learning PowerShell: Try to guess what the resulted array look like: a = 1, 2 b = 1, 2+3 c = 1, 2*3  Answers: 1, 2 1, 2, 3 1, 2, 1, 2, 1, 2  Ouch! It shakes my faith in PowerShell and people behind it. That's just the comma operator binding more tightly than the arithmetic operators. e.g. b = 1, 2+3 is the same as b = (1, 2)+3. You were possibly expecting: b = 1, (2+3) I understood why it's working that way. But didn't understand why it was designed in that way. Wow, this is totally mind-boggling! It's like they were trying to redefine the opposite of intuitive. They've done it, too! A: In MOD_REWRITE RewriteRule ^([a-zA-Z0-9_-]+)\.php 1/ [R,NC] RewriteRule ^([a-zA-Z0-9_-]+)/ 1\.php [NC,L]  Will cause: "file.php > file > file.php > file > file.php > file > ..."  And finally: Error 500 Too Many Redirects  (In general I find editing .htaccess files to be about as tedious as constructing a properly functioning regular expression.) ...and WTFx2 is that it is not quite HTTP Error 500 Internal server error. Why shouldn't it cause that behaviour..? Because of the L? Is that the bit you find confusing? It was confusing (WTF) up until I learned the L caused that. I know better now, of course. ;) +14 A: The absolute worst WTF has got to be Cobol's ALTERED GOTO. The syntax is pretty straight forward: "ALTER label1 TO GOTO label2", but the results of debugging run-time spaghetti are mind-boggling. It represents accurately the business model of some stakeholders, when they say something but REALLY MEAN some other thing. What a feature! ;D And this was one of those things that if I ever saw it, I'd pull out a shotgun. +4 A: SQLite lets you declare columns with whatever data type you want. It looks for a few particular substrings ("INT", "REAL", "TEXT", etc.) to determine the affinity. This makes it possible to lie in your type declarations: CREATE TABLE Quirks ( X FLOATING POINT, -- = INTEGER affinity because of the "INT" Y STRING, -- = NUMERIC affinity );  Actually the actual storage type is completely dynamic, so even if you say column X is integer, you could still put a blob into it. True. Affinity is just the *preferred* type to coerce values to. +3 A: Atari BASIC: You can fill a string with a character without writing a loop: 10 DIM A(100) 20 A(1)=" ":A(100)=" ":A(2)=A  As far as I can remember ':' means what ';' means in Java/C. It's a old Basic thing, not specific to Atari's @pedrofurla: I'm pretty sure he's saying that after those three assignments, A(3) through A(99) will now contain spaces as well. I bet the underlying string implementation looks __scary__. @Jander: yeah, now I am reinterpreting the line. It's a kind of unbelievable feature. The A(2)=A portion is pretty weird, can't really wonder what's behind it. +10 A: Perl: It's possible to write a program consisting entirely of punctuation. How does this even work?! Who needs brainf*ck when you've got perl! +2 A: Not technically a language WTF, but an architecture one. http://www.6502.org/tutorials/6502opcodes.html#JMP 6502 assembly, indirect JMP: Note that there is no carry associated with the indirect jump so: AN INDIRECT JUMP MUST NEVER USE A VECTOR BEGINNING ON THE LAST BYTE OF A PAGE For example if address 3000 contains 40, 30FF contains 80, and 3100 contains 50, the result of JMP (30FF) will be a transfer of control to 4080 rather than 5080 as you intended i.e. the 6502 took the low byte of the address from 30FF and the high byte from 3000. So adding a single byte to your code could make your indirect jump go wildly off target. A: "dynamic" in C#. Ruins the day for everyone who has to work together with a RAD or python victim because Intellisense, type safety and determinism die instantly with the first use of the "dynamic" keyword. Didn't know they added that! That's sweet. Type safety is one of the things I love about C# and one of the reasons I want to switch my web development from Python over to C#... however, this could also come in handy. With power comes responsibility! +6 A: PHP From the online doc: string implode ( string glue , array pieces ) — Join array elements with a string Note: implode() can, for historical reasons, accept its parameters in either order. So this works: implode(someArray, glue) Hope they kill these historical quirks in PHP 6. To kill the quirks of PHP would require killing the entire language =P ... and I think that's a great idea. its a bit like how mysql_db_query depreciated to mysql_query but flipped the arguments... +12 A: This is one of my favorites, you can do a println in Java without main(). This will compile and run, giving the println, but also an exception (java.lang.NoSuchMethodError: main) class Test { static { System.out.println("I'm printing in Java without main()"); } }  +1 Nice finding!!! So is it strange? Completely predictable behaviour. The class loader invokes the class construcor itself when it loads a class before looking-up for any method. No matter is it main(String[]), or is it any other method. Moreover, the entire application may have not the main(String[]) method - it depends to the application infrastructure. @Lyubomyr: You are correct on your comment, but you used the wrong terms. It is the *free floating static block* what gets executed when the class is loaded. The class is loaded to determine whether or not a main method exists. The class loader never invokes the class constructor. @OscarRyz: Oh, I see. I'm not very familiar with Java, 'cause it's somewhat new for me. Thank you for clarification, Oscar. Now I know more. :) @Lyubomyr: It is also strange because this will print out to the screen while also throwing an exception: java.lang.NoSuchMethodError: main. @Luybomyr Shaydariv: Yes, it is strange. The fact that it is predictable does not cure strangeness. Most of the "strange" language features listed under this question are completely predictable. @RussellW: As far as I understand Java and JVM, it depends just a way you load the class, so if you run it as a single application, it requires main(String[] args) - that's why it's definitely clear why it fails with NoSuchMethodError. This is very similar to Turbo C++ programming techniques that allowed to specify some _before-main_ priority using some special #pragma directives, if I'm not wrong. +3 A: ## In PHP var_export('false' == 0); // true var_export('false' == true); // true var_export('false' == false); // false  EDIT As @Kobi mentioned, it could happen because language interpret any value as "TRUE" except "FALSE", but not in case of PHP, where things are even more strange than you thought! This case is fully documented in chapter "String conversion to numbers" of a PHP manual, which says: If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero). Here is example: print (int) 'zero'; // 0 print (int) 'false'; // 0 // but print (int) '1 - one'; // 1  P.S. I see more harm than usefulness of such implicit type conversions. I don't know any PHP, but it makes sense if any value is true, besides false (some languages behave that way) - 0 is true, and 'any string' is true. Well, quoting me in the answer is just unfair :P, but the direction is right - show some more asserts and see if it makes sense, draw a whole picture. +52 A: JavaScript is object oriented, right? So running methods on literal strings and numbers should work. Like "hello".toUpperCase() and 3.toString(). Turns out that second one is a syntax error, why? Because the parser expects a number followed by a dot to be a floating point literal. That's not the WTF, the WTF is that you only have to add another dot to make it work: 3..toString()  The reason is that the literal 3. is interpreted as 3.0, and 3.0.toString() works fine. Works this way in Python too (try 3..__add__(4)). Then again I think (3).__add__(4) is a much less brain damaged way to do it :) You can just do (3).toString() @Gorilla3D: yeah, but that's not a strange language feature, is it? 3.0.toString() makes my eyes itch. +3 A: This old PHP favorite isn't all that WTFish on its own, but a scope resolution error is one of those things that gets seen by so many developers that it's worth giving some WTF love: class = new StdClass(); class::test(); PHP Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM on line 3  +3 A: In Ruby, you can do some weird things with heredocs. Consider: a = <<ONE This is one. #{<<TWO} This is two. #{<<THREE} This is three. THREE TWO ONE p a # => "This is one. This is two. This is three.\n\n\n"  I don't get why this is weird... +8 A: The use of "WTF" in the English language. Is this a feature? Rather a bug as an unfortunate result of human stupidity. A: In C#, there is the Managed Extensibility Framework in .Net 4 - It offers a container for IoC-DI but it is spookysaurus: http://mef.codeplex.com Three mark downs and no comments; senseless and cowardly. I guess I just made it four. As requested, here's my comment: MEF is not a language feature. MEF is not an IoC container, it's an extensibility framework, just like advertised. See this question: http://stackoverflow.com/questions/108116/. In that very link it mentions Mef as an IoC container and when Mike Taulty last spoke on the matter, he refered to it as such. So get your facts right and resolve your own contradictions. +4 A: NSIS (the Nullsoft Scriptable Install System) has the StrCmp instruction: StrCmp str1 str2 jump_if_equal [jump_if_not_equal]  Compares (case insensitively) str1 to str2. If str1 and str2 are equal, Gotos jump_if_equal, otherwise Gotos jump_if_not_equal. StrCmp 0 "a string" 0 +3 DetailPrint '$$0 == "a string"' Goto +2 DetailPrint '$$0 != "a string"'  The icing on the cake: jump_if_equal and jump_if_not_equal can be negative, too. But I guess you already figured that out from the + symbol in front of positive numbers. I don't remember whether it's mandatory, or just a horrible convention. This basically combines the worst of BASIC and the worst of Assembler. Evil. InnoSetup at least uses PascalScript, which is kind of sane, mostly. +5 A: The entirety of the Malbolge programming language: http://en.wikipedia.org/wiki/Malbolge +1 Coolest esoteric programming language ever. A: In Ruby, default function arguments are working in mysterious ways.. (or at least for someone familiar with Python): def f(a="a", b="b") return [a, b] end f() # -> ["a", "b"] f(a="A") # -> ["A", "b"] f(b="B") # -> ["B", "b"] # WTF? expected ["a", "B"]  I think it's not strange anymore ! It's logical . @Michel Kogan: agree, but for ruby newbie pythonist it's really a wtf Makes complete sense... Although I guess I don't know the python version, maybe the python version is the WTF This isn't much of a wtf for someone used to C-like languages that don't support named parameters. @Jake all py versions behave like f(b="B") -> ["a", "B"] @mykhal: Yup, that sounds more like the WTF to me :p @Jake: Erm, no, it's a great feature called [named parameters](http://en.wikipedia.org/wiki/Named_parameter) (now supported in C#!). The WTF is that Ruby does not support named parameters.. @Danny Pflughoeft: I get it, and I do agree that it would be a useful feature indeed. However looking at the example given here its still a bit of a WTF to someone not used to named parameters (like me) @jake wtf, there are even more languages having this wtf? :) A: Perl if you try break the line with backslash, like my$x = 1 + \
1;

print $x;  you don't get 2, but rather something like 313781057, and the result is always different. don't use backslash for this in Perl, it is used to get the references (something like pointers) I don't see this as a "strange feature" so much as a misunderstanding of how an operator works. Just because one needs to backslash a newline in some languages doesn't mean that this is also the case for Perl. +5 A: In Java, String s = null; System.out.println(s + "hello");  This outputs "nullhello". I would have expected a Null Reference Exception. @jdk: NullReferenceException is C#'s thing. This is because all the + operations are automatically compiled to StringBuilder flows so that a+b+c (where all variables are Strings) becomes new StringBuilder().append(a).append(b).append(c).toString() and as we can see from StringBuilder.append(Object o)'s javadoc, nulls are handled by printing null instead of throwing an exception. **Tl;dr:** Compiler magic with syntactic sugar. @Esko: And here I thought Microsoft copied Sun verbatim :) @jdk: Most of C# is syntactic sugar anyways :) But yeah, compiler magic related to concatenating Strings with + is really a whole issue on its own. +3 A: Commodore BASIC's command shortcuts. Basically most commands had an abbreviated form which was usually the first letter + (shift+2nd letter). But because the character set on a C64 was by default in all uppercase, these commands would look like bizarre symbols. Here's a short hello world example: Maybe someone has a better example actually with more meat to it, but for long programs this looked completely ridiculous. Here is a list of abbreviations: http://www.c64-wiki.com/index.php/BASIC_keyword_abbreviation the abbreviation translated to memory savings, and with 3,583 bytes and 38,991 on the c64, every byte counted. i also remember that you didn't need to put space after the command, so FORI=1TO15 is valid. Shouldn't take too much imagination to come up with more interesting examples. The one everyone experienced though is that if you put the cursor on the READY. line and hit ENTER, the BASIC parser interprets it the same as READ Y. A rougly similar approach was used in Sinclair Basic at ZX-Spectrum (at least 48K) where each BASIC keyword had its own character code that's above 0x7F. So anyone who tried reviewing the BASIC program dump (and not its listing using LIST command) was surprised for the first time. A: Perl can automatically convert base 26 into base 10, if you can live with yourself in the morning... $ perl -E "say lc (@a='a'..'asdf')"
30530

A:

In ColdFusion text values are converted to various data types automatically for various purposes. I hit an odd problem where "00A" and "000" were being return as equal. It turned out that ColdFusion was interpreting "00A" as a time, converting to some sort of numeric time format, and converting it to 0. "000" was being converted to 0. So they were both considered equivalent. That is when I learned about the compare function for strings.

+6  A:

By far the strangest feature I've ever encountered was a "RETURN n" statement in a dialect of BASIC (don't remember which one, this was about 28 years ago). "n" was optional and defaulted to 1. It could be a positive or negative number that indicated which line relative to the invoking GOSUB is the next to get executed.

For example the following would output "30":

10 GOSUB 200
20 PRINT "20"
30 PRINT "30"
100 END
200 RETURN +2


I encountered this when I had to translate a program written in this bizarre BASIC to FORTRAN. The BASIC program used this feature quite a bit to return to different statements based on various conditions and it took me a while to understand the logic flow. Once I understood it, I was able to write a much simpler version of the program. Needless to say, the simpler FORTRAN version had fewer bugs than the original BASIC program.

+3  A:

In PHP:

for ($s="a";$s<="z";$s++) echo$s.' ';


This will write:

a b c d e .. .w x y z aa ab ac ad .. ay az ba bb bc ... by bz ca cb ... yz za zb ... zx zy zz

Why? Does anyone know?
because PHP follows perl' convention dealing with increments on a string variables. so, $s = 'z'; echo ++$s; will return 'aa'.but strings are compared as strings, so 'aa' is less than 'z'.
+10  A:

My favorite little C++ syntax trick is that you can put URL's (with some restrictions) directly into the code:

int main( int argc, char *argv[] )
{
int i=10;

http://www.stackoverflow.com
return 1;
}


This compiles just fine.

Syntax highlighting kind of spoils the joke, but it's still fun.

It took me a little while to get this, but it's hilarious.
+6  A:

Ruby

Time.parse often pretends that the parsing did not failed, returns now instead

require 'time'

Time.parse '2000-01-01 12:00:00'
# -> 2000-01-01 12:00:00 +0100

Time.parse '2000-99-01 00:00:00'
# -> ArgumentError: argument out of range ...

Time.parse 'now'
# -> 2010-08-13 21:26:13 +0200

Time.parse 'yesterday'
# -> 2010-08-13 21:26:18 +0200

Time.parse 'billion years ago'
# -> 2010-08-13 21:26:37 +0200

+2  A:

The rest of these have nothing on the astounding Ruby Flip-Flop Operator:

p = proc {|a,b| a..b ? "yes" : "no" }

p[false,false]    => "no"
p[true,false]     => "yes"
p[false,false]    => "yes"   # ???
p[false,true]     => "yes"
p[false,false]    => "no"


Yes, program state stored in the interpreter's parse tree. Things like this are why it takes forever to make a compliant Ruby implementation. But I forgive you, Ruby <3

Wow, nice turing machine ;-)
+2  A:

Ruby Flip-Flops. "..." and ".." in conditional statements are not always range operators:

(0..20).each do |x|
if ((x%10) == 5)..((x%10) == 5)
print "#{x} "
end
end

(0..20).each do |x|
if ((x%10) == 5)...((x%10) == 5)
print "#{x} "
end
end


This will output:

5 15
5 6 7 8 9 10 11 12 13 14 15


.. checks both statements on each pass, ... only checks the "on" or "off" statement in each pass (depending on the flip-flop state). They are stolen from awk and sed.

Matz writes in "The Ruby Programming Language": "Flip-flops are a fairly obscure feature of Ruby and probably best avoided..."

+4  A:

Looking for a function? Why not a language?

I love PHP but it always seems to be built like this "Oh s***t! I forgot this! Let's just add another argument to the function" which result in this :

str_replace($search,$replace, $subject, ...) strstr($subject, $search, ...) Notice the extra underscore and the different order for the arguments. Here is something else $a = array( 'a', 'b', 'c', 'd');

print_r($a); //Prints array( 0 => 'a', 1 => 'b', 2 => 'c', 3 => 'd'); unset($a[2]); //Destroys the element 2 of the list
print_r($a); //Prints array( 0 => 'a', 1 => 'b', 3 => 'd');  strstr is like that to copy its behaviour in C. And php's arrays are stored associative. If you don't want indexes to break, don't use unset but actual array functions like array_splice. +2 A: Python 2.x demonstrates a poor list comprehension realization: z = 4 s = [z*z for z in range(255)] print z  This code returns 254. The list comprehension's variable collides with an upper defined. Python 3.x had disposed of this feature, but closures are still using dynamic linking for external variables and brings many WTFs in the functional style python programmer def mapper(x): return x*x continuations = [lambda: mapper(x) for x in range(5)] print( [c() for c in continuations])  This code returns obviously [16,16,16,16,16]. +1 A: In C: int main() { int i = 0; int array[] = {1,2}; return (i[array] + 1 == array[i]); }  This program will return 1 (true). it returns false. By definition, array[i] and i[array] are both identical to *(array+i). A: I built a language with a BUT clause once, a long time ago. is that similar to an else or otherwise clause? Do you have any examples of this but clause? It was a string processing language, something like scan a until 'x' but if not found do y. It was a bit of an in-joke, really, one of the participants had always wanted a language with a BUT modifier in it. Some reason for the downvote? This is similar to the syntax of several languages that string together expressions separated by logical operators, like expr1 || expr2 || expr3. The execution stops at the first expression that evaluates to true. +2 A: Fortran's special meaning of different columns. (Probably completely natural if you grew up with punchcards.) One side effect of this is that e.g. variable names are truncated after column 72. Combined with IMPLICIT NONE this then silently introduces a new variable when such a variable name is started close to column 72. You'll need 1. to be aware of this 2. an editor which highlights the comment part (after column 72) in a different color than the part before... This is especially true on IBM where columns 72 thru 80 are significant to the editor. A: PHP$ php -r '::' Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM

Why not say "unexpected T_SCOPE_RESOLUTION_OPERATOR" ?

It's an interesting case of an untranslated word in an error message but I wouldn't classify it as a language feature per se.
@johnK I still don't get why error messages aren't language features. If error reporting wasn't a feature you would have the equivalent of ERROR_REPORTING=OFF, which BTW is also a feature...
@Talvi: I would draw the same line as you did between error messages as language features vs error reporting as a language feature: I don't consider messages as features even if the reporting system that contains them is a feature. Two different things.
@johnK "its not a bug.. its a feature." <- that line
+4  A:

In JavaScript this:

var something = 12;

function nicelyCraftedFunction()
{
something = 13;
// ... some other code
// ... and in Galaxy far, far away this:
if( false ) // so the block never executes:
{
var something;
}
}
nicelyCraftedFunction(); // call of the function


Normally you would expect that something variable will get value of 13. But not in JavaScript - variables there have function scope so later declaration affects everything up-stream.

In languages that use C/C++/Java notation (like JS) you would expect variables having block scope, not like this ...

So dead block of code that compiler can even remove from final generated bytecode still have side effects in the rest of code that executes normally.

Therefore something will be still 12 - not change after invocation of the function.

Your original answer doesn't state what something actually gets, leaving the reader to wonder what is the strange result of this language feature.
Outer variable 'something' will not change after execution of the function. So 'something = 13;' does nothing in this sample. As soon JS sees 'var something' *anywhere* in function body it will think that it is a local (for the function) variable.
+1  A:

s a="a=""a=""""a"""",@a=""""2N"""",a=""""c=""""_(""""22""""[email protected]),@a"",@a,a=""a"",a(c)=""S+""_c,e=$T(@@[email protected](c))",@a this is a nice one-liner in COS (cache objectscript). The funny thing to note here are 5 different modes of code-indirection *G +10 A: I like sneaking-in octal values in C: int values[8] = { 123, 154, 103, 310, 046, 806, 002, 970 };  That looks like an accident waiting to happen ;o) I've actually seen this 'in the wild', self-proclaimed hackers tend to like this oddity to obfuscate code. +10 A: In Haskell: let 2 + 2 = 5 in 2 + 2  yields 5. Can I get an explanation to this? The reason is very straightforward: In haskell, (like in most other languages) you can simply redefine a function locally (haskell treats operators in the exact same way as "normal" functions), this lets the outer operator be hidden. After this, he just pattern matches against the values 2 and 2, like it's common in haskell. For instance, let 2 + 2 = 5 in 2 + 3 would yield a pattern matching failure. this is the same aslet (+) = \2 2 -> 5 in (+) 2 2 It also works in F#: let (+) 2 2 = 5 in 2 + 2 A: And again Haskell: In Haskell you can handle an arbitary size file, as if it is a simple String. The file will be only read, if the string is actually used. Because of the incredible laziness of Haskell, a program like this will run in constant space, regardless of the file's size: main = interact (>>= \x -> if x == '\n' then "\r\n" else [x])  (This program convert's a file from stdin to stdout and replace LF by CRLF, the interact function input's the whole stdin to a function and moves the output to stdout.) This laziness may also cause problems, because if you close a file handle, you cannot be completely shure, whether lazy Haskell has already parsed all the data from it. +1 A: How about the neat system-dependent overflows causing year rollovers in (MRI/C) Ruby and MacRuby (but not in JRuby) followed by localtime errors for a larger number. Not a common issue, but it is strange: $ ruby -version
ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0]
$irb >> Time.at(67767976233550799) => Tue Dec 31 23:59:59 -0500 2147483647 >> Time.at(67767976233550800) => Wed Jan 01 00:00:00 -0500 -2147483648 >> Time.at(67768036191694799) => Wed Dec 31 23:59:59 -0500 -2147481749 >> Time.at(67768036191694800) ArgumentError: localtime error ... Maybe IRB bug!!  A: in Java String("aaa")==String("aaa") //false //you need to use String("aaa").equals(String("aaa")) // true  That's because java doesn't have operator overloading, with the exception of + for String types, coming from a C background this is completely expected behaviour. To be even more specific, if the first line would be true, the String class would differ even more from all other classes in java why is this down voted. Its very strange. The fact that there is an explanation for it doesnt make it less surprising or strange +1 because it's not obvious that '==' often fails when working with strings. If you have a variable 'myStr' equal to 'hello', writing myStr=="hello" does not always work (I could be wrong but think it would work if the compiler is able to inline "hello"). I wouldn't call it a "strangest" language feature, just one of the "poorest" language features. +1 A: Since I haven't seen anyone mention it... RPG 2 or 3 (Report Program Generator... aka Rocket Propelled Garbage) is by far the screwyest language I've ever used. It combines almost no control over program flow (Enter at the top of the file, Exit at the bottom) and programming statements are defined based on characters defined in specific columns using a fixed font (think PUNCH CARDS!!). To be really FUBAR you have to attempt to program in DYL-280. It combined RPG flow and logic with COBOL syntax. Look here for RPG: wikipedia.org /wiki/IBM_RPG An example of DYL-280: http://99-bottles-of-beer.net/language-dyl-280-224.html +2 A: For those who didn't know, PostScript is actually a programming language. I've gotten a bit insane with it -- I wrote a PostScript program that computes a Mandelbrot fractal to a very high level of detail. It's really printable PostScript, though it will crash a lot of print drivers... Anyway, where to start with PostScript... Here's one: You can actually create a variable whose identifier is.... nothing. () cvn 5 def % Assign the number 5 to... nothing PostScript is a stack-based language. () puts an empty string on the stack. cvn converts it to a name ("/" if you print it, because all names in PS are preceded by a slash). Then 5 def assigns the value 5 to it. (% is the comment character) You can't directly get it back, e.g. if I say "/ print", this will not print the number 5. But you can get it back indirectly: () cvn load print % this will print the number 5 What else... PostScript has dictionaries as a native type, and you can use an array reference as a key to the dictionary... but it is the REFERENCE that is the key, not the array. So: /myDict 100 dict def [0] dup myDict exch 42 put myDict exch get == % prints 42 myDict [1] 42 put myDict [1] get % throws an undefined error Edit: Oh yeah, one more fun thing... Try the following at a Ghostscript prompt: 1 array dup dup 0 exch put ==  D'oh! Yes, I've seen (well, at least heard of) PostScript documents that contained the value of pi in them where it used the printer itself to actually approximate that value of pi to a certain number of decimal digits for inclusion in the document. ;-) +2 A: Here's some messing around in the Perl debugger:  DB<1> sub foo { +(1..20) } DB<2> @bar = foo(); # list of 1, 2, 3, 4...20 DB<3> x scalar @bar # size of list 0 20 DB<4> x scalar foo(); 0 ''  That's right. When you call the method like that, the scalar context from scalar propagates down into the subroutine call, turning the innocuous-looking .. into an entirely different operator. (That's the "flip-flop" operator, instead of the range operator). +2 A: In Perl: if(true==undef) { print "True\n"; } else{ print "False\n"; } if(undef) { print "True\n"; } else{ print "False\n"; } if(true) { print "True\n"; } else{ print "False\n"; }  Prints: True False True  What's the output? It prints True False True - implying that the automatic undef -> boolean typecasting behaves differently if it's being compared with the == operator. You do realise you can edit an answer, especially CW answers? A: JavaScript: ( {} == {} ) == false  What does it do? What's odd with this? Isn't that just (function is a function) is false? object references just do not match, nothing strange Every time you {}, you create a new object pointer. Two new object pointers aren't the same because they aren't at the same location. not strange, it's like ( object() == object() ) == False in Python @esko - Function is Object, Object is not Function. @code: While I understand what you're saying, how does that apply to this "oddity"? After all isn't this basically about element identities and is pretty much universal to all programming languages - x isn't x unless there's a special rule saying it is. @Delan Azabani: Definitely no, you're messing up with objects and references. {} is not a pointer. It's a new _empty_ object that can be referenced throught either a regular reference variable. Moreover, pointers can be "same" in any language, and point the same objects many times. However, if I do this: a = {}; b = a; we're really setting a pointer because they point to the same object, not a copy. Try it by setting a.c and seeing that b.c is also set. @Delan Azabani: Did I say about copying? I think you're inspired by C/C++. The term pointer is not so applicable for JS 'cause it's ok to say _reference_. All JavaScript objects are passed by reference - an implicit pointer saying in C++ terminology. You said, _Every time you {}, you create a new object pointer._ It's not true because you can write e.g. function(){/*NO REF*/new CustomObject();} (I choosed CustomObject because its constructor could e.g. display something, but a simple {} might be ommitted by JS optimizer) where a newly created object is NOT referenced at all. A: In C,  int x = 1; int y = x++ + ++x; printf("%d", y);  Is ambiguous, what gets printed depends on the compiler. The compiler could store the new value of x++ before ++x is evaluated, or at the end of the statement. it is undefined. You can't change a variable in different places in a statement, that is undefined; not ambiguous. However, I would not say it's ambiguous or undefined or whatever else, even FFJoe used a very old piece of code that many people are familiar with. It's more a C bug or something like those weird things. A programming language should always have the same behavior even for expressions, the most core part of a language. The expression that has been depictured above, I think, always should be deterministic since it always have some defined precedence rules. Sorry, cannot compose sentences in English together well. The problem is that the C language allows operations to occur in any order between sequence points, in order to allow compilers to optimize expressions. The only sequence point in the 2nd line is at the assignment operator, so all of the other operations can take place in any order, according to what the compiler deems the most efficient. Dictating more constraining (more "deterministic") rules about execution order would inhibit optimizations. +21 A: I added the "format" function to Lisp in about 1977, before "printf" even existed (I was copying from the same source as Unix did: Multics). It started off innocently enough, but got laden with feature after feature. Things got out of hand when Guy Steele put in iteration and associated features, which were accepted into the Common Lisp X3J13 ANSI standard. The following example can be found at Table 22-8 in section 22.3.3 of Common Lisp the Language, 2nd Edition:  (defun print-xapping (xapping stream depth) (declare (ignore depth)) (format stream "~:[{~;[~]~:{~S~:[->~S~;~*~]~:^ ~}~:[~; ~]~ ~{~S->~^ ~}~:[~; ~]~[~*~;->~S~;->~*~]~:[}~;]~]" (xectorp xapping) (do ((vp (xectorp xapping)) (sp (finite-part-is-xetp xapping)) (d (xapping-domain xapping) (cdr d)) (r (xapping-range xapping) (cdr r)) (z '() (cons (list (if vp (car r) (car d)) (or vp sp) (car r)) z))) ((null d) (reverse z))) (and (xapping-domain xapping) (or (xapping-exceptions xapping) (xapping-infinite xapping))) (xapping-exceptions xapping) (and (xapping-exceptions xapping) (xapping-infinite xapping)) (ecase (xapping-infinite xapping) ((nil) 0) (:constant 1) (:universal 2)) (xapping-default xapping) (xectorp xapping)))  +1 for a guy who was there. This answer is refreshing considering the plethora of off-the-cuff answers where somebody is surprised C# doesn't work like C++, etc. +1 for someone brave enough to refer to a Lisp eccentricity. man lisp syntax hilighting on SO SUCKS... +3 A: In JavaScript: 1 / 0; // Infinity 1 / -0; // -Infinity  This behavior is defined by IEEE754 -> http://grouper.ieee.org/groups/754/ Other curiosities of this specification is positive and negative NaN:s, +0, 0 and -0. so what? it's just the 1/epsilon limit for epsilon \downto 0 and \epsilon \upto -0 Most languages I know raise some kind of division by zero error. This behavior was a surprise for me. Thats because JavaScript was created ^^COUGH^^glued together^^COUGH^^ on the assumption that most of its users would be idiots, and therefore would be confused by the meaningless errors. What they didn't want was this: "Error on line 5: Division by Zero, WTF does this error message mean????" What they got was this "HLP MY PRGM DOSNT WRK!!!" Ironically, the answers it provides mathematically *are* correct. @Talvi - I would hardly agree. if 1 / 0 = infinity => infinity * 0 = 1, which definitively is not true. I know that @Tobias is right, though. @Ralph your counter-example is flawed per infinity is not (necessarily) commutative. see: http://en.wikipedia.org/wiki/Commutative +16 A: else in Python's for loops. From the Python documentation: for n in range(2, 10): for x in range(2, n): if n % x == 0: print n, 'equals', x, '*', n/x break else: # loop fell through without finding a factor print n, 'is a prime number'  Output: 2 is a prime number 3 is a prime number 4 equals 2 * 2 5 is a prime number 6 equals 2 * 3 7 is a prime number 8 equals 2 * 4 9 equals 3 * 3  What does it do? @Daniel: I believe the else is only executed if the for loop does **not** exit because of a break statement. yes it is executed after the for loop is done. a quick example code snippet would be nice here for those not familiar with python I've added an example There's an else for while and try too. try: else: works just like you would expect (gets executed when no exception is raised); for/white: else: doesn't match the intuition of ~50% of programmers. I expected it to be executed only if the main body of the for/while loop was never executed, but that's not the case -- the else clause is executed only if no break statement inside the for/while loop is executed. Confused yet? A: Delphi don't care about typecast like "word" and will read outside of array arr[0..65535] where pos = 65535: arr[word(pos + 10)] A: The concatenation in Tcl is adding two strings it become one string: set s1 "prime" set s2 "number" set s3$s1$s2 puts s3  The output is primenumber huh? What is strange? "strange" is the way Tcl parses out variables from within strings I guess..., but isn't it common to scripting languages? I agree with corydoras, doesn't seem very odd to me. +6 A: C/C++: The Fast Inverse Square Root algorithm takes advantage of the IEEE floating-point representation (code copied from Wikipedia): float InvSqrt(float x) { union { float f; int i; } tmp; tmp.f = x; tmp.i = 0x5f3759df - (tmp.i >> 1); float y = tmp.f; return y * (1.5f - 0.5f * x * y * y); }  Ah, this is the one that came out of Quake code, right? Love it, though it's not quite a language feature... Yes, it's from Quake. You're right, this has more to do with the IEEE 32-bit floating-point representation than C/C++. A: In C#: a = cond ? b : c; If 'b' & 'c' are "assign incompatible", you'll never get result, even if 'a' is object. It's frequently used and most idiotically implemented operator from MS. For comparison see implementation in D language (note on type inference). It should be noted that the C# implementation is quite sane in that it avoids a few hard problems quite elegantly. Read Eric Lippert’s explanation (somewhere on his blog) on why the conditional operator was designed the way it is. You mean that it won't compile. Also, this is a sensible design decision. Eric Lippert's explanation: http://blogs.msdn.com/b/ericlippert/archive/2010/05/27/cast-operators-do-not-obey-the-distributive-law.aspx, also http://stackoverflow.com/questions/1171717/c-conditional-operator +10 A: This may have been already mentioned, but -- PHP's handling of octal values: $a = 07; // 7 (as it should be)
$b = 08; // 0 (would be an error in any sensible language)$c = 018; // 1 (again, should have been an error)
\$d = 0A; // error (as it should be)


See here: http://bugs.php.net/bug.php?id=29676

Also note the comments on the bug - Derick calls it a feature (as shown by quoting "fix"), not a bug and he claims it would "slow down PHP dramatically in all cases where numbers are used inside scripts" - but then, why does PHP raise an error for 0A?

I think one could make a whole book about the weirdness of PHP...

A:

I came across this one while trying to figure out a MACRO that made absolutely no sense but worked anyway. This is true for objective-c but might be also true for other flavors of C (or at least the gcc compiler)

NSString *oneString = @"This " @"is " @"just " @"one " @"normal " @" string";


equals

NSString *oneString = @"This is just one normal string";


It's also true for C style strings

char* str = "this " "also " "works";

I miss this feature in C#. This is very useful if you have a long string that needs to be wrapped -- you don't need to remember to add explicit concatenation.
Actually after I did something I did realise that I've been using this feature all the time for long strings, I just never tried it in the same line, and when it is in the same line, it just looks so strange.