What? No error? [closed]

Question

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 1

Java

  public static void main(String[] args) throws Exception {
        Integer a = 1, b = 1;
        Integer c = 200, d = 200;
        if ( a != b || c == d) {
            throw new Exception("This should be thrown");
        }
    }

The Integers from the range of -127 .. 127 are cached so Integer.valueOf(127) == Integer.valueOf(127) is true but Integer.valueOf(128) == Integer.valueOf(128) is false.

Answer 2

JavaScript

/21 + 21     // SyntaxError in this

SyntaxError could be expected, but this expression works and even returns true.

Answer 3

python

 = 3
 

You expect

SyntaxError: unexpected indent

Instead you get

SyntaxError: invalid character in identifier

Also this:

" " == " "
False

Unicode spaces

Answer 4

APL

table ← {
  ⍵⍴⍳×/⍵
  [{(]}) ⍝ obviously a syntax error right?
}

Result:

      table 6 8
 1  2  3  4  5  6  7  8
 9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48

This does fail:

table ← {
  [{(]})
  ⍵⍴⍳×/⍵
}

But this runs fine again:

table ← {
  0:[{(]})
  ⍵⍴⍳×/⍵
}

APL parsing is lazy. At least in Dyalog APL. (Really!) Also, a d-fn returns the value of the first line that gets a result. ⍵⍴⍳×/⍵ always returns a value (it's not an assignment and it doesn't have a guard), so, ⍵⍴⍳×/⍵ is run and returns a value, and the second line is never even parsed, thus, no error. In the second example, the line [{(]}) is run first, so it fails. But the third example works, because it has a guard (0:), and 0 is false so it's skipped.

Answer 5

C

I don't belive that nobody posted this yet (sorry for archaeology):

const int main[] = {};

C use the same namespace for function names and variable names. So this will compile and link as valid executable but will return SIGSEGV at runtime.

Answer 6

Java (java.util.regex.Pattern)

This post's effectiveness depends on how much you know about Pattern class documentation. The behavior shown below also depends on the quirks in OpenJDK's Java Class Library (JCL) implementation of Pattern class.

1. Inline flags (valid ones as shown in documentation (?idmsuxU-idmsuxU))

   Pattern.compile("(?t)"); // Throws PatternSyntaxException. Nothing surprising here
   
   Pattern.compile("(?c)"); // Compiles normally (!)
   

   c flag was intended to be used as inline flag for CANON_EQ, but it currently has absolutely no effect, due to the way CANON_EQ is handled.

   There is absolutely no reason to use this in your code.

2. Character class intersection (shown in documentation as [\p{L}&&[^\p{Lu}]] or [a-z&&[def]], i.e. nesting seems to be required from the example)

   Pattern.compile("[\\p{IsAlphabetic}&&\\pM]"); // Compiled normally (!)
   

   And the compiled Pattern also works when matching against "\u0345".

   However, it is still recommended that you follow the documentation's way of writing regex.

3. Character class in \p notation (shown in documentation to specify a POSIX character class, a java.lang.Character class, or for Unicode script/block/category/binary property)

   Pattern.compile("\\p{Letter}"); // Throws PatternSyntaxException. Nothing surprising here
   
   Pattern.compile("\\p{all}"); // Both compiles normally (!)
   Pattern.compile("\\p{L1}");
   

   all and L1 are hidden names usable by \p:

   • \p{all} is equivalent to (?s:.).
   • \p{L1} is equivalent to [\x00-\xFF].

   However, since this is not specified in the documentation, I strongly advise you against using them even if you know you can use them.

Answer 7

C++

How many times have you been told to be careful to avoid index out of bounds errors with your for loops?

#include<iostream>
#include<string>
using namespace std;

int main() {
    string s="text here";
    for(int i=0;i<=s.size();i++)
        cout<<s[i];
    return 0;
}

In C++ (and most other languages), strings are just special char-arrays. In C++, a string always has a buffer of a space at the end, which isn't usually noticed because all the functions, etc. account for it. Here I am just accessing the space directly, so it just prints a space instead of crashing with and index out of bounds error.

Answer 8

PHP

Some slightly non-standard syntax here:

<html>
<body>
<p>Error?</p>
<?php 

echo beach, far away in time;

?>
<p>What error??</p>

What's going on?

There's a three-per-em space after the opening <?php tag. The PHP parser treats this as part of the tag name, and therefore fails to recognise this code block as PHP. Instead it passes it straight to your web browser. Your browser doesn't understand it either, so all you see is the HTML text that surrounds it. (An ordinary non-breaking space would have worked too, but Markdown converts those to regular spaces so we need to use something different.)

Answer 9

Python 2

isSorted = lambda a: all(x>y for x,y in zip(a[1:],a[:-1]))
print isSorted( [(1+3j),(1+2j,),(2+1j)] )

The surplus comma after 1+2j does not raise a syntax error, because this is Python’s way of creating a tuple with one element. But most importantly, this avoids that in isSorted complex numbers are compared and thus a TypeError is raised. This is because apart from two complex numbers you can almost compare everything in Python, including complex numbers and tuples.

Answer 10

Perl

