Hello world/Standard error

Hello world/Standard error
You are encouraged to solve this task according to the task description, using any language you may know.

Hello world/Standard error is part of Short Circuit's Console Program Basics selection.

A common practice in computing is to send error messages to a different output stream than normal text console messages.

The normal messages print to what is called "standard output" or "standard out".

The error messages print to "standard error".

This separation can be used to redirect error messages to a different place than normal messages.

Task

Show how to print a message to standard error by printing     Goodbye, World!     on that stream.

11l

Translation of: Python

<lang 11l>:stderr.write("Goodbye, World!\n")</lang>

4DOS Batch

<lang 4dos>echoerr Goodbye, World!</lang>

AArch64 Assembly

<lang ARM_Assembly>.equ STDERR, 2 .equ SVC_WRITE, 64 .equ SVC_EXIT, 93

.text .global _start

_start: stp x29, x30, [sp, -16]! mov x0, #STDERR ldr x1, =msg mov x2, 15 mov x8, #SVC_WRITE mov x29, sp svc #0 // write(stderr, msg, 15); ldp x29, x30, [sp], 16 mov x0, #0 mov x8, #SVC_EXIT svc #0 // exit(0);

msg: .ascii "Goodbye World!\n"</lang>

Ada

<lang ada>with Ada.Text_IO; use Ada.Text_IO;

procedure Goodbye_World is begin

  Put_Line (Standard_Error, "Goodbye, World!");

end Goodbye_World;</lang>

Agena

<lang agena>io.write( io.stderr, "Goodbye, World!\n" )</lang>

Aime

<lang aime>v_text("Goodbye, World!\n");</lang>

ALGOL 68

The procedures print and printf output to stand out, whereas put and putf can output to any open file, including stand error.

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d - note that printf and putf were not ported into ELLA's libraries.

<lang algol68>main:(

 put(stand error, ("Goodbye, World!", new line))

)</lang>

Output:

Goodbye, World!

Argile

<lang Argile>use std eprint "Goodbye, World!"</lang> or <lang Argile>use std eprintf "Goodbye, World!\n"</lang> or <lang Argile>use std fprintf stderr "Goodbye, World!\n"</lang>

ARM Assembly

Works with: as version Raspberry Pi

<lang ARM Assembly> /* ARM assembly Raspberry PI */ /* program hellowordLP.s */ .data szMessage: .asciz "Goodbye world. \n " @ error message .equ LGMESSAGE, . - szMessage @ compute length of message

.text .global main main:

   mov r0, #2                  @ output error linux
   ldr r1, iAdrMessage         @ adresse of message
   mov r2, #LGMESSAGE          @ sizeof(message) 
   mov r7, #4                  @ select system call 'write' 
   swi #0                      @ perform the system call 

   mov r0, #0                  @ return code
   mov r7, #1                  @ request to exit program
   swi #0                       @ perform the system call

iAdrMessage: .int szMessage

</lang>

Arturo

<lang arturo>panic "Goodbye, World!"</lang>

ATS

<lang ATS>implement main0 () = fprint (stderr_ref, "Goodbye, World!\n")</lang>

AutoHotkey

requires AutoHotkey_N implementation. <lang autohotkey>; c:\> autohotkey.exe stderr.ahk 2> error.txt FileAppend, Goodbye`, World!, stderr  ; requires AutoHotkey_N</lang>

Or with the current AutoHotkey_L:

Works with: AutoHotkey_L

(documentation on this behavior: http://www.autohotkey.net/~Lexikos/AutoHotkey_L/docs/commands/FileAppend.htm) <lang AutoHotkey>FileAppend, Goodbye`, World!, *</lang>

AutoIt

<lang AutoIt>ConsoleWriteError("Goodbye, World!" & @CRLF)</lang>

AWK

To print a message to standard error, pipe it through a shell command:

<lang awk>BEGIN {

 print "Goodbye, World!"| "cat 1>&2"

}</lang>

