24
\$\begingroup\$

Inspired by I'm not the language you're looking for!

Challenge

Choose two different programming languages, and write a program that prints the following line to stdout (or equivalent):

This program errors out in <the current language> :P

and then generates different kind of error in each of the two languages.

Rules

Some rules are taken from the original challenge.

  • In the output, language names should exactly follow:
    • The name listed on TIO, optionally excluding the version number and/or the implementation name (e.g. if you use JavaScript (Node.js) as one of your languages, you can use JavaScript for your language name, but not JS or Javascript.)
    • The full name on the official website (or GitHub repo) if your language of choice is not available on TIO.
  • Neither program should take any input from the user.
  • You may use comments in either language.
  • Two different versions of the same language count as different languages.
    • If this is done, the program should output the major version number, and if running on two different minor versions, should report the minor version also.
    • You should not use prebuilt version functions (this includes variables that have already been evaluated at runtime).
  • Two different command line flags in the same language also count as different languages as per this meta consensus, as long as the flags don't include code fragments (such as -Dblahblah... in C).
    • If this is done, the program should also output the flag used.
  • Two errors are considered different unless both errors are generated by the same semantics (such as "division by zero", "segmentation fault", or "index out of range").
    • If a language's runtime does not exit after an error, but reports the error in some way to the user, it's a valid error.
    • If a language does not discriminate the error messages but has a known list of reasons that cause error, you must specify the reason, not the error message.
      An example is ><>, which has only one error message something smells fishy..., but esolangs wiki page has a list of error reasons.
  • Syntax error is not allowed unless it is generated by calling eval() or similar.
  • Throwing something manually (via throw(JS), raise(Python), die(Perl) or similar) is allowed, but all of them are considered as one kind of error.
  • Error by invalid command in 2D or golflangs is also allowed (and treated as one kind of error).

Examples

Python and Ruby

  • Python: This program errors out in Python :P to stdout, then undefined identifier
  • Ruby: This program errors out in Ruby :P to stdout, then index out of bounds

C89 and C99

  • C89: This program errors out in C 89 :P to stdout, then division by zero
  • C99: This program errors out in C 99 :P to stdout, then segmentation fault

Note that the version number should always be separated from the language name by a space.

Python 2.7.9 and Python 2.7.10

  • Python 2.7.9: This program errors out in Python 2.7.9 :P to stdout, then syntax error on eval
  • Python 2.7.10: This program errors out in Python 2.7.10 :P to stdout, then key error on dict

Perl and Perl -n

  • Perl: This program errors out in Perl :P to stdout, then invalid time format
  • Perl -n: This program errors out in Perl -n :P to stdout, then try to open a file that doesn't exist

Winning condition

This is , so the shortest code in bytes wins. But you're always encouraged to post an answer that is fun or interesting even if it isn't very short.

\$\endgroup\$
  • \$\begingroup\$ Sandbox post (deleted) \$\endgroup\$ – Bubbler Mar 21 '18 at 4:58
  • \$\begingroup\$ Does the error need to halt the program? \$\endgroup\$ – Jo King Mar 21 '18 at 5:00
  • \$\begingroup\$ I initially thought so. However, if there are some languages that may continue (possibly with undefined behavior) after something like "division by zero", with some mechanism to acknowledge that the program encountered that error, then I will happily allow that. \$\endgroup\$ – Bubbler Mar 21 '18 at 5:12
  • \$\begingroup\$ I think I already know the answer, but just in case: may the sentence This program errors out in ... contain mixed tabs/spaces instead of just spaces? \$\endgroup\$ – Kevin Cruijssen Mar 21 '18 at 9:08
  • \$\begingroup\$ Related (print two different texts in two different languages). \$\endgroup\$ – Kevin Cruijssen Mar 21 '18 at 10:13

32 Answers 32

27
\$\begingroup\$

Python 2 / Python 3, 60 bytes

print("This program errors out in Python %d :P"%(3/2*2))*1;a
  • Python 2 got NameError: name 'a' is not defined
  • Python 3 got unsupported operand type(s) for *: 'NoneType' and 'int'

Python 2:

  • / is integer division, 3 / 2 got 1; int(3 / 2 * 2) is 2.
  • print is a statement, so the first statement read as print((...)*1), here *1 means repeating the string once.
  • second statement referenced a non-existing variable, which caused the error.
  • Try it online!

Python 3:

  • '/' is floating number division, 3 / 2 got 1.5; int(3 / 2 * 2) is 3.
  • print is a function, so the first statement read as (print(...))*1.
  • function print returns None; Multiplication do not work on None x int, so it report "unsupported operand".
  • Try it online!
\$\endgroup\$
15
\$\begingroup\$

C and C++, 114 101 bytes

-13 bytes thanks to l4m2!

#include<stdio.h>
main(){auto d=.5;printf("This program errors out in C%s :P",d?"++":"");2[&d]+=1/d;}

Segmentation fault in C++, floating point exception in C.

auto is defaulted to int in C so (int).5 becomes 0, so trying to divide by it is basically division by zero.

In C++ 1/d is 2, adding it to address of d and trying to change that address' value throws a segfault.