if (false) {
    # Shouldn't happen
}
else {
    die "Huge error";
}

In Perl, false is not a keyword, and it's parsed a bareword ("false"). As "false" is true, the program exits without any exception (die keyword). Both strict and warnings would notice this problem, which shows why using use strict; use warnings; in Perl is a good idea.

Answer 11

Java

It is more convoluted than I would like, but here it goes.

package misc;

import java.io.FileWriter;

public class HelloWorld
{
    public static String writeFile(String fileName)
    {
        try {
            FileWriter fw = null;
            try {
                if( fileName==null ) return "bad parameter!";

                fw = new FileWriter(fileName);
                fw.write("Hello, World!\n");
            } finally {
                fw.close();
            }
        } catch( Exception ex ){
        }

        return "OK";
    }

    public static void main(String[] args)
    {
        String result = writeFile("hello.txt"); // returns OK
        System.out.println(result);

        result = writeFile(null); // should return "bad parameter!", right?
        System.out.println(result);
    }
}

The second call to writeFile should complain, right? It doesn't. Both calls return "OK".

If fileName is null, the very first thing the method does is to return an error message. So how can it return "OK"?

The return "bad parameter!"; is executed. But before returning, it has to execute the final section. At that time, fw is null. It throws a NullPointerException and, well, forgets it was supposed to return. The exception is caught and ignored. The procedure returns "OK".

Answer 12

XML

And you thought you knew XML...

Lo§”“@¥…™¢‰–•~}ñKð}@on%L”…¢¢‡…nÈ…““–k@æ–™“„ZLa”…¢¢‡…n

copy the above in hello.xml and open with IE.

It is encoded in EBCDIC. The XML processor is supposed to detect it. It does in IE. But when you view it, it is usually displayed in UTF or latin, so it is all garbled.

Answer 13

Ruby

1 / 0.0  

This does not result in a ZeroDivisionError, but in

# => Infinity

Answer 14

C#

using System;
class DivideByZero
{
   static int \u004F = Convert.ToInt16('\u0031');

   static void Main(string[] args)
   {
      Console.WriteLine(1 / O);  // Divide by Zero
   }
}

This code is actually dividing by O(the letter) and not 0(the number). If you know your hexadecimal ASCII characters well, then you might notice that I am setting the value of O(the letter) to '1' converted to an int16. Perhaps even weirder to some people, the output of this program is (the number): 0

Answer 15

Casio Calculator

It's quite hard to count bytes/tokens in this "language" - I've given the number of keypresses required, excluding Shift, Alpha (the second shift key) and = at the end - this certainly fits into 1 byte per keypress.

Tested on the fx-85GT PLUS model, which is a standard, non-graphing, "non-programmable" scientific calculator. Other models will work.