Or write to /dev/stderr:

Works with: gawk

Works with: mawk

Works with: nawk

<lang awk>BEGIN {

 print "Goodbye, World!" > "/dev/stderr"

}</lang>

With gawk, mawk and nawk: a special feature associates "/dev/stderr" with standard error. The manuals of gawk and mawk describe this feature; nawk also has this feature.

Other implementations might try to open /dev/stderr as a file. Some Unix clones, like BSD, have a /dev/stderr device node that duplicates standard error, so this code would still work. Some systems have no such device node, so this code would fail. We recommend "cat 1>&2", which is more portable, and works with any Unix clone.

BASIC

BaCon

<lang freebasic>EPRINT "Goodbye, World!"</lang>

ZX Spectrum Basic

On the ZX Spectrum, standard error is on stream 1:

<lang zxbasic> 10 PRINT #1;"Goodbye, World!" 20 PAUSE 50: REM allow time for the user to see the error message </lang>

Batch File

<lang dos>1>&2 echo Goodbye, World!</lang> The redirection operator 1>&2 causes all output on stream 1 (standard out) to be redirected to stream 2 (standard error). The redirection can be moved to the end of the line, too.

BBC BASIC

Works with: BBC BASIC for Windows

The program must be compiled as a console application for this to work. <lang bbcbasic> STD_ERROR_HANDLE = -12

     SYS "GetStdHandle", STD_ERROR_HANDLE TO @hfile%(1)
     PRINT #13, "Goodbye, World!"
     QUIT</lang>

C

Unlike puts(), fputs() does not append a terminal newline. <lang c>#include <stdio.h>

int main() { fprintf(stderr, "Goodbye, "); fputs("World!\n", stderr);

return 0; }</lang>

C#

<lang csharp>static class StdErr {

   static void Main(string[] args)
   {
       Console.Error.WriteLine("Goodbye, World!");
   }

}</lang>

C++

<lang cpp>#include <iostream>

int main() {

 std::cerr << "Goodbye, World!\n";

}</lang>

Clojure

<lang lisp>(binding [*out* *err*]

 (println "Goodbye, world!"))</lang>

CMake

Most messages go to standard error.

<lang cmake>message("Goodbye, World!")</lang>

The message cannot be a keyword; message("STATUS") never prints "STATUS", but message("" "STATUS") does work.

COBOL

Using fixed format.

Works with: OpenCOBOL

<lang cobol> program-id. ehello. procedure division. display "Goodbye, world!" upon syserr. stop run.</lang>

CoffeeScript

Translation of: JavaScript

Works with: Node.js

<lang coffeescript>console.warn "Goodbye, World!"</lang>

Common Lisp

<lang lisp>(format *error-output* "Goodbye, world!~%")</lang>

D

<lang d>import std.stdio;

void main () {

   stderr.writeln("Goodbye, World!");

}</lang>

Alternative Version

Library: tango

<lang d>import tango.io.Stdout;

void main () {

   Stderr("Goodbye, World!").newline;

}</lang>

Déjà Vu

<lang dejavu>!write-fragment!stderr !encode!utf-8 "Goodbye, World!\n"</lang>

Delphi

<lang Delphi>program Project1;

{$APPTYPE CONSOLE}

begin

 WriteLn(ErrOutput, 'Goodbye, World!');

end.</lang>

Dylan.NET

Works with: Mono version 2.6.7

Works with: Mono version 2.10.x

Works with: Mono version 3.x.y

Works with: .NET version 3.5

Works with: .NET version 4.0

Works with: .NET version 4.5

One Line version: <lang Dylan.NET>Console::get_Error()::WriteLine("Goodbye World!")</lang> Goodbye World Program: <lang Dylan.NET> //compile using the new dylan.NET v, 11.5.1.2 or later //use mono to run the compiler

1. refstdasm mscorlib.dll

import System

assembly stderrex exe ver 1.1.0.0