Try it in C++!
Try it in C!

\$\endgroup\$
  • 1
    \$\begingroup\$ Not sure if it helps, but if you can map C/C++ to 2 and 0, you could use "++"+n, where n is 0 for C++ and 2 for C \$\endgroup\$ – Conor O'Brien Mar 21 '18 at 14:47
  • 1
    \$\begingroup\$ d?"++":"" 9 char, "++"+4*d 8 char. But gets C/C++ backwards. Sigh. \$\endgroup\$ – Yakk Mar 22 '18 at 15:30
  • 1
    \$\begingroup\$ int main(){auto d=.5;printf("This program errors out in C%s :P",d?"++":"");2[&d]+=1/d;}(105) though I don't know why \$\endgroup\$ – l4m2 May 4 '18 at 8:36
  • 1
    \$\begingroup\$ Also int can be omitted \$\endgroup\$ – l4m2 May 4 '18 at 8:37
  • \$\begingroup\$ Suggest L"⬫"+!d instead of d?"++":"" \$\endgroup\$ – ceilingcat Dec 7 '18 at 20:54
13
\$\begingroup\$

JavaScript + HTML / HTML + JavaScript, 160 bytes

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

Not sure if this count two languages, but it is funny.

\$\endgroup\$
  • \$\begingroup\$ So, the former is undefined identifier, the latter is function call on a non-function type. Technically I'd consider the former HTML and the latter JavaScript, but really nice idea. \$\endgroup\$ – Bubbler Mar 21 '18 at 23:35
  • \$\begingroup\$ A good use of <!-- ... --> as single line comment markers (I know that this is in the spec for backward compatibility reasons) \$\endgroup\$ – Shieru Asakoto Oct 12 '18 at 8:50
12
\$\begingroup\$

Java 8 & C99, 172 bytes

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

Based on my answer for the 'abc' and 'cba' challenge.

Try it in Java 8 - resulting in ArrayIndexOutOfBoundsException: 1.
Try it in C - resulting in Floating point exception: division by zero is undefined.

Explanation:

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

As you can see in the Java-highlighted code above, the first line is a comment due to //, and the C-code is a comment due to /* ... */, resulting in:

interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]="";}}

So it prints to STDOUT, and then tries to access the second program-argument (when none given), so it produces the ArrayIndexOutOfBoundsException.


//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

Not sure how to correctly enable C-highlighting, because lang-c results in the same highlighting as Java.. But //\ will comment out the next line, which is the Java-code, resulting in:

main(n){{n=puts("This program errors out in C99 :P")/0;}}

So it prins to STDOUT, and then gives a division by zero error.

\$\endgroup\$
  • \$\begingroup\$ I think It will work with both C89 and C99. Don't hold me to that. \$\endgroup\$ – SIGSTACKFAULT Mar 21 '18 at 17:01
  • \$\begingroup\$ The // was added to C with C99. \$\endgroup\$ – betseg Mar 22 '18 at 5:29
  • \$\begingroup\$ Thanks to both of you, I've changed it to C99. \$\endgroup\$ – Kevin Cruijssen Mar 22 '18 at 7:47
  • \$\begingroup\$ Why a[1] instead of a[0]? \$\endgroup\$ – xehpuk Mar 22 '18 at 18:15
  • \$\begingroup\$ @xehpuk No particular reason. It doesn't matter which digit I use and I had already filled in a 1 from the start. Could have used 0, 9, etc. as well. If I have something to edit about this post I will change it to 0 as well at the same time. \$\endgroup\$ – Kevin Cruijssen Mar 22 '18 at 19:03
10
\$\begingroup\$

Java 8 & Whitespace, 439 431 428 bytes

               
















 interface a{static void    main(String[]a){System.out.print("This program errors out in"+
" Java 8 :P");a[0]="";}}        




























