Python

Typical sunday afternoon in a house of three brothers.

try: # The night before the exam. assert(2/5 < 3/5) # Math is hard! print("Be quiet!") except: # Options: 1. Play. 2. Do nothing. try: print(__import__("this").s) except: "Too afraid to snap back." 

Output

$ # Older brother: $ python3.4 123.py Be quiet! $ $ # Much younger brother: $ ./python1 123.py $ $ # Slightly younger brother: $ python2.7 123.py The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those! Gur Mra bs Clguba, ol Gvz Crgref Ornhgvshy vf orggre guna htyl. Rkcyvpvg vf orggre guna vzcyvpvg. Fvzcyr vf orggre guna pbzcyrk. Pbzcyrk vf orggre guna pbzcyvpngrq. Syng vf orggre guna arfgrq. Fcnefr vf orggre guna qrafr. Ernqnovyvgl pbhagf. Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf. Nygubhtu cenpgvpnyvgl orngf chevgl. Reebef fubhyq arire cnff fvyragyl. Hayrff rkcyvpvgyl fvyraprq. Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff. Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg. Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu. Abj vf orggre guna arire. Nygubhtu arire vf bsgra orggre guna *evtug* abj. Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn. Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn. Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr! 

How it works

try: assert(2/5 < 3/5) # In Python 3, '2/5' and '3/5' are floats. # In lower versions, they're ints and the assertion fails. print("Be quiet!") # Python 3 prints this and exits. # Lower versions already caught an exception. except: try: print(__import__("this").s) # Try importing 'this' (an easter egg which prints the Zen of # Python) and printing 'this.s' (same old Zen with ROT13 obfuscation). # The easter egg doesn't exist in Python 1 and an exception is raised. except: "Too afraid to snap back." # Bare string. Would be printed in REPL; does nothing in a program. 

This C++03 C++11 and C++14 program prints old, medium or new: (C++03 is a set of technical corrections to C++98: compilers consider the two to be synonymous)

#define M(x, ...) __VA_ARGS__ int a[] = { M(1'2, 3'4, 5, 0) }; const char *b[]={ 0, "is", "the", "best", "always", "new" }; struct foo { ~foo() { throw std::string("old"); } }; void done() { std::cout << "medium" << std::endl; std::exit(0); } int main() { if (b[a[1]]) { std::cout << b[a[1]] << std::endl; } else { std::set_terminate(done); try { foo test; } catch( std::string c) { std::cout << c.c_str() << std::endl; } } } 

live example

There are a few ways to do this; I figured out ways that current versions of clang and gcc support when you tell it to compile in a particular version mode.

It relies on a few things.

To distinguish C++14 from C++11/C++03, it uses ' as an internal delimiter in integer constants. Then I discard a leading token, which either contains a , or not depending on the C++ version. The 2nd element of the array is now either 0 or 5. I use this to look up in another array -- entry 0 is null, and entry 5 is "new". If it is non-null, I print it and am finished (for C++14).

To distinguish C++03 from C++11, it throws from a destructor. In C++11, all destructors are implicitly noexcept, which calls the std::set_terminate handler.

I install a terminate handler that prints out "medium" (for C++11), and in the catch block I print "old" (for C++03).

Breaking changes stolen from here for C++11 and here for C++14.

C

Golfed, for the hell of it.

O;main(o){o=((O='\o'),O);} 

It does nothing.

Fortunately.
I didn't find anything relevant, so this is just about playing with undefined behaviors again.

C89

§3.1.3.4 7 — Character constants

In addition, certain nongraphic characters are representable by escape sequences consisting of the backslash \ followed by a lower-case letter: \a , \b , \f , \n , \r , \t , and \v . If any other escape sequence is encountered, the behavior is undefined.

Yup. '\o' implies an undefined behavior in C89, while it is only implemention-defined in C99 and C11 (it gives me 'o').

C99

This is where it gets tricky.

§6.5.16 4 — Assignment operators

(...) If an attempt is made to modify the result of an assignment operator or to access it after the next sequence point, the behavior is undefined.

This is a weird wording specific to C99.

A sequence point is needed after (O='\o'): , do the trick.
Since it is necessary to access the result (i.e. "to read or modify the value of an object" as defined by the standard, whose identifier is O) to store it in o, the behavior is undefined.

C11

All of that does not apply in C11.
It should work fine while compiling in C11.
Nobody uses C11.