class public Program

  method public static void main()
     Console::get_Error()::WriteLine("Goodbye World!")
  end method

end class </lang>

E

<lang e>stderr.println("Goodbye, World!")</lang>

Elixir

<lang elixir>IO.puts :stderr, "Goodbye, World!"</lang>

Emacs Lisp

<lang Emacs Lisp> (error "Goodbye, World!")

</lang>

Output:

Goodbye, World!                                                                              

Erlang

<lang erlang>io:put_chars(standard_error, "Goodbye, World!\n").</lang>

Euphoria

<lang Euphoria>puts(2,"Goodbye, world!\n") -- 2 means output to 'standard error'</lang>

F#

<lang fsharp>eprintfn "%s" "Goodbye, World!"</lang> or you can use the .Net classes <lang fsharp>System.Console.Error.WriteLine("Goodbye, World!");</lang>

Factor

Start Factor in a terminal for this: <lang factor>error-stream get [ "Goodbye, World! bbl, crashing" print flush ] with-output-stream*</lang>

Fantom

<lang fantom> class Main {

 public static Void main ()
 {
   Env.cur.err.printLine ("Goodbye, World!")
 }

} </lang>

Forth

Works with: GNU Forth

<lang forth>outfile-id

 stderr to outfile-id
 ." Goodbye, World!" cr

to outfile-id</lang>

Fortran

Normally standard error is associated with the unit 0 but this could be different for different vendors. Therefore since Fortran 2003 there's an intrinsic module which defines the parameter ERROR_UNIT.

<lang fortran>program StdErr

 ! Fortran 2003
 use iso_fortran_env

 ! in case there's no module iso_fortran_env ...
 !integer, parameter :: ERROR_UNIT = 0
 
 write (ERROR_UNIT, *) "Goodbye, World!"

end program StdErr</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Open Err As #1 Print #1, "Goodbye World!" Close #1 Sleep</lang>

Frink

<lang frink> staticJava["java.lang.System","err"].println["Goodbye, World!"] </lang>

Genie