Try it in Java 8 - resulting in ArrayIndexOutOfBoundsException: 0.
Try it in Whitespace - resulting in user error (Can't do Infix Plus).

Explanation:

Java 8:

interface a{static void main(String[]a){System.out.print("This program errors out in"+
" Java 8 :P");a[0]="";}}

So it prints to STDOUT, and then tries to access the first program-argument (when none given), so it produces the ArrayIndexOutOfBoundsException.


Whitespace:

[S S T  T   S T S S N
_Push_-20_P][S S T  T   S T S T S N
_Push_-42_:][S S T  T   S S S T S S N
_Push_-68_space][S S S T    N
_Push_1_e][S S T    T   N
_Push_-1_c][S S T   T   T   N
_Push_-3_a][S S S T T   S S N
_Push_12_p][S S S T T   T   T   N
_Push_15_s][S S S T N
_Push_1_e][S S S T  S S S S N
_Push_16_t][S S S T S T N
_Push_5_i][S S S T  S S N
_Push_4_h][S S T    T   T   S T N
_Push_-13_W][S T    S S T   S T S N
_Copy_10th_space][S S S T   S T S N
_Push_10_n][S S S T S T N
_Push_5_i][S T  S S T   S N
_Copy_2nd_space][S S S T    S S S S N
_Push_16_t][S S S T S S S T N
_Push_17_u][S S S T S T T   N
_Push_11_o][S T S S T   T   N
_Copy_3th_space][S S S T    T   T   T   N
_Push_15_s][S S S T T   T   S N
_Push_14_r][S S S T S T T   N
_Push_11_o][S S S T T   T   S N
_Push_14_r][S N
S _Duplicate_14_r][S S S T  N
_Push_1_e][S T  S S T   T   S N
_Copy_6th_space][S S S T    S S T   N
_Push_9_m][S S T    T   T   N
_Push_-3_a][S S S T T   T   S N
_Push_14_r][S S S T T   N
_Push_3_g][S S S T  S T T   N
_Push_11_o][S S S T T   T   S N
_Push_14_r][S S S T T   S S N
_Push_12_p][S T S S T   T   T   N
_Copy_7th_space][S S S T    T   T   T   N
_Push_15_s][S S S T S T N
_Push_5_i][S S S T  S S N
_Push_4_h][S S T    T   S S S S N
_Push_-16_T][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S S N
_Push_100][T    S S S _Add_top_two][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Whitespace is a stack-based language that ignore everything except for spaces, tabs and new-lines. Here is the same program in pseudo-code:

Push all unicode values of "P: ecapsetihW tuo srorre margorp sihT", minus 100
Start LOOP
  Push 100
  Add the top two stack values together
  Print as character
  Go to the next iteration of the LOOP

It will error as soon as it's done printing all values and the stack is empty when it tries to do the Add (TSSS) which requires two items on the stack.


Old 431 bytes answer started with SSN:

So it would error at the error_value (SSN), with an Prelude.last: empty list error. Why is this an error value? In Whitespace numbers are created like this:

  • S at the start: Enable Stack Manipulation
  • S: Push what follows as Number
  • S or T: Positive or Negative respectively
  • Some S and/or T, followed by an N: Number as binary, where T=1 and S=0.

Some examples:

  • Pushing the value 1 will be SSSTN;
  • Pushing the value -1 will be SSTTN;
  • Pushing the value 100 will be SSSTTSSTSSN.
  • Pushing the value 0 can be SSSSN, SSTSN, SSSN, SSTN, SSSSSSSSSSSSN, etc. (When you use SSSN (or SSTN), we don't have to specify the binary part, because it's implicitly 0 after we've stated it's either positive or negative.)

SSN however doesn't give any compilation errors, but does give an error as soon as it's used, which is what I've used to error out.

\$\endgroup\$
9
\$\begingroup\$

><> and Foo, 42 bytes

#o<"This code errors in "p"Foo"'><>'" :P"/

Try it in ><>!

Try it in Foo!

Foo prints everything in ", as is well documented, and tries to divide by zero at the end. It ignores the '><>'.

><> pushes the "Foo" to the stack, but immediately pops it using p. After it prints everything to the stack with #o< it exits when the the stack is empty with the only error message it knows, something smells fishy...

\$\endgroup\$
  • \$\begingroup\$ Reason of the error is important, not the error message. The esolang page on ><> has a list of error reasons, so I believe you should specify one of them, not something smells fishy.... \$\endgroup\$ – Bubbler Mar 21 '18 at 5:32
  • 2
    \$\begingroup\$ @Bubbler The error is caused by popping from an empty stack. \$\endgroup\$ – Esolanging Fruit Mar 21 '18 at 14:14
  • 3
    \$\begingroup\$ Using p to pop Foo is very clever! \$\endgroup\$ – Esolanging Fruit Mar 21 '18 at 14:14
9
\$\begingroup\$

CBM BASIC and 6502 machine code (C64), 142 144 bytes

Had to add 2 bytes after realizing a syntax error wasn't allowed ....


Hexdump of .prg file:

01 08 50 08 00 00 8F 5A 49 52 49 41 A9 17 8D 18 D0 A2 30 BD 30 08 20 D2 FF E8
E0 4B D0 F5 A2 30 BD 05 08 20 D2 FF E8 E0 44 D0 F5 A9 0D 20 D2 FF A2 1A 4C 37
A4 22 36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0 22 20 20 20
20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22 D4 48 49 53 20 50 52
4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54 20 49 4E 20 C3 C2 CD 2D C2 C1
D3 C9 C3 20 3A D0 22 2C 58 AD 50 00 00 00

The CBM BASIC view, as listed in the C64's editor:

0 remziriastepgosubinput#new0exp0 dim.clrsavekinput#stepnew0exp<white> dim.clrsavedinput#stepstep
 dim.newl7to"6502 machine code :P"
1 poke53272,23:print"This program errors out in CBM-BASIC :P",x/p

original listing

Attention: It's impossible to correctly enter this program in the BASIC editor. Don't even try to edit this program in the BASIC editor, it will crash. Still, it's a runnable BASIC program ;)


The 6502 machine code view:

         01 08                          ; load address

.C:0801  50 08       BVC $080B          ; jump to real start of mc

         ; line number (00 00), REM (8F) and "ziria"
.C:0803  00 00 8F 5A 49 52 49 41

.C:080b  A9 17       LDA #$17
.C:080d  8D 18 D0    STA $D018          ; set upper/lower font
.C:0810  A2 30       LDX #$30
.C:0812  BD 30 08    LDA $0830,X
.C:0815  20 D2 FF    JSR $FFD2          ; print "This program errors ..."
.C:0818  E8          INX
.C:0819  E0 4B       CPX #$4B
.C:081b  D0 F5       BNE $0812
.C:081d  A2 30       LDX #$30
.C:081f  BD 05 08    LDA $0805,X
.C:0822  20 D2 FF    JSR $FFD2          ; print "6502 machine code :P"
.C:0825  E8          INX
.C:0826  E0 44       CPX #$44
.C:0828  D0 F5       BNE $081F
.C:082a  A9 0D       LDA #$0D
.C:082c  20 D2 FF    JSR $FFD2          ; print a newline
.C:082f  A2 1A       LDX #$1A           ; error code for "can't continue"
.C:0831  4C 37 A4    JMP $A437          ; jump to error handling routine

.C:0834  22 ; '"'

         ; "6502 machine code :P"
.C:0835  36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0

         ; '"', some spaces, and next BASIC line
.C:0849  22 20 20 20 20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22

         ; "This program errors out in CBM-BASIC :P"
.C:0860  D4 48 49 53 20 50 52 4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54
.C:0877  20 49 4E 20 C3 C2 CD 2D C2 C1 D3 C9 C3 20 3A D0

.C:0887  22 2C 58 AD 50 00 00 00

Online demo, type run to run as BASIC, sys 2049 to run as machine code, list to show it interpreted as BASIC code.

Running as BASIC produces a division by zero error in 1, running as machine code a can't continue error

screenshot


Explanation:

The first two bytes of a .prg file are the load address in little endian, this is $0801 (decimal 2049) here, which is the start address for BASIC programs on the C64. run starts this program in the BASIC interpreter, while sys 2049 is the command to run a machine code program at address 2049.

As you can see, the first line in the BASIC view is a comment (rem) containing "garbage" and part of the required output string. This is the machine code program and some filler bytes. You see some "random" BASIC commands there because CBM-BASIC programs contain the commands "tokenized" as single byte values, and some of these values are the same as opcodes used in the machine code. The machine code reuses the string present in the second line of code for its output.

The first two bytes of a line of a basic program are a pointer to the next line, here $0850. This is carefully chosen because 50 08 is also a 6502 branch instruction jumping over the next 8 bytes when the overflow flag is not set -- this is used to jump somewhere in the middle of this "comment" line when executed as machine code. The 50 is the opcode used here, so the second line has to start at 0850 for the trick to work. That's why you see a sequence of 5 20 bytes (space characters) to fill up. The machine code actively jumps to the ROM error handling routine to give a "can't continue" error.

The BASIC code is pretty straightforward; as a second argument to "print", two uninitialized variables (having a value of 0 in CBM BASIC) are divided, triggering the "division by zero" error.

\$\endgroup\$
  • 2
    \$\begingroup\$ You, sir, are a Real Programmer. How did you come up with this? Atari programming? \$\endgroup\$ – Orion Mar 23 '18 at 4:10
  • \$\begingroup\$ @Orion thanks :) Basically, I started with the second line entered as normal BASIC, moved it out of the way using the machine code monitor built into vice (emulator), assembled the machine code directly to ram and manually repaired the line pointers of the basic program... \$\endgroup\$ – Felix Palmen Mar 23 '18 at 8:10
6
\$\begingroup\$

C and Python, 126 116 bytes

-10 bytes thanks to @Bubbler!

#1/*
-print("This program errors out in Python :P")
'''*/
main(c){c=puts("This program errors out in C :P")/0;}//'''

In Python print() is a None, so trying to get its negative doesn't make sense, so Python throws an error.

In C printf() returns an int, so dividing it by zero gives a floating point exception.

Try it in C!
Try it in Python!

\$\endgroup\$
  • 1
    \$\begingroup\$ You can use -print(...) to raise a TypeError in Python, and then you're free to make Floating Point Error (division by zero) in C. Combined with some redundant newlines, here is 116 bytes (Python, C). \$\endgroup\$ – Bubbler Mar 21 '18 at 7:01
5
\$\begingroup\$

Attache + Wolfram Language (Mathematica), 82 bytes

s:="Attache"
s=" Mathematica "
Throw[Print["This program errors out in",s,":P"]-0]

Try Attache online! Try Mathematica online!

This pivots upon the meaning of the operator = in the two languages. In Attache, it compares for equality, but in Mathematica, it performs variable assignment. := does variable assignment in both languages.

Now, in Attache, Print returns an array of strings printed, and subtraction is not possible with strings and integers (namely, 0). So, a type error is thrown. In Mathematica, Print returns Null, and Mathematica is just fine subtracting 0 from that. But, we manually throw that null with Throw, giving a nocatch error.

\$\endgroup\$
  • \$\begingroup\$ note: this doesn't work for current versions of attache due to a bug. I'll try to fix that soonish \$\endgroup\$ – Conor O'Brien Oct 12 '18 at 2:13
5
\$\begingroup\$

Python (2) and QB64, 82 bytes

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

To test the Python version, you can Try it online! To test the QB64 version, you'll need to download QB64.

What Python sees

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

The first line is just the bare expression 1 (a no-op) followed by a comment.

The second line sets s to the string "QB64", but the third line immediately changes it to "Python". The fourth line prints the message accordingly.

The fifth line is another bare expression, but it raises a NameError because of the undefined name CLS.

What QB64 sees

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

The first line, numbered 1#, defines every variable whose name starts with S (case-insensitive) as a string variable. This means we don't have to use s$, which would be a syntax error in Python.

The second line sets s to the string "QB64". ' starts a comment in QB64, so the third line doesn't do anything. The fourth line prints the message accordingly.

The fifth line tries to CLS (clear screen) with an argument of -1. But since CLS only accepts arguments of 0, 1, or 2, this produces the error Illegal function call. The error creates a dialog box asking the user if they want to continue execution or abort. Technically, this means the error isn't fatal (in this case, you can pick "continue execution" and the program simply ends without further problems); but the OP has explicitly allowed languages that can continue after an error, so QB64's behavior should be fine.

\$\endgroup\$
3
\$\begingroup\$

Perl 5 and JavaScript (Node.js), 96 bytes

eval("printf=console.log");printf("This program errors out in %s :P",("Perl","JavaScript"));$//0

This makes use of the fact that (...) is a list in Perl that printf will use the leftmost element of and the fact that it's the comma operator in JavaScript, which will return the rightmost argument.

Causes a division by zero error in Perl and a ReferenceError because $ is not defined in JavaScript.

Try the Perl online!

Try the JavaScript online!

\$\endgroup\$
3
\$\begingroup\$

Octave and MATLAB, 67 bytes

v=ver;disp(['This program errors out in ' v(1).Name ' :P']);v(--pi)

Try it online!

Notes: The code assumes MATLAB is installed with no toolboxes (or that the names of any toolbox that is installed don't start with letters A to M).

How it works:

The code gets the version data for the interpreter and toolboxes using ver. Running v(1).Name extracts the name of the first product, this will return either Octave or MATLAB assuming the note above holds true.

The program will then display the required string, complete with Octave or MATLAB as required.

Finally we do v(--pi).

In Octave, -- is the pre-decrement operator. As such it attempts to pre-decrement which fails as the variable pi doesn't exist (pi is actually function, not a variable).

This program errors out in Octave :P
error: in x-- or --x, x must be defined first

In MATLAB, the pre-decrement operator doesn't exist. As such the statement is interpreted as v(-(-pi)) which is equal to just v(pi). However pi is not an integer, so cannot be used to index into the v array, giving an error.

This program errors out in MATLAB :P
Subscript indices must either be real positive integers or logicals.
\$\endgroup\$
3
\$\begingroup\$

C++ 14 (gcc) / C++ 17 (gcc), 107 105 bytes

#include<cstdio>
int*p,c=*"??/0"/20;int
main(){*p=printf("This program errors out in C++ 1%d :P",4+c)/c;}

Try it online! (C++14)

Try it online! (C++17)


Assumes that <cstdio> declares printf in the global namespace (in addition to std) and that the basic execution character set uses ASCII values, which are both true using g++ on Linux.

The basic catch here is that C++17 eliminated trigraphs from the language.

In C++14, "??/0" contains a trigraph and is equivalent to "\0". So *"??/0" is zero, and c is set to zero. The number 4 is passed as an argument to printf, then the division by c causes undefined behavior. On Linux, this happens before *p comes into the picture, and the program gets a SIGFPE.

In C++17, "??/0" is exactly the length 4 string it appears to be. So *"??/0" is '?' or 63, and c is set to 3. The number 7 is passed as an argument to printf, and this time the division by c is valid. Since p is a namespace member, it gets zero-initialized at the start of the program and has a null pointer value, so *p is undefined behavior. On Linux, because the program attempts to modify memory at address zero, the program gets a SIGSEGV.

\$\endgroup\$
  • \$\begingroup\$ main's return type can be omitted, so -3 bytes. \$\endgroup\$ – Max Yekhlakov Oct 12 '18 at 5:36
2
\$\begingroup\$

Perl 5 and Perl 6, 55 bytes

say('This program errors out in Perl ',5-~-1,' :P').a/0

Try Perl 5 online! (Illegal division by zero)

Try Perl 6 online! (No such method)

Prefix ~ is stringification in Perl 6 and essentially a no-op in the program above. In Perl 5, it's bitwise not, converting -1 to 0.

. is method call syntax in Perl 6 and concatenation in Perl 5.

\$\endgroup\$
2
\$\begingroup\$

C (gcc)/Stax, 109 bytes

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

Try it online! (C (gcc))

Try it online! (Stax) or Run and debug it! (Stax)

Segfault in C. Invalid operation in Stax. I love how everything that is not a comment is actually used in Stax.

C

This is how C sees it. The first line is no-op. The second line prints the message with printf and then segfaults due to the =0.

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P\n",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

Stax

Stax program terminates whenever it tries to pop or peek from empty stack. This makes it a little bit tricky and we have to prepare a stack that is not empty. AA=~1; does this while remaining a valid statement in C.

AA=~1;
AA=       10=10, returns a 1
   ~      Put it on the input stack
    1     Pushes a 1 to main stack (*)
     ;    Peek from the input stack (**)

What is really useful is the ~, it prepares a non-empty input stack so that the ; can be executed without exiting the program. However, the two 1s on the main stack are also used later.

The second line begins with a tab and starts a line comment in Stax.

"...";;;/*dp`UGYC\`Q*/
"..."                     "This program errors out in"
     ;;;                  Peek the stack three times so that we have enough operands for the next two operations
        /                 Divide, this consumes one element of the main stack
         *                Multiply, this consumes another element
          d               Discard the result, now the TOS is the string
           p              Pop and print without newline
            `UGYC\`       Compressed string literal for " Stax :P"
                   Q      Print and keep the string as TOS
                    *     Duplicate string specific times
                          Since the element under the top of stack is `1` that was prepared in (**), this does nothing
                     /    Invalid operation error

The invalid operation is trying to perform / operation for a string as the TOS (2nd operand) and the number 1 from (*) as the 1st operand, which is invalid.

If the two operands are swapped, it would be a valid operation in Stax.

\$\endgroup\$
2
\$\begingroup\$

Jelly and M, 39 bytes

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ

Try it in Jelly!

Try it in M!

Both languages apply inverse İ to 0 which results in inf for Jelly and zoo for M. I don't know why zoo represents infinity in M. Ask Dennis.

The important difference is that Jelly's infinity is equal to itself while M's infinity is not. Thus the "is equal to itself" monad =` yields 1 in Jelly and 0 in M. From here:

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ
İ=`                                      0 in M, 1 in Jelly
    “¢³ƥ“Ȥ¹»                             Pair of compressed strings: [' M',' Jelly']
   ị                                     Index into this list with 0 or 1
            ;“ :P”                       Concatenate with the string ' :P'
                  “¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»       Compressed string: 'This program errors in'
                                  ;      Prepend this to ' Jelly/M :P'
                                   Ȯ     Print the string and return it
                                    Ṡ    Sign. M errors with a string as input and terminates
                                         Jelly returns a list of Nones
                                     ṛ   Right argument. This prevents the list of Nones from being printed
                                      Ɠ  Read a single line from input. Since input is not allowed, this produces an EOFError

Jelly's error is EOFError: EOF when reading a line.

M's error is TypeError: '>' not supported between instances of 'str' and 'int'.

\$\endgroup\$
  • 1
    \$\begingroup\$ How do you even begin to do this in two esolangs? \$\endgroup\$ – Magic Octopus Urn Oct 22 '18 at 14:55
2
\$\begingroup\$

Foo / CJam, 51 50 bytes

"This program errors out in ""Foo"/'C'J'a'm" :P"Li

This exits with a divide-by-zero error in Foo, and a NumberFormatException in CJam.

To CJam:

  • A string literal (between quotes) pushes itself to the stack. Items from the stack are automatically printed without a separator when the program terminates.
  • / tries to split the string This program errors out in on the substring Foo. Since the string does not contain the substring, this yields a singleton array containing the original string, which displayed in exactly the same way.
  • 'x is a character literal for x, which is printed the same way as a one-character string. This way, we can push data for CJam that is ignored by Foo (I haven't figured out how to make a loop not execute in Foo).
  • Li tries to cast the empty string to an integer, which fails. Everything from the stack is printed.

To Foo:

  • A string literal (between quotes) prints itself.
  • / tries to divide the current cell by the top stack element (which is an implicit 0). For some reason, divide-by-0 errors aren't fatal in Foo, so this just prints the message
    Only Chuck Norris can divide by zero.
    to STDERR and keeps going.
  • Unrecognized characters ('C'J'a'm and Li) are ignored.
\$\endgroup\$
  • 2
    \$\begingroup\$ Isn't the latter 50 bytes? \$\endgroup\$ – Bubbler Mar 21 '18 at 5:14
  • \$\begingroup\$ @Bubbler Forgot to edit that, sorry. \$\endgroup\$ – Esolanging Fruit Mar 21 '18 at 14:12
  • 7
    \$\begingroup\$ I think there's a bug in the Foo interpreter. It should obviously error with Only Jon Skeet can divide by zero. meta.stackexchange.com/a/9138 \$\endgroup\$ – osdavison Mar 21 '18 at 15:17
2
\$\begingroup\$

Python and Lua, 111 110 102 98 95 85 bytes

x="This program errors out in ",#[[
print(x[0]+"Python :P")
a#]]z=#print(x.."Lua :P")

Errors: Python 3:

Traceback (most recent call last):
  File ".code.tio", line 3, in <module>
    a#]]z=#print(x.."Lua :P")
NameError: name 'a' is not defined

Lua:

lua: .code.tio:3: attempt to get length of a nil value
stack traceback:
    .code.tio:3: in main chunk
    [C]: in ?

Clearly distinct.

Abuses multiple differences:

  • <var>=<a>,<b>,... creates a tuple in Python, but in Lua it creates an argument list, from which only the first member is taken.
  • # starts a comment in Python, but is the length operator in Lua. Extra props to Python for allowing tuples to end in a comma.
  • [[...]] is Lua's multiline string syntax, meaning it doesn't even see Python's print function; this is necessary due to Lua using .. for string concatenation and not +.
  • Python errors after seeing a, an undefined variable; Lua after z=#print(x.."Lua :P"). Using just #print(x.."Lua :P") for Lua doesn't work, as that raises an error before the code is even executed.

Edits:

  • No need to use "".join in Python, -1 byte
  • Make x a string in both languages and place Python in a string literal in the print function, -8 bytes
  • Using #[[]] is shorter than #"" and --[[]], -4 bytes
  • No need to use #1 as a table key, -3 bytes
  • Jo King did this, -9 bytes
  • Taking the length of the return value of print(x.."Lua :P") works, apparently; -1 byte
\$\endgroup\$
  • 1
    \$\begingroup\$ 86 bytes \$\endgroup\$ – Jo King Mar 21 '18 at 23:36
2
\$\begingroup\$

Java and C# 242 235

/**\u002f/*/using System;/**/class G{public static void/**\u002fmain/*/Main/**/(String[]a){String s="This program errors out in ";/**\u002fSystem.out.print(s+"Java :P");/*/Console.Write(s+"C# :P")/**/;s=/**\u002f(1/0)+""/*/a[-1]/**/;}}

Abusing different escape handling between java and C# (unicode escapes are parsed before code parsing in java and not in c#) as a sort of preprocessor, thats the job of the \u0027 magic, rest are some "toggle-comments"

Edit: Golfed off 8 bytes thanks to a pointer of @KevinCruijssen

Edit: Rule derp fixed

\$\endgroup\$
  • \$\begingroup\$ You can golf 6 bytes by changing both String in var (Java 10 supports this). (Or 5 by changing String s="..."; to String s="...",x; and remove String in front of x= in Java 9 or before). \$\endgroup\$ – Kevin Cruijssen Mar 23 '18 at 9:35
  • 1
    \$\begingroup\$ reusing the S-string works, too for java99 and before. @KevinCruijssen \$\endgroup\$ – masterX244 Mar 23 '18 at 17:54
2
\$\begingroup\$

AutoHotKey / C#, 155 133 128 122 bytes

Syntax highlighting explains it better than I could:

C# RuntimeBinderException: 'Cannot invoke a non-delegate type'

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

AutoHotkey Error: An exception was thrown.

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

Edits:

  1. removed a var
  2. -5 bytes thanks to milk
\$\endgroup\$
  • 2
    \$\begingroup\$ Here's a slightly shorter exception to throw in C#: i+=i[-1]. System.IndexOutOfRangeException: 'Index was outside the bounds of the array.' \$\endgroup\$ – milk Mar 22 '18 at 2:00
  • 2
    \$\begingroup\$ Slightly shorter still to use dynamic instead of var and throw Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: 'Cannot invoke a non-delegate type' with i(). \$\endgroup\$ – milk Mar 22 '18 at 2:08
2
\$\begingroup\$

PHP 7+ / JavaScript, 90 89 bytes

This uses 2 languages with very similar syntax, allowing to write this code on both languages.

The language separation is done by a property not present in JavaScript: PHP considers [] (empty array) to be a falsy value while it is truthy in JavaScript (because it is an object and objects are always truthy, even new Boolean(false)).

$X='This program errors out in %s :P';([]?console.log($X,'JavaScript'):printf($X,PHP))();


Execution:

Will focus on the following piece of code: ([]?console.log($X,'JavaScript'):printf($X,PHP))();.

The string attribution works the same in both languages.

This code uses the "ternary operator" (Javascript, PHP), which works mostly the same way in both languages.

Javascript

Javascript will run the console.log($X,'JavaScript') piece, which returns undefined.

Later on, when you try to execute (...)(), you get an Uncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function (in Google Chrome).

PHP

PHP will execute the printf($X,PHP) piece.

In PHP, the printf function returns the length of the output.

PHP has an interesting functionality: it can execute functions who's name is stored in a variable (or, since PHP7, as the result of an expression), which prevents a syntax error.

PHP then will try to run the function who's name is the result of the expression []? ... :printf($X,PHP) (which is the number 33).
But that interesting functionality has a caveat: only accepts strings (duh!).

This causes a Fatal error: Function name must be a string, because 33 is an int.


Thanks to Shieru Asakoto for saving me 1 byte!

\$\endgroup\$
  • \$\begingroup\$ [] is shorter than '0' and also evaluated differently in JS and PHP, so maybe a -1 byte here? \$\endgroup\$ – Shieru Asakoto Oct 12 '18 at 9:36
  • \$\begingroup\$ I have plenty of questions with that issue, where [] needs to be used instead of '0', '\0', '\0'=="0", and used that [] before as well. But thank you for spotting this question. \$\endgroup\$ – Ismael Miguel Oct 12 '18 at 10:19
1
\$\begingroup\$

Perl 5 and C, 95 bytes

//;$_='
main(){puts(puts("This program errors out in C :P"));}//';/T.*n /;print$&,"perl :P";die

//; is basically a NOP in perl, and is a comment in C.

So the C program is effectively:

main(){puts(puts("This program errors out in C :P"));}

Which prints the required string, then tries to run puts(32). This is technically undefined behavior in C, but it causes a segmentation fault on TIO and every system I have access to.

The perl program treats the whole C program as a string, uses the regex /T.*n / to match This program errors out in and then prints that and perl :P. die causes the program to crash with the error Died at script_name line 2.

If you don't like that as an error, 1/0 is the same length and crashes with an Illegal division by zero error. I just like die more ;)

Try it online! (C)

Try it online! (Perl)

\$\endgroup\$
1
\$\begingroup\$

VBScript, JScript, 72 bytes

x="VB"
'';x='J'
WScript.echo("This program errors out in "+x+"Script")
y

VBScript will print "Microsoft VBScript runtime error: Type mismatch: 'y'"
JScript will print "Microsoft JScript runtime error: 'y' is undefined"

\$\endgroup\$
1
\$\begingroup\$

JavaScript & Python 3, 105 91 bytes

Errors by NameError: name 'console' is not defined in Python 3

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Try it online!

... and by TypeError: console.log(...) is not a function in JavaScript.

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Java (JDK)/JavaScript (Node.js), 154 bytes

class P{P(){var s="This program errors out in ";try{System.out.printf("%sJava :P",s);}finally{if(1!='1'){var a=0/0;}throw new Error(s+"JavaScript :P");}}}

Try it online! (Java)

Try it online! (JavaScript)

Output in Java:

This program errors out in Java :P
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at P.(Main.java:1)

Output in JavaScript (to stderr):

Error: This program errors out in JavaScript :P
    at P (/home/runner/.code.tio:1:185)

This takes advantage of JavaScript's weak typing (1=='1') to detect the language, and the same keywords in Java and JavaScript (var,class), and the similar error constructors (new Error()) to make the polyglot.

\$\endgroup\$
0
\$\begingroup\$

C(gcc) on Linux/C(gcc) on Mac (160)

#include <sys/utsname.h>
main(){struct utsname n;float g;uname(&n);printf("This program errors out in C(gcc) on %s :P\n",n.sysname);g=1/(int)gamma(1);abort();}

Untested on Mac; basically, John Cook pointed out (in his blog) that POSIX doesn't define gamma; Linux uses the log of the gamma function (log(gamma(1)) will return 0 which will trigger a floating point exception); OSX uses the "true" gamma function, (which is officially called tgamma per POSIX); this returns 1 which will then hit the abort statement; I tried to get it to throw a different floating point error (e.g. sqrt(-1) but I'm forgetting how to make that throw an error vs just return zero)

\$\endgroup\$
0
\$\begingroup\$

Perl, Bash (78 bytes)

printf "This program errors out in ";eval 'echo Bash :P'||print"Perl :P
";
a()

Output in Perl:

This program errors out in Perl :P
Undefined subroutine &main::a called at /tmp/perlbash line 3.

Output in Bash:

This program errors out in Bash :P
/tmp/perlbash: line 4: syntax error: unexpected end of file

(Note that Bash is indeed displaying the line 4 error, despite the fact that line 3 does not end with a line feed...)

\$\endgroup\$
0
\$\begingroup\$

C and ECPP, 112 bytes

#ifdef ECPP
#replace "C" "ECPP"
#endif
main(){puts("This program errors out in " "C" " :P");raise(strlen("C"));}
\$\endgroup\$
0
\$\begingroup\$

C (gcc) and Haskell, 135 bytes

char/*x=0-- */*
s="This program errors out in ";
int main(){--s;*s=printf("%sC :P",s+1);}//-}=0;main=mapM print[s++"Haskell :P",tail""]

Try it online (С)! Try it online (Haskell)!

The result is achieved by interweaving the comments, the C version being essentially this:

char * s = "This program errors out in ";
int main ()
{
   --s;
   *s = printf ("%sC :P", s + 1);
}

(Failure is achieved by writing before the beginning of the string).

Haskell version, on the other hand, reduces to the following:

char /* x = 0 -- a useless operator (/*) taking two arguments
s = "This program errors out in ";
int main () = 0 -- a useless function int taking two arguments
main = mapM print [s ++ "Haskell :P", tail ""]

(Failure is achieved by taking tail of an empty list)

\$\endgroup\$
0
\$\begingroup\$

Ruby / Erlang, 150 115 bytes

%w();puts r=<<X[/T.*n /]+"Ruby :P";r*=-1
main([])->io:fwrite("This program errors out in Erlang :P
"),X=1/0,Y=
X
.%

Try it online:

Ruby

Erlang (escrpit)

What's happening here?

Erlang was quite easy, it's just printing out a string then performing a division by zero.

The % sign starts a single line comment in Erlang, so I could use that to mark Ruby code, by creating some nop and then appending valid code.

Ruby has to skip all the Erlang code, so I used the here-document syntax to read it all into a string. The delimiter is a valid variable name in Erlang, so that's no problem. Then I multiply the string by -1, which is an invalid argument and outputs the error message.

The last line marks the end of the Erlang function, and does not look too bad to the Ruby interpreter, which gets an error before having to interpret that anyway.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.