These calculators have two possible input/output formats: MathIO, which is default, and displays expressions as they are written on paper (e.g. fractions display properly), and LineIO, which uses the more conventional method of representing expressions as a single string of characters without vertical dimension - e.g. square root is √(...), fractions are 1⎦2 (that's meant to be like an underscore with a vertical bar of equal length attached to the right, like _| but as a single character).

Code

You'd think that this monstrosity would give many syntax errors. How to enter it:

((.!%PowerNegative-.DegreeRight (close-paren if in linear mode)%Degree

Press = to evaluate it.

What it looks like in linear mode:

((.!%^(--.°)%°

Decimal points without numbers, multiple percent signs, multiple degree signs, too many minuses, unclosed parentheses...

Output

0°0'36"

. evaluates to 0, just as .5 is 0.5 and 5. is 5.
Parentheses are automatically closed at the end of the expression.
((.!%^(--.°) on its own evaluates to 1 - the degree symbol disappears.
Although the calculator uses different symbols for negation and subtraction, the latter can be used for both, while the first only negates. --. is just 0.
Multiple percent symbols can be used in a single number - 1%% evaluates to 0.0001.
Without the final °, the expression evaluates to 0.01.

Answer 16

REBOL

do not run "this"

---

How it works:

do: execute the following code.
not: negate.
run: runs the following thing as a bash command.
"this": an illegal bash command, does nothing.

Answer 17

Ruby

class Foo

  def self.get_bar
    self.bar
  end

  private

  def self.bar
    1 + 1
  end

end

p Foo.bar

Prints 2. Yeah, Ruby just doesn't apply the private modifier to class methods if you declare them this way. If you instead do this in a class << self block it works fine.

Answer 18

Clojure

  (defn check-nil [v] {:pre [nil? v]} v)
 
  (check-nil nil) 

  (defn check-keyword [v] {:pre [keyword? v]} v)
 
  (check-keyword “sdf”) 

First one throwing exception but second one does not throw any exception. First one v itself is null that way it throw exception. The form should be {:pre [(nil? v)]} and {:pre [(keyword? v)]}

Answer 19

Haskell

main=print (0/0, 1/0)

It is funny because Haskell is such a mathematical language, but this won't produce a zero-division error. Instead it outputs (NaN,Infinity). This is because division isn't defined on integer anyways, so it just assumes they are floats, which can be NaN and Infinity.

Answer 20

C

#include <stdio.h>
#include <string.h>

int main(void)
{
    if(1 != 0)
        perror("Error?");

    return 0;
}

perror() produces a message describing the last error encountered during a call to a system or library function - In the absence of an error it will print "Success". As such the output of the program is: "Error?: Success"

Answer 21

This isn't anything new, but still, the syntax of C/C++ in gcc has always amazed me ;-) Of course, it compiles without any errors by gcc -Wall -pedantic-errors.

#include <ctype.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
    char p = '!';

    switch (argc) {
        while (!isdigit(p))
    case 1:
        p += 1;
        do { break;
    case 2:
        p = '1';
        continue;
    default:
        p = *1[argv];
        } while (false);
    }

    printf("%c\n", p);

    return 0;
}

a[b] is just *(a+b) and cases in switch are just labels. As a bonus, continue works like break here, because the loop checks the condition before jumping. Also, it's nice trick to spell default as defau1t while using a font where 1 and l are hard to distinguish.

:-)

Answer 22

#include <stdio.h>

int main(void) {
    if ("hello"=="hello") {
        printf("Same!\n");
    } else {
        printf("Different!\n");
    }
    return 0;
}

---

Hint:

Oh ho! This is classic CS 101 stuff. Strings should not be compared directly, because they're pointers!

---

Answer:

. . . except that in this case, since they're the same literal, the compiler has optimized the literals to point to the same location in memory. Hence the output: "Same!\n".

Answer 23

Haskell

{-# LANGUAGE FlexibleInstances, FlexibleContexts #-}

import Control.Monad

main = 0 -- just bogus value so we can compile and see if the below definitions make sense...
         -- will be an error if you actually try to run this as a program.

data Complex a = Complex { realPart :: a, imagPart :: a }

instance Monad Complex where  -- to get convenience functions `liftM` etc..
  return x = Complex x x
  Complex r i >>= f = f r

instance (Monad complex, Num a) => Num (complex a) where
                            -- allow `Complex` to be used with numerical operators
  fromInteger = return . fromInteger
  (+) = liftM2(+)
  (*) = liftM2(*)
  abs = liftM abs
  signum = liftM signum

instance (Monad Complex, Fractional a) => Fractional (Complex a) where
  fromRational = return . fromRational
  (/) = liftM2(/)

Indeed, it's normally not possible to define an effectful action such as main by simply writing = number. If you try to run main = 0 alone, it'll sure enough give an error (indeed at compile time already).
However, I made a mistake further down in the code: the Num (complex a) instance should have Complex in uppercase like everywhere else. But it's lowercase, so the compiler will interpret this as a type variable and define a Num instance not only for Complex, but for all Monad types. This includes particularly the IO monad, so all of the sudden the definition of main on top makes sense: 0 is now an acceptable value, and will simply be wrapped up and returned.

Answer 24

Python

Looks like this should produce an indentation error:

def a():
 print "start"
 if True:
                    for x in range(2):
                     print x 
 if False:
            print "do not print this"

 a()

but it doesn't. And it prints "start" and then 0 and 1.

In fact, Python interpreter doesn't care about the size of indentation, and it is relative to the current block.

Answer 25

JavaScript

var bSum = function (result, current, index, source) {
    return  result + (current << ( soucre.length - index - 1))
}
[1,0,1,0,1,0].reduce (bSum,0) //42

This obviously fails with a ReferenceError: soucre is not defined right?

Nope,
because of the function expression, there is no ASI, and the ArrayLiteral becomes a Property Accesor. Since the function has no property 0. The above fails even before, throwing a
TypeError: Cannot call method 'reduce' of undefined

Answer 26

Bit late on this one, but whatever.

PHP

<?='this ';</script>is some<%echo('code');

outputs "this is some code" (at least on my system)

PHP allows <script>...</script> and <%...%> alongside <?php...?>, <?...?>, and <?=...?> for enclosing tags for reasons nobody quite understands, allows mixing of these tags in a single script (in this example, <?=...</script> for reasons nobody quite understands, and doesn't actually require a closing tag for reasons nobody quite understands. As such, this is actually two separate code segments (<?='this ';</script> and <%echo('code');), with is some just being garbage.

Answer 27

C++

Two plus two is minus four.

#include <cassert>

int main() {
  struct {
    int two : 2;
  } _;
  _.two = 2;

  assert(_.two + _.two == -4);

  return 0;
}

Returns successfully; there is no error. http://ideone.com/eHQcJQ

This is actually quite a useful (but dangerous) feature - controlled overflow of a limited size bitfield struct member.

Answer 28

JavaScript

As you've seen, using 99999.toString() gives an error, where 99999..toString() works.

Now, have a look at this code:

0322323022302343534534535043.toString()

The number here is an octal (base-8) number. The octal notation does not have decimals in JavaScript.

Answer 29

Javascript

a = 1
a+++1

Javascript now has a triple plus operator

Answer 30

Go

package main insofaras
import "fmt" notwithstanding
func whereas main() {
    fmt despiteallobjections.Println(
        thetruthofthematter "Hello, world!")
}

http://golang.org/src/cmd/gc/lex.c defines some strange keywords like despiteallobjections, which are ignored by the language.