<lang genie>[indent=4] /*

 Hello, to Standard error, in Genie
 valac helloStderr.gs

• /

init

   stderr.printf("%s\n", "Goodbye, World!")</lang>

Output:

prompt$ ./helloStderr | wc
Goodbye, World!
      0       0       0

Go

Built in println now goes to stderr. <lang go>package main func main() { println("Goodbye, World!") }</lang> but the builtin print() and println() functions are not guaranteed to stay in the language. So you should probably use <lang go>package main import ("fmt"; "os") func main() { fmt.Fprintln(os.Stderr, "Goodbye, World!") }</lang>

Groovy

<lang groovy>System.err.println("Goodbye, World!")</lang>

Haskell

<lang haskell>import System.IO main = hPutStrLn stderr "Goodbye, World!"</lang>

Huginn

<lang huginn>#! /bin/sh exec huginn --no-argv -E "${0}" "${@}"

1. ! huginn

import OperatingSystem as os;

main() { os.stderr().write( "Goodbye, World!\n" ); return ( 0 ); }</lang>

Icon and Unicon

<lang icon>procedure main()

 write(&errout, "Goodbye World" )

end</lang>

J

<lang j>stderr =: 1!:2&4 stderr 'Goodbye, World!'</lang>

Java

<lang java>public class Err{

  public static void main(String[] args){
     System.err.println("Goodbye, World!");
  }

}</lang>

JavaScript

Works with: JScript

and only with cscript.exe

<lang javascript>WScript.StdErr.WriteLine("Goodbye, World!");</lang>

Works with: Node.js

<lang javascript>console.warn("Goodbye, World!")</lang>

Works with: Firefox

<lang javascript>console.error("Goodbye, World!")//only works if console object exists</lang> OR <lang javascript>throw new Error("Goodbye, World!")//Should work in any browser</lang>

jq

<lang jq>jq -n —-arg s 'Goodbye, World!' '$s | stderr | empty'</lang>

`stderr` copies its input to STDERR before passing it along the pipeline, and hence the occurrence of `empty` above.

Julia

<lang julia>println(STDERR, "Goodbye, World!")</lang>

Kotlin

<lang scala>fun main(args: Array<String>) {

   System.err.println("Goodbye, World!")

}</lang>

langur

<lang langur>writelnErr "goodbye, people"</lang>

Lasso

<lang Lasso>define stderr(s::string) => {

   file_stderr->writeBytes(#s->asBytes)

}

stderr('Goodbye, World!')</lang>

Lingo

• Windows:

Library: CommandLine Xtra

<lang lingo>-- print to standard error stdErr("Goodbye, World!", TRUE)

-- print to the Windows debug console (shown in realtime e.g. in Systernal's DebugView) dbgPrint("Goodbye, World!")</lang>

• Mac OS X:

Library: Shell Xtra

<lang lingo>sx = xtra("Shell").new()

-- print to standard error sx.shell_cmd("echo Goodbye, World!>&2")

-- print to system.log (shown in realtime e.g. in Konsole.app) sx.shell_cmd("logger Goodbye, World!")</lang>

LLVM

<lang llvm>; This is not strictly LLVM, as it uses the C library function "printf".

LLVM does not provide a way to print values, so the alternative would be

to just load the string into memory, and that would be boring.

Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps

%struct._iobuf = type { i8* }

$"message" = comdat any @"message" = linkonce_odr unnamed_addr constant [17 x i8] c"Goodbye, world!\0A\00", comdat, align 1

-- For discovering stderr (io pipe 2)

declare %struct._iobuf* @__acrt_iob_func(i32)

--- The declaration for the external C fprintf function.

declare i32 @fprintf(%struct._iobuf*, i8*, ...)

define i32 @main() {

-- load stderr

 %1 = call %struct._iobuf* @__acrt_iob_func(i32 2)

-- print the message to stderr with fprintf

 %2 = call i32 (%struct._iobuf*, i8*, ...) @fprintf(%struct._iobuf* %1, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @"message", i32 0, i32 0))

-- exit

 ret i32 0

}</lang>

Output:

Goodbye, world!

Logtalk

The stream alias "user_error" can be used to print to the "standard error" stream. <lang logtalk>

- object(error_message).

   % the initialization/1 directive argument is automatically executed
   % when the object is compiled and loaded into memory:
   :- initialization(write(user_error, 'Goodbye, World!\n')).

- end_object.

</lang>

Lua

<lang lua>io.stderr:write("Goodbye, World!\n")</lang>

m4

<lang m4>errprint(`Goodbye, World! ')dnl</lang>

MANOOL

<lang MANOOL>{{extern "manool.org.18/std/0.3/all"} in Err.WriteLine["Goodbye, World!"]}</lang>

Maple

<lang Maple> error "Goodbye World" </lang>

Mathematica / Wolfram Language

<lang Mathematica>Write[Streams["stderr"], "Goodbye, World!"]</lang>

MATLAB / Octave

This prints to standard error, and continues execution <lang MATLAB>fprintf(2,'Goodbye, World!')</lang> This will not stop further execution, if called from within a script or function. <lang MATLAB>error 'Goodbye, World!'</lang>

Mercury

<lang>

- module hello_error.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

- implementation.

main(!IO) :-

   io.stderr_stream(Stderr, !IO),
   io.write_string(Stderr, "Goodbye, World!\n", !IO).

</lang>

Metafont

Metafont has no a real way to send a text to the standard output/error nor to a file. Anyway it exists the errmessage command which will output an error message and prompt the user for action (suspending the interpretation of the source).

<lang metafont>errmessage "Error"; message "...going on..."; % if the user decides to go on and not to stop

                         % the program because of the error.</lang>

ML/I

<lang ML/I>MCSET S4=1 MCNOTE Goodbye, World!</lang>

Modula-2

<lang modula2>MODULE HelloErr; IMPORT StdError;

BEGIN

 StdError.WriteString('Goodbye, World!');
 StdError.WriteLn

END HelloErr.</lang>

Modula-3

<lang modula3>MODULE Stderr EXPORTS Main;

IMPORT Wr, Stdio;

BEGIN

 Wr.PutText(Stdio.stderr, "Goodbye, World!\n");

END Stderr.</lang>

N/t/roff

The request .tm prints whatever after it, until and including the newline character, to the standard error. The string parsed to it need not be quoted and will never appear on standard output.

<lang N/t/roff> .tm Goodbye, World! </lang>

Neko

<lang ActionScript>/**

 Hello world, to standard error, in Neko
 Tectonics:
   nekoc hello-stderr.neko
   neko hello-stderr

• /

/* Assume stderr is already open, just need write */ var file_write = $loader.loadprim("std@file_write", 4);

