[Question]
  [
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
 
 
Closed 8 years ago.
**Locked**. This question and its answers are [locked](/help/locked-posts) because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
 
 
Your task is simple. Write a program that should obviously produce an error on first glance either when compiled or run, but either doesn't or produces some other unrelated error. This is a popularity contest, so be creative.
  
[Answer]
# C++
Make sure you compile the following code in standard conforming mode (for example, for g++ use the -ansi flag):
```
int main()
{
  // why doesn't the following line give a type mismatch error??/
  return "success!";
}
```
How it works:
> 
>  The ??/ is a trigraph sequence that is translated into a backslash which escapes the following newline, so the next line is still part of the comment and therefore won't generate a syntax error. Note that in C++, omitting the return in `main` is well defined and equivalent to returning 0, indicating a successful run.
> 
> 
> 
[Answer]
# Ruby
Always a fan of this one.
```
x = x
```
No `NameError`. x is now `nil`.
> 
>  This is just a "feature" of Ruby :-)
> 
> 
> 
Here's a more mundane one that's gotten me before:
```
x = 42
if x < 0
  raise Exception, "no negatives please"
elseif x == 42
  raise Exception, "ah! the meaning of life"
else  
  p 'nothing to see here...'
end 
```
Prints "nothing to see here."
> 
>  It's **elsif**, not **elseif**. (and it's certainly not **elif** - woe to the wayward python programmer (me)!) So to the interpreter **elseif** looks like a normal method call, and since we don't enter the x<0 block, we go straight on to **else** and don't raise an exception. This bug is incredibly obvious in any syntax-highlighting environment, thankfully (?) code golf is not such an environment.
> 
> 
> 
[Answer]
# C?
Pretty normal code here...
```
void main() = main--;
```
> 
>  It's Haskell, not C. It defines a function named "void" that takes two arguments. The first is named "main" and if the second (unnamed) is an empty tuple, it returns the "main" variable. "--" starts a comment in Haskell, so the ";" is commented out.
> 
> 
> 
[Answer]
# JavaScript
```
var а = 100;
if (typeof a !== 'undefined') throw 'This should always throw, right?';
console.log('How am I still alive?');
```
Here's how it works:
> 
>  The first `a` is actually an `а` (that is, Cryllic Unicode "a").
> 
> 
> 
[Answer]
# JavaScript
When I was providing the following code I was told many times *"It must be a typo! How can it work?"*.
```
console.log( 42..toString(2) );
```
The description below was copied exactly from [one the recent cases](https://codegolf.stackexchange.com/a/21381/14901).
> 
>  As you probably know, in JavaScript everything except literals is an object. Numbers are objects as well. So theoretically (and practically) you may get properties or call methods of any non-literal via dot notation, as you do `'string'.length` or `[1,2,3].pop()`. In case of numbers you may do the same but you should keep in mind that after a single dot the parser will look for a fractional part of the number expecting a float value (as in `123.45`). If you use an integer you should "tell" the parser that a fractional part is empty, setting an extra dot before addressing a property: `123..method()`.
> 
> 
> 
[Answer]
# bash
```
#!/bin/bash
[ 1 < 2 ] && exit
for i in `seq 1 $[2 ** 64]`
    do "$0" | "$0"
done
while [[ false ]]
    do :
done
if maybe
    do [: [: [: [: [; [; [; [; ;] ;] ;] ;] :] :] :] :]
fi
```
### Results
* You might expect the script not to produce any errors at all, since it exits after the first command. It doesn't.
* You might expect the typical error messages caused by an ongoing fork bomb due to the `for` loop. There's no fork bomb.
* You might expect bash to complain about the missing `maybe` command or the whole bunch of syntax error inside the `if` block. It won't.
* The only error message the script *might* produce ends in `2: No such file or directory`.
### Explanation
* > 
>  `[` isn't special to bash, so `< 2` performs, as usual, redirection. Unless there is a file with name `2` in the current directory, this will cause an error.
> 
> 
>
* > 
>  Due to that error above, the command before `&&` will have a non-zero exit status and `exit` will not be executed.
> 
> 
>
* > 
>  The `for` loop isn't infinite. In fact, there's no loop at all. Since bash cannot compute the 64th power of 2, the arithmetic expression's result is `0`.
> 
> 
>
* > 
>  `[[ false ]]` tests if `false` is a null string. It isn't, so this `while` loop is infinite.
> 
> 
>
* > 
>  Because of the above, the `if` statement never gets executed, so no errors get detected.
> 
> 
>
[Answer]
## Perl
```
use strict;
use warnings;
Syntax error!
exit 0;
```
Source and explanation: <https://stackoverflow.com/questions/11695110>
[Answer]
# Java
```
class Gotcha {
    public static void main(String... args) {
        try  {
            main();
        } finally {
            main();
        }
    }
}
```
No stack overflows here; move along.
> 
>  At first glance, this should produce a `StackOverflowError`, but it doesn't! It actually just runs forever (for all practical purposes at least; technically it would terminate after a time many orders of magnitude longer than the age of the universe). If you want to know how/why this works, see [this](https://stackoverflow.com/questions/12438786/try-finally-block-prevents-stackoverflowerror). Also, if you happen to be wondering why we can call `main()` without arguments when the main method generally would need a `String[]` argument: it's because we've declared it to be variable-argument here, which is perfectly valid.
> 
> 
> 
[Answer]
# CoffeeScript
```
What? No error? Yep, this code does not have any bugs, why would it?
```
> 
>  `?` followed by a space is operator that calls a function, but only if it exists. JavaScript doesn't have a function called `What`, therefore the function isn't called, and its arguments are simply ignored. The other words in the code are function calls that actually aren't called, because `What` function doesn't exist. At end, `?` is existence operator, as it is not used in call function. Other sentence enders, such as `.` or `!` would not work, as `.` is for methods, and `!` is not operator (which cannot be used after an identifier).
> 
>  To read how CoffeeScript converted this to JavaScript, visit <http://coffeescript.org/#try:What%3F%20No%20error%3F%20Yep%2C%20this%20code%20does%20not%20have%20any%20bugs%2C%20why%20it%20would%3F>.
> 
> 
> 
[Answer]
# VBScript
The `&` operator in VBScript is string concatenation but what on earth are the `&&` and `&&&` operators? (Recall that the "and" operator in VBScript is `And`, not `&&`.)
```
x = 10&987&&654&&&321
```
That program fragment is legal VBScript. Why? And what is the value of `x`?
> 
>  The lexer breaks this down as `x = 10 & 987 & &654& & &321`. An integer literal which begins with `&` is, bizarrely enough, an octal literal. An octal literal which ends with `&` is, even more bizarrely, a long integer. So the value of x is the concatenation of the decimal values of those four integers: `10987428209`.
> 
> 
> 
[Answer]
# Objective-C
Not a big deal, but it has surprised me while trying to put a link inside a comment: 
```
http://www.google.com
        return 42;
```
> 
>  http is a code label here, such labels are used in goto instructions
> 
> 
> 
[Answer]
# C#
```
class Foo
{
    static void Main(string[] args)
    {
        Bar();
    }
    static IEnumerable<object> Bar()
    {
        throw new Exception("I am invincible!");
        yield break;
    }
}
```
> 
>  Because the `Bar` method does a `yield`, the method doesn't actually run when called, it returns an enumerator which, when iterated,s runs the method.
> 
> 
> 
[Answer]
## C
```
main=195;
```
> 
>  Works on x86 platforms, where 195 is the opcode for ret. Does nothing,
> 
> 
> 
[Answer]
# Java
Probably too obvious.
```
public static void main(String[] varargs) throws Exception{
    char a, b = (char)Integer.parseInt("000d",16);
    // Chars have \u000d as value, so they're equal
    if(a == b){
        throw new Exception("This should be thrown");
    }
}
```
What?
> 
>  Throws a syntax error after `\u000d`. `\u000d` is the unicode for a new line. Even though it is commented out, the Java compiler treats what is after this as code since it isn't commented out anymore.
> 
> 
> 
[Answer]
# C++
```
#include <iostream>
int succ(int x)
{
  return x + 1;
}
int succ(double x)
{
  return int(x + 1.0);
}
int succ(int *p)
{
  return *p + 1;
}
int main()
{
  std::cout << succ(NULL) << '\n';
}
```
Why?
> 
>  `NULL` is an intergal constant, so it matches the `int` overload strictly better than the `int*` one. Still, most programmers have `NULL` associated with pointers, so a null pointer dereference can be expected.
> 
> 
> 
[Answer]
## Python
```
print """""quintuple-quoted strings!"""""
```
> 
>  Perfectly valid, but the output is hard to guess. The first 3 " characters start a multiline string and the next two are part of the string. At the end, the first three "s terminate the string and the last two are an empty string literal that gets concatenated by the parser to the multiline string.
> 
> 
> 
[Answer]
## **JavaScript**
```
if (1/0 === -1/0) {
  throw "Surely there's an error in here somewhere...";
}
```
How it works:
> 
>  There's positive and negative infinity in JS, and no error for dividing by zero.
> 
> 
> 
[Answer]
## C++
Mixing trigraphs and space-less lambdas can be quite confusing and definitely look erroneous to people who are not aware of trigraphs:
```
int main()
{
    return??-??(??)()??<return"??/x00FF";??>()??(0??);
}
```
How it works:
> 
>  Some sequences consisting of 3 symbols, beginning with ??, are called trigraphs and will be substituted by a fully-compliant preprocessor. Preprocessed, the line in question looks as follows: **return ~[] (){ return "\x00FF"; }()[0];** As one can see, this is nothing but a superfluous lambda function returning a string consisting of the 0xFFth character. The **[0]** just extracts that character and **~** NOTs it, so 0 is returned.
> 
> 
> 
[Answer]
## VBA/VB6
```
Private Sub DivByZero()
    Dim x() As String
    x = Split(vbNullString, ",")
    Debug.Print 1 / UBound(x)
End Sub
```
Splitting an empty comma delimited string should give an empty array. Should be an obvious division by zero error, right?
> 
>  Nope. Surprisingly, when any zero length string is split the runtime
>  gives you an array with a lower bound of 0 and an upper bound of -1.
>  The code above will output -1.
> 
> 
> 
[Answer]
# Javascript
```
5..toString();
5 .toString();
```
Gives:
5
Whereas:
```
5.toString();
```
Gives SyntaxError
How it works:
> 
>  JavaScript tries to parse dot on a number as a floating point literal
> 
> 
> 
[Answer]
# HTML
First post here, I'm not sure I get this or not, but here goes.
```
<html>
    <head></head>
    <body>
        <?php $_POST['non-existant'] = $idontexisteither ?>
    </body>
</html>
```
---
> 
>  It's a `.html` file...
> 
> 
> 
[Answer]
# VBScript
Visual Basic 6 users will know that
```
If Blah Then Foo Bar
```
is legal, as is
```
If Blah Then 
    Foo Bar
End If
```
But what about
```
If Blah Then Foo Bar End If
```
? Turns out that is legal in VBScript but not in VB6. Why?
> 
>  It's a bug in the parser; the intention was to reject this. The code which detects the `End If` was supposed to also check whether it was a multi-line `If` statement, and it did not. When I tried to fix it and sent out a beta with the fix, a certain influential industry news organization discovered that they had this line of code in one of their VBScript programs and said they would give the new version a low rating unless we un-fixed the bug, because they didn't want to change their source code.
> 
> 
> 
[Answer]
# C
This reminded me of an error I ran into when I learned C. Sadly the original variant doesn't seem to work with a current GCC, but this one still does:
```
#define ARR_SIZE 1234
int main() {
    int i = ARR_SIZE;
    int arr[ARR_SIZE];
    while(i >= 0) {
        (--i)[arr] = 0;
    }
    i = *(int*)0;
}
```
This obviously segfaults because we dereference a null pointer, right?
> 
>  Wrong - actually, it's an infinite loop as our loop condition is off by one. Due to the prefix decrement, `i` runs from 1023 to -1. This means the assignment overwrites not only all elements in `arr`, but also the memory location directly before it - which happens to be the place where `i` is stored. On reaching `-1`, `i` overwrites itself with `0` and thus the loop condition is fulfilled again...
> 
> 
> 
This was the original variant I which I can't reproduce anymore:
> 
>  The same thing worked with `i` going upwards from 0 and being off by one. The latest GCC always stores `i` before `arr` in memory; this must have been different in older versions (maybe depending on declaration order). It was an actual error I produced in one of my first toy programs dealing with arrays.
> 
> 
> 
Also, this one's obvious if you know how pointers work in C, but can be surprising if you don't:
> 
>  You might think that the assignment to `(--i)[arr]` throws an error, but it's valid and equivalent to `arr[--i]`. An expression `a[x]` is just syntactic sugar for `*(a + x)` which computes and dereferences the pointer to the indexed element; the addition is of course commutative and thus equivalent to `*(x + a)`.
> 
> 
> 
[Answer]
## Java
```
public class WhatTheHeckException extends RuntimeException {
    private static double d;        // Uninitialized variable
    public static void main(String... args) {
        if (d/d==d/d) throw new WhatTheHeckException();
        // Well that should always be true right? == is reflexive!
        System.out.println("Nothing to see here...");
    }
}
```
Why this works:
> 
>  Unitialized fields have default values. In this case **d** is just **0**. **0/0 = NaN** in double division, and **NaN** never equals itself, so the **if** returns false. Note this would not work if you had **0/0==0/0**, as at would be integer **0/0** division would WOULD throw an **ArithmeticException**.
> 
> 
> 
[Answer]
# PHP (40 bytes)
```
<?for(;;$e.=$e++)foreach($e::$e()as&$e);
```
This was the answer I gave in this question: [Insanity Check Program](https://codegolf.stackexchange.com/questions/19115/insanity-check-program/20421#20421)
The idea was to make a code that produced errors.
The 1st error that we will think of, is a syntax error.
There are no syntax errors...
Other would be that the class/function doesn't exist.
It doesn't run that far...
Other would be a time-out or a memory overflow, but, again, it doesn't reach that far...
Test the code here: <http://writecodeonline.com/php/> (remove the `<?` on the beginning to test).
[Answer]
# C++11
```
struct comp {
    comp operator compl () { return comp { }; }
    operator comp () { return comp { }; }
    compl comp () { return; comp { }; }
};
int main() {
    comp com;
    compl com;
}
```
Compiles and runs without any warnings with `g++ -pedantic-errors -std=c++11`.
> 
>  `compl` is a standard alternative spelling for `~`, just like `not` is an alternative for `!`. `compl` is used here to first override `operator~` and then define a destructor. Another trick is that `operator comp` is a conversion function from the type `comp` to itself. Surprisingly the standard does not forbid such a conversion function - but it does say that such a function is never used.
> 
> 
> 
[Answer]
# VBScript
```
function[:(](["):"]):[:(]=["):"]:
end function
msgbox getref(":(")(":)")
'Output: :)
```
What it does:
> 
> Function, Sub and Variable Names in VBScript can be anything if you use square brackets. This script makes a function called `:(` and one argument `"):"` but because they do not follow normal naming convention they are surrounded by square brackets. The return value is set to the parameter value. An additional colon is used to get everything on one line. The Msgbox statement gets a reference to the function (but does not need the brackets) and calls it with a smiley `:)` as parameter.
> 
> 
> 
[Answer]
## C#
Actually I caught myself on mistakenly doing just that :)
```
public static object Crash(int i)
{
    if (i > 0)
        return i + 1;
    else
        return new ArgumentOutOfRangeException("i");
}
public static void Main()
{
    Crash(-1);
}
```
> 
>  **throw**, not **return**.
> 
> 
> 
[Answer]
# Java
```
enum derp
{
    public static void main(String[] a)
    {
        System.out.println(new org.yaml.snakeyaml.Yaml().dump(new java.awt.Point()));
    }
}
```
And how that one works:
> 
>  Firs you think the Enum is not valid but its valid; then you think it will print a standard Point objects attributes but Gotcha! due to how Snakeyaml serializes you get a smooth StackOverFLow error
> 
> 
> 
And another one:
```
enum derp
{
    ;public static void main(String[] a)
    {
        main(a);
    }
    static int x = 1;
    static
    {
        System.exit(x);
    }
}
```
> 
>  you think a Stackoverflow will happen due to the obvious recursion but the program abuses the fact that when you run it the `static{} block` will be executed first and due to that it exits before the main() loads
> 
> 
> 
```
enum derp
{
    ;
        public static void main(
            String[] a)
    {
        int aa=1;
        int ab=0x000d;
        //setting integer ab to \u000d  /*)
        ab=0;
        
        /*Error!*/
        aa/=ab;
    }
    static int x = 1;
}
```
> 
>  this one relies on that `/*Error*/`-commented out code as closing point for the comment opened before the ab=0; the explain about the integer ab to 0x000d hides the newline to activate the commentout of the next line
> 
> 
> 
[Answer]
# C
Strings and arrays in c can be pretty confusing
```
main(){
  int i=0;
  char string[64]="Hello world;H%s";
  while(strlen(&i++[string])){
    i[' '+string]=string[i]-' ';
  }
  5[string]=44;
  return printf(string,'!'+string);
}
```
]