/* Load (and execute) the file_stderr primitive */ var stderr = $loader.loadprim("std@file_stderr", 0)();

file_write(stderr, "Goodbye, World!\n", 0, 16);</lang>

Output:

prompt$ nekoc hello-stderr.neko
prompt$ neko hello-stderr
Goodbye, World!
prompt$ neko hello-stderr 2>/dev/null
prompt$

Nemerle

<lang Nemerle>System.Console.Error.WriteLine("Goodbye, World!");</lang>

NetRexx

<lang NetRexx>/* NetRexx */

options replace format comments java crossref savelog symbols binary

System.err.println("Goodbye, World!") </lang>

Nim

<lang nim>stderr.writeln "Hello World"</lang>

Oberon-2

Oxford Oberon-2 <lang oberon2> MODULE HelloErr; IMPORT Err; BEGIN Err.String("Goodbye, World!");Err.Ln END HelloErr. </lang>

Output:

Goodbye, World!

Objective-C

Works with: GNUstep

Works with: Cocoa

In Objective-C one can use the standard C library and the stderr as in the C language; nonetheless a common way to output to stderr for logging purpose and/or error notification is the NSLog function, that works almost like fprintf(stderr, "..."), save for the fact that the format string is an NSString object, and it also prepends a timestamp.

<lang objc>#import <Foundation/Foundation.h>

int main() {

  fprintf(stderr, "Goodbye, World!\n");
  fputs("Goodbye, World!\n", stderr);
  NSLog(@"Goodbye, World!");
  return 0;

}</lang>

OCaml

<lang ocaml>prerr_endline "Goodbye, World!"; (* this is how you print a string with newline to stderr *) Printf.eprintf "Goodbye, World!\n"; (* this is how you would use printf with stderr *)</lang>

we can also use the out_channel stderr:

<lang ocaml>output_string stderr "Goodbye, World!\n"; Printf.fprintf stderr "Goodbye, World!\n";</lang>

finally the Unix module also provides unbuffered write functions:

<lang ocaml>let msg = "Goodbye, World!\n" in ignore(Unix.write Unix.stderr msg 0 (String.length msg)) ;;</lang>

Octave

<lang octave>fprintf(stderr, "Goodbye, World!\n");</lang>

Oforth

<lang Oforth>System.Err "Goodbye, World!" << cr</lang>

Ol

<lang scheme> (print-to stderr "Goodbye, World!") </lang>

ooRexx

ooRexx provides a .error object that writes output to the standard error stream. <lang ooRexx>.error~lineout("Goodbye, World!")</lang> The .error object is a proxy that delegates to a backing stream, so this might be redirected. By default, this delegates to the .stderr object, which can also be used directly. <lang ooRexx>.stderr~lineout("Goodbye, World!")</lang> or in 'Classic REXX style' <lang ooRexx>/* REXX ---------------------------------------------------------------

• 07.07.2014 Walter Pachl
• 12.07.2014 WP see Discussion where redirection from within the program is shown
• --------------------------------------------------------------------*/

Say 'rexx serr 2>err.txt directs the stderr output to the file err.txt' Call lineout 'stderr','Good bye, world!' Call lineout ,'Hello, world!' Say 'and this is the error output:' 'type err.txt' </lang>

Oz

<lang oz>functor import Application System define

  {System.showError "Goodbye, World!"}
  {Application.exit 0}

end</lang>

PARI/GP

<lang parigp>error("Goodbye, World!")</lang>

Pascal

Works with: Free Pascal

<lang pascal>program byeworld;

begin

 writeln(StdErr, 'Goodbye, World!');

end.</lang>

Perl

<lang perl>warn "Goodbye, World!\n";</lang>

Or:

<lang perl>print STDERR "Goodbye, World!\n";</lang>

Perl 6

<lang perl6>note "Goodbye, World!";</lang>

Phix

<lang Phix>puts(2,"Goodbye, World!\n")</lang>

PHP

<lang php>fprintf(STDERR, "Goodbye, World!\n");</lang> or <lang php>file_put_contents("php://stderr","Hello World!\n");</lang>

PicoLisp

<lang PicoLisp>(out 2 (prinl "Goodbye, World!"))</lang>

PL/I

<lang PL/I>display ('Goodbye, World');</lang>

PostScript

<lang postscript>(%stderr) (w) file dup (Goodbye, World! ) writestring closefile</lang>

PowerBASIC

Works with: PowerBASIC Console Compiler

<lang powerbasic>STDERR "Goodbye, World!"</lang>

PowerShell

Since PowerShell has a slightly different system of pipes and streams (to facilitate easy usage from a host application) the standard Write-Error cmdlet is mainly for sending annotated error messages to the host: <lang powershell>Write-Error "Goodbye, World!"</lang> Note that this outputs more than just the message, because behind the scenes it is an uncaught exception:

Write-Error "Goodbye, World!" : Goodbye, World!
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException

To accurately reproduce the behavior of other languages one has to resort to .NET in this case: <lang powershell>[Console]::Error.WriteLine("Goodbye, World!")</lang>

PureBasic

ConsoleError() writes the message string (plus a newline) to the standard error output of current program.

Standard error output can be used in conjunction with ReadProgramError() to reads a line from an other programs error output (stderr).

<lang PureBasic>ConsoleError("Goodbye, World!")</lang>

Python

Works with: Python version 2.x

<lang python>import sys

print >> sys.stderr, "Goodbye, World!"</lang>

Works with: Python version 3.x

<lang python>import sys

print("Goodbye, World!", file=sys.stderr)</lang>

Works with either: <lang python>import sys

sys.stderr.write("Goodbye, World!\n")</lang>

R

<lang R>cat("Goodbye, World!", file=stderr())</lang>

Ra

<lang Ra> class HelloWorld **Prints "Goodbye, World!" to standard error**

on start

print to Console.error made !, "Goodbye, World!" </lang>

Racket

<lang Racket> (eprintf "Goodbye, World!\n") </lang>

Retro

<lang Retro>'Goodbye,_World! '/dev/stderr file:spew</lang>

REXX

version 1

This version will work with those operating systems (hosts) that support stream output and a STDERR output
stream (by name).
If the   stderr   name is supported and enabled, the output is written to the terminal.
If not supported or disabled, the output is written to a (disk) file named   STDERR. <lang rexx>call lineout 'STDERR', "Goodbye, World!"</lang>

version 2

Same as above, but uses a different style and also invokes   charout   instead of   lineout. <lang rexx>msgText = 'Goodbye, World!' call charout 'STDERR', msgText</lang>

version 3

this works on Windows 7 and ooRexx and REGINA <lang rexx>/* REXX ---------------------------------------------------------------

• 07.07.2014 Walter Pachl
• enter the appropriate command shown in a command prompt.
• "rexx serr.rex 2>err.txt"
• or "regina serr.rex 2>err.txt"
• 2>file will redirect the stderr stream to the specified file.
• I don't know any other way to catch this stream
• --------------------------------------------------------------------*/

Parse Version v Say v Call lineout 'stderr','Good bye, world!' Call lineout ,'Hello, world!' Say 'and this is the error output:' 'type err.txt'</lang>

Ring

<lang ring>fputs(stderr,"Goodbye, World!")</lang>

Ruby

<lang ruby>$stderr.puts "Goodbye, World!"</lang> The following also works, unless you have disabled warnings (ruby command line option "-W0" or set $VERBOSE=nil) <lang ruby>warn "Goodbye, World!"</lang>

Run BASIC

<lang runbasic>html "<script> window.open(,'error_msg',); document.write('Goodbye, World!'); </script>""</lang> Run Basic runs in a browser. This opens a new browser window, or a tab in the case of Chrome and some others.

Rust

<lang rust>fn main() {

   eprintln!("Hello, {}!", "world");

}</lang> or <lang rust>fn main() {

   use ::std::io::Write;
   let (stderr, errmsg) = (&mut ::std::io::stderr(), "Error writing to stderr");
   writeln!(stderr, "Bye, world!").expect(errmsg);
   
   let (goodbye, world) = ("Goodbye", "world");
   writeln!(stderr, "{}, {}!", goodbye, world).expect(errmsg);

}</lang> or <lang rust>fn main() {

   use std::io::{self, Write};

   io::stderr().write(b"Goodbye, world!").expect("Could not write to stderr");
   // With some finagling, you can do a formatted string here as well
   let goodbye = "Goodbye";
   let world = "world";
   io::stderr().write(&*format!("{}, {}!", goodbye, world).as_bytes()).expect("Could not write to stderr");
   // Clearly, if you want formatted strings there's no reason not to just use writeln!

}</lang>

S-lang

<lang S-lang>() = fputs("Goodbye, World!\n", stderr);</lang>

Salmon

<lang Salmon> standard_error.print("Goodbye, World!\n"); </lang>

or

<lang Salmon> include "short.salm"; stderr.print("Goodbye, World!\n"); </lang>

or

<lang Salmon> include "shorter.salm"; err.print("Goodbye, World!\n"); </lang> or

<lang Salmon> include "shorter.salm"; se.print("Goodbye, World!\n"); </lang>

Sather

<lang sather>class MAIN is

 main is
   #ERR + "Hello World!\n";
 end;

end;</lang>

Scala

Library: Console

Ad hoc REPL solution

Ad hoc solution as REPL script: <lang Scala>Console.err.println("Goodbye, World!")</lang>

Via Java runtime

This is a call to the Java run-time library. Not recommendated. <lang Scala>System.err.println("Goodbye, World!")</lang>

Via Scala Console API

This is a call to the Scala API. Recommendated. <lang Scala>Console.err.println("Goodbye, World!")</lang>

Short term deviation to err

<lang Scala>Console.withOut(Console.err) { println("This goes to default _err_") }</lang>

Long term deviation to err

<lang Scala> println ("Out not deviated")

 Console.setOut(Console.err)
 println ("Out deviated")
 Console.setOut(Console.out) // Reset to normal</lang>

Scilab

<lang scilab>error("Goodbye, World!")</lang>

Scheme

<lang scheme>(error "Goodbye, World!")</lang>

sed

Requires /dev/stderr

<lang sed>#n 1 { s/.*/Goodbye, World!/w /dev/stderr }</lang>

This program requires at least 1 line of input. It changes the first line to "Goodbye, World!" and then prints the first line to standard error. It reads and ignores the remaining lines.

Test output:

<lang bash>$ echo a | sed -f error.sed >/dev/null Goodbye, World!</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 begin
   writeln(STD_ERR, "Goodbye, World!");
 end func;</lang>

Sidef

<lang ruby>STDERR.println("Goodbye, World!");</lang>

Slate

<lang slate>inform: 'Goodbye, World!' &target: DebugConsole.</lang>

Smalltalk

The details on to which name stderr is bound may vary between Smalltalk dialects. If different, a "Smalltalk at:#Stderr put:<name your stream here>" should provide compatibility.

<lang smalltalk>Stderr nextPutAll: 'Goodbye, World!'</lang>

However, all smalltalks provide a console named "Transcript", where diagnostics is usually sent to. Thus:

<lang smalltalk>Transcript show: 'Goodbye, World!'</lang>

will work on all, and is the preferred way to do this. And yes, when operating UI-less, the global "Transcript" is usually bound to the stderr stream.

SNOBOL4

<lang snobol4> terminal = "Error"

       output = "Normal text"

end</lang>

Standard ML

<lang sml>TextIO.output (TextIO.stdErr, "Goodbye, World!\n")</lang>

Swift

<lang Swift>import Foundation

let out = NSOutputStream(toFileAtPath: "/dev/stderr", append: true) let err = "Goodbye, World!".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false) out?.open() let success = out?.write(UnsafePointer<UInt8>(err!.bytes), maxLength: err!.length) out?.close()

if let bytes = success {

   println("\nWrote \(bytes) bytes")

}</lang>

Output:

Goodbye, World!
Wrote 15 bytes

Tcl

<lang tcl>puts stderr "Goodbye, World!"</lang>

Transact-SQL

<lang Transact-SQL> RAISERROR 'Goodbye, World!', 16, 1 </lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT PRINT/ERROR "hello world" text="goodbye world" PRINT/ERROR text </lang>

Output:

@@@@@@@@  hello world                                                  @@@@@@@@
@@@@@@@@  goodbye world                                                @@@@@@@@

UNIX Shell

Works with: Bourne Shell

<lang bash>echo "Goodbye, World!" >&2</lang>

C Shell

<lang csh>echo "Goodbye, World!" >/dev/stderr</lang>

This requires /dev/stderr, a device node from BSD and some other Unix clones. This command works with both Bourne Shell and C Shell.

Ursa

<lang ursa>out "goodbye, world!" endl console.err</lang>

VBA

<lang VB> Sub StandardError()

   Debug.Print "Goodbye World!"

End Sub </lang>

VBScript

Must work in cscript.exe <lang vb>WScript.StdErr.WriteLine "Goodbye, World!"</lang>

Verbexx

<lang verbexx>@STDERR "Goodbye, World!\n";</lang>

Visual Basic .NET

<lang vbnet>Module Module1

   Sub Main()
       Console.Error.WriteLine("Goodbye, World!")
   End Sub

End Module</lang>

WDTE

<lang WDTE>io.writeln io.stderr 'Goodbye, World!';</lang>

X86 Assembly

Works with: nasm version 2.05.01

This is known to work on Linux, it may or may not work on other Unix-like systems

Note that it is only 2 characters different from the Assembly example on User Output - text

Prints "Goodbye, World!" to stderr (and there is probably an even simpler version): <lang asm>section .data msg db 'Goodbye, World!', 0AH len equ $-msg

section .text global _start _start: mov edx, len

       mov     ecx, msg
       mov     ebx, 2
       mov     eax, 4
       int     80h

       mov     ebx, 1
       mov     eax, 1
       int     80h</lang>

XLISP

<lang xlisp>(DISPLAY "Goodbye, World!" *ERROR-OUTPUT*)</lang>

XPL0

The terms "standard output" and "standard error" are not used, but it's trivial to send messages to a variety of devices by specifying their numbers. Normally messages are displayed on the text console, which is device 0. Instead, this example sends the message to the (first) printer, which is device 2.

<lang XPL0>code Text=12; Text(2, "Goodbye, World!")</lang>

zkl

<lang zkl>File.stderr.writeln("Goodbye, World!")</lang>