Hello World In Many Programming Languages
Hello World In Many Programming LanguagesThere are very nice collections of 200+ HelloWorld in a lot of ProgrammingLanguages at http://www.latech.edu/~acm/HelloWorld.shtml. A big collection of 440+ Hello World programs can be found here: http://helloworldcollection.de
See also: ProgrammingChrestomathy, ArraySumInManyProgrammingLanguages, CounterInManyProgrammingLanguages, DotProductInManyProgrammingLanguages, WardNumberInManyProgrammingLanguages, HexDumpInManyProgrammingLanguages, NinetyNineBottlesOfBeerOnTheWall, QuineProgram, and TrainSpotting
If you are confused about whether or not your selected language is a programming language take this easy test to determine it: if it is possible to modify the program to print the greeting ten times without duplicating code, then it most likely is a programming language.
An apparently reasonable attempt was made to edit this page on August 6th, 2013, to presumably present a new Algol 60 example, but some of the existing content was damaged in the process. I lack the patience to sort out the mess, so I reverted the edit but made some effort to retain the (corrected?) Algol 60 example. I removed the commentary that related to the old (convoluted, and probably erroneous) example.
trace('hello world');
actsl
from http://compilers.iecc.com/comparch/article/07-10-055
int nul
fun main
"Hello World!\n" arg call printf ref nul =
procedure HELLO_WARD is beginWhat about Tandy TRS 80 (Level 1) with 4k Ram 1 p. "Hello World" 2 End
PUT ("Hello, Ward");
end HELLO_WARD;
Is a variation on the version offered in Understanding Ada by Ken Shumate.
* Direct way(s) (either on a file hello.als or at the interpreter prompt):
println "Hello World!"
trans a "Hello World!"
a
* A bit more involved (let functions be!):
trans hello nil { println "Hello World!" }
hello
* Even more (OO to the mêlée):
const Hello (class)
trans Hello:greet nil { String "Hello World!" }
const nice-user (Hello)
trans nice-user:hello nil { println (this:greet) }
nice-user:hello
It is nice :-) -- DavidDeLis
Algol-60
begin
file rmt (kind = remote);
write(rmt, <"Hello World!">);
end.
AmigaE (AmigaEe):
PROC main()
PrintF('Hello world\n')
ENDPROC
But if you want to use some OOP for more interest:
PROC main() HANDLE
DEF message=NIL:PTR TO printMessage->object to be allocated
NEW message.new('Hello world\n')
message.print()
EXCEPT DO
END message
IF exception
PrintF('Exception raised: \s.\n', IF exceptioninfo THEN exceptioninfo ELSE 'Unknown')
ENDIF
ENDPROC
OBJECT printMessage PRIVATE
message:PTR TO CHAR->message to be printed
ENDOBJECT
/* This is the constructor */
PROC new(message:PTR TO CHAR) OF printMessage
self.message := message
ENDPROC
/* This is a normal method */
PROC print(addNewLine=FALSE) OF printMessage
IF addNewLine = FALSE
PrintF(self.message)
ELSE
PrintF('\s\n', self.message)
ENDIF
ENDPROC
Please note that AmigaE is case-sensitive, that keywords must be uppercase, and that user-defined names must at-least start with a lower-case letter.
APL (AplLanguage)
'Hello World'
on helloWorld()
display dialog "Hello World!" buttons {"OK"}
end helloWorld
helloWorld()
AssemblyLanguage for the IBM-PC (i386):
dosseg .model small .stack 100h .data hello_message db 'Hello, World!',0dh,0ah,'$' .code main proc mov ax,@data mov ds,ax mov ah,9 mov dx,offset hello_message int 21h mov ax,4C00h int 21h main endp end mainBut nowadays, we do it in protected mode in Linux.
.text .global _start _start: mov $4, %eax /* write system call */ mov $1, %ebx /* stdout */ mov $msg, %ecx mov $msgend-msg, %edx int $0x80 mov $1, %eax /* _exit system call */ mov $0, %ebx /* EXIT_SUCCESS */ int $0x80 .data msg: .ascii "Hello, world\n" msgend:(Very nice, but gas/gcc format should be:
.global main main:I have just checked it.. otherwise, it's cool, my assembler days are long gone...)
Nope. That is if you want to use the libc and use the C startup code. The above program, however, does not require any C library code to be linked; it calls directly to the kernel through the interrupt 0x80 interface.
Autoit 3
Msgbox(0,"Hello!!","Hello,World !!")
Or
ConsoleWrite?("Hello, World !!!")
IBM 360/370/390 BAL (Basic Assembler Language)
// EXEC ASSEMBLY START MAINBALR 2,0 USING *,2 OPEN PRINT MVCBUF,HW PUTPRINT CLOSE PRINT EOJ HWDCCL132'HELLO WORLD' BUFDSCL132 PRINTDTFPR IOAREA1=BUF,DEVADDR=SYSLST,BLKSIZE=132,* DEVICE=3203,CONTROL=YES,PRINTOV=YES ENDMAIN /* // EXEC LNKEDT // EXEC /* /&(Ahhh... those were the days)
Sorry, had to tweak it! Opcodes start in col. 10; operands in col. 16. These two rules aren't essential - an opcode can start as early as col. 2. Continuation character is in col. 72 (didn't bother spacing that far over). Continuations of statements on the next line start at col. 16. These last two rules are essential.
echo "" | awk 'BEGIN{print "Hello World"}'
or
echo "Hello World" | awk '{print $0}'
GNU Awk:
awk 'BEGIN{print "Hello World"}'
B (BeeLanguage):
main( ) {
putchar('hell');
putchar('o, w');
putchar('orld');
putchar('*n' );
}
-- AdamBerger
10 PRINT "HELLO WORLD"(Obviously optional, but included 99.999% of the time...)
20 GOTO 10 RUN (AWAY, LAUGHING)Poor old Basic - everybody's forgotten you...
10 FORI=1to100000:NEXT 20 PRINT CHR$(7):GOTO20
0".dlrow ,olleH">v ,: ^_@
BlitzMax? (http://www.blitzmax.com)
Can be done in two variants
Print "Hello World!"Or if you want it in a nice dialog box
Notify "Hello World!"
Bourne Shell:
#!/bin/sh echo hello, world
BrainLanguage (brain hello.brn):
"Hello, world" println.
BrainfuckLanguage (an EsotericProgrammingLanguage)::
>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++. [-]>++++++++[<++++>-]<.>+++++++++++[<+++++>-]<. >++++++++[<+++>-]<.+++.------.--------.[-]>++++++++[<++++>-]<+. [-]++++++++++.
>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++. [-]>++++++++[<++++>-]<.#>+++++++++++[<+++++>-]<. >++++++++[<+++>-]<.+++.------.--------.[-]>++++++++[<++++>-]<+. [-]++++++++++.
-- DavidHooker
shorter:
++++++++++[>+++++++>++++++++++>+++>+<<<<-] >++.>+.+++++++..+++.>++.<<+++++++++++++++. >.+++.------.--------.>+.>.
C (CeeLanguage) (according to KernighanAndRitchie):
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("Hello, world\n");
return EXIT_SUCCESS;
}
Cerner Command Language (CCL)
;Example 1
call echo("Hello World!") go
;Example 2
drop program helloworld2 go
create program helloworld2
call echo("Hello World!")
end go
;Example 3
drop program helloworld3 go
create program helloworld3
PAINT
call TEXT(1,1, "Hello World!")
end go
class Hello {
static void Main() {
System.Console.Write("Hello World");
}
}
C++ (CeePlusPlus)
#include <iostream>
int main()
{
std::cout << "Hello, World.";
}
The code does not actually need the
return 0; // an integer return value is expected. Thou shalt not remove this line!to be conformant - main will implicitly return 0 if no return value is given. See 3.6.1.5 (http://www.open-std.org/jtc1/sc22/open/n2356/basic.html#basic.start.main) -- ScottMcMurray
Cobol
IDENTIFICATION DIVISION. PROGRAM-ID. Hello. ENVIRONMENT DIVISION. DATA DIVISION. PROCEDURE DIVISION. Display 'Hello, World'. STOP RUN.
Tag based:
<cfset hello = "Hello World!"> <cfoutput>#hello#</cfoutput>Script based:
<cfscript>
WriteOutput("Hello World!");
</cfscript>
Note that you don't need to assign a variable first. You can just type Hello World without any tags (if you don't care about "proper" HTML).
COM HelloWorld client:
#define WIN32_LEAN_AND_MEAN #include <windows.h> #include <objbase.h> #include <iostream.h> #include <tchar.h> #import "HelloSrv?.tlb" void _tmain (int argc, TCHAR * argv[]) { if (S_OK == CoInitialize?(NULL)) { try { HELLOSRVLib::IHelloWorld p(__uuidof(HELLOSRVLib::HelloWorld)); p->Hello(); } catch (const _com_error& Err) { cerr << Err.ErrorMessage?() << endl; } CoUninitialize?(); } else { cerr << "Error during OLE initialization" << endl; } }-- PhilipEskelin
RM COBOL:
000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. HELLOWORLD. 000300 000400* 000500 ENVIRONMENT DIVISION. 000600 CONFIGURATION SECTION. 000700 SOURCE-COMPUTER. RM-COBOL. 000800 OBJECT-COMPUTER. RM-COBOL. 000900 001000 DATA DIVISION. 001100 FILE SECTION. 001200 100000 PROCEDURE DIVISION. 100100 100200 MAIN-LOGIC SECTION. 100300 BEGIN. 100400 DISPLAY " " LINE 1 POSITION 1 ERASE EOS. 100500 DISPLAY "Hello world!" LINE 15 POSITION 10. 100600 STOP RUN. 100700 MAIN-LOGIC-EXIT. 100800 EXIT.
Interactively (at the ReadEvalPrintLoop):
"Hello World!"
If you're picky and you want a file you can "execute" which will write the sequence "Hello World!\n" on stdout:
(write-line "Hello World!")
COW (an EsotericProgrammingLanguage):
see: http://www.bigzaphod.org/cow/
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO Moo Moo MoO MoO MoO Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo MoO MoO MoO Moo MOo MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo
Is this code translated from the BrainfuckLanguage code given above? -- AnonymousDonor
D
See: http://dlang.org/
import std.c.stdio;
int main(char[][] args)
{
printf("Hello, World!\n");
return 0
}
-- PaulRuane
Also:
import std.stdio;
void main() {
writeln("Hello, World!");
}
[Hello, world!] p
Dodo http://dodo.sourceforge.net
In the runnable dodo0 variant:
println("Hello World!") ->
exit()
A proper dodo program would be:
import console
def Main: Main()
{
console!Stdout().Puts("Hello World!")
}.
DOS (DiskOperatingSystem)
command.com Shell Script:
echo Hello WorldMac users often confuse the operating system with the small sample shell that came with it.
It was claimed that DOS did not qualify as a programming language, according to the test given at the top of the page. However, consider the following cmd.exe shell script:
for /l %i in (1,1,10) do echo Hello World(at least under NT-like shells)
class HELLO
creation make
feature make is
do
print ("Hello, World%N")
end
end -- class HELLO
(defun hello-world ()
(interactive)
(with-current-buffer (pop-to-buffer "*Hello!*")
(insert "Hello World\n")))
In file hello.erl:
-module(hello).
-export([hello_world/0]).
hello_world() -> io:fwrite("hello, world\n").
in erl (or esh, or compiling it):
> c(hello). > hello:hello_world().
##X#
For non-programmers:
These examples are mere toys! Don't forget the real thing, GNU HelloWorld at http://www.gnu.org/software/hello/
From the page:
The GNU `hello' program produces a familiar, friendly greeting. It allows nonprogrammers to use a classic computer science tool which would otherwise be unavailable to them. Yes, this really is the classic program that prints "Hello, world!" when you run it. Unlike the elementary version often presented in books like K&R, GNU hello processes its argument list to modify its behavior, supports internationalization, and includes a mail reader. The primary purpose of this program is to demonstrate how to write other programs that do these things; it serves as a model for all of the GNU coding standards.This is an interesting corollary to the joke among Windows programmers that the last Windows program was written sometime in 1994; everything since then has been a modification of HELLO.C from Petzold. Sadly, I actually worked on a commercial product where that was the case.
Forte TOOL:
task.part.logmgr.putline( 'Hello World ' );-- DavidVydra
CR .( Hello, world!)
FortranLanguage -- this works both with f77 and f90
PROGRAM HELLOWORLD 10 FORMAT (1X,11HHELLO WORLD) WRITE(6,10) END
println["Hello World!"]
package main
import "fmt"
func main() {
fmt.Printf("Hello, World\n")
}
obbs["Hello World!"]xx:
main = do putStrLn "Hello, world."-- LoganHanks?
In file HelloWorld.hs:
module Main where main = putStrLn "Hello, World!\n"Then compile it or call it (eg. using hugs98: hugs HelloWorld.hs and at the prompt -> main)
h
Hello Worldexecuted as helloworld.htag if htag is properly associated with the interpreter, or as htag helloworld.htag if it isn't.
Here if it's called as http://localhost/helloworld.htag:
<!%WRITECONTENTTYPE%> <html><head> <title>Hello world</title> </head> <body> Hello World </body>This is also the reason why I created HtagLanguage, so I don't need unnecessary fluff. -- SvenNeumann
HTML
not a programming language.
That's not a sufficient reason to exclude it. Anyhow, ColdFusion is based around it, thus one can "print" just by stating the string:
Hello WorldHard to beat that.
Icon
procedure main(args)
write("Hello, World!");
end
-- MichaelKnight
[ Main; print "Hello World!^"; ];
"Hello World!" print
"Hello World!" println
Jakarta Velocity (JakartaVelocity)
import java.io.StringWriter;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.VelocityContext;
public class HelloWorld
{
public static void main(String args[])
throws Exception
{
Velocity.init();
VelocityContext context = new VelocityContext();
context.put("name", "World");
String s = "Hello $name!";
StringWriter w = new StringWriter();
Velocity.evaluate(context, w, "hello", s);
System.out.println(w);
}
}
-- DimitrisTzoumpas
public class Hello {
public static void main(String []args) {
System.out.println("Hello World");
}
}
Object oriented Java
class Greeting {
void greet(Named target) {
System.out.println("Hello, " + target.getName() + "!");
}
}
interface Named {
String getName();
}
class World implements Named {
String getName() {
return "World";
}
}
class Main {
public static void main( String[] args ) {
Greeting greeting = new Greeting();
greeting.greet(new World());
}
}
Swing Java
public class Hello {
public static void main(String []args) {
JOptionPane.showMessageDialog(null,"Hello, world!");
}
}
JavaApplet:
import java.applet.*;
import java.awt.*;
public class Hello extends Applet {
public void paint(Graphics g) {
g.drawString("Hello World", 25, 50);
}
}
document.writeln("Hello, World");
-- Paul Gresham, 07NOV1999
Pop up:
alert("Hello, World");
Note that none of these two examples are, strictly speaking, correct. They might however produce some results when being run from a specific host environment, and might even produce the intended result when this host environment happens to be a WebBrowser...
J (JayLanguage)
'Hello World'
"Hello World!" putln .-- ShaeErisson
K (KayLanguage):
`0:"Hello World"
LatteLanguage? (http://www.latte.org/):
{\def \hello "Hello, World!"}
{\head {\title \hello}}
{\body \hello}
-- IlmariKaronen
LISP:
(DEFUN HELLO-WORLD () (PRINT (LIST 'HELLO 'WORLD)))
put "Hello World"or:
alert "Hello World"-- Welshy31
Logo
the turtle language, still unbeaten in handling of sets, there is an interpreter here: http://www.cs.berkeley.edu/~bh/logo.html
print [Hello World]-- michael
HAI CAN HAS STDIO? VISIBLE "HAI WORLD!" KTHXBYE
Lotus Formula:
@Prompt([Ok];"";"Hello World")
Sub Click(Source As Button) Print "Hello World" End Sub
print "Hello, World."
import IO = LX.Text_IO procedure HELLO() is IO.WriteLn "Hello World"
(* Classic Modula-2, aka PIM *) MODULE HelloWorld; FROM InOut? IMPORT WriteString?,WriteLn; BEGIN WriteString?("Hello World!"); WriteLn; END HelloWorld. (* ISO Modula-2 *) MODULE HelloWorld; FROM STextIO IMPORT WriteString?,WriteLn; BEGIN WriteString?("Hello World!"); WriteLn; END HelloWorld. (* Modula-2 R10 *) MODULE HelloWorld; IMPORT PervasiveIO; BEGIN WRITE("HelloWorld!\n"); END HelloWorld.
MODULE Hello EXPORTS Main; IMPORT Stdio, Wr; BEGIN Wr.PutText?(Stdio.stdout, "Hello World"); END Hello.Graphical version
MODULE Hello EXPORTS Main;
IMPORT Trestle, TextVBT;
VAR v := TextVBT.New("Hello World");
BEGIN
Trestle.Intall(v);
Trestle.AwaitDelete?();
END Hello.
Multiple languages:
All such discussions are concluded by contemplating HelloPolyGlots. Cobol, Pascal, Fortran, C, PostScript, BourneShell, Assembly: All in one single source file!
That makes my cheesy little effort (Perl and C) look, well cheesy. Here it is anyway. -- BruceIde
#include <stdio.h>
#define sub int
#define print(a) printf("%s", a)
sub main() {
print("Hello world\n");
}
#ifdef _perl
main();
#endif
NemerleLanguage: (http://www.nemerle.org)
module Hello {
Main(): void {
Nemerle.IO.printf("Hello world\n");
}
}
or a graphical version, using Gtk#:
using System;
using Gtk;
using GtkSharp;
module hello {
Main(): void {
Application.Init();
def button = Button("Hello World");
button.Clicked += (fun(_,_) {
Console.WriteLine("Hello World")
});
def window = Window("Helloworld");
window.DeleteEvent += (fun(_,_) {
Application.Quit()
});
window.Add(button);
window.ShowAll();
Application.Run()
}
}
#import <Foundation/Foundation.h>
@interface Greeter : NSObject {
}
- greet;
@end
@implementation Greeter
- greet {
NSLog(@"Hello, World!");
}
@end
int main(int argc, char *argv[]) {
Greeter *gr = [Greeter new];
[gr greet];
[gr release];
return 0;
}
-- MartinHëer
OpalLanguage?:
FUN hello : denotation DEF hello == "Hello, World"Since Opal is a pure functional language there is no such side-effect as outputting something to stdout the only possibillity is to call this from the interpreter and so get the string as a result. (Ok, there is an output monad, but I'm not gonna touch that. :)
The idea is to show a program which prints out "Hello, world!" to the standard output. If it is difficult or ugly in your language, then so be it. If you are ashamed, then remove it completely.
At the interactive prompt:
print_string("Hello World!");;
This is more correct (adds a newline and flushes the channel):
print_endline "Hello, World!";;-- MarcoMaggesi
program HelloWorld; begin writeln('Hello World'); end.-- SavasAlparslan
$\/\/\ /\ /\ I wish Ward +++++ ++ ++ +++++ /++++\ ++ ++ /++++\ would fix the ++\++\++ ++ ++ ++ ++ +++++ +/+++/ ++ ++ ++ +++++ ++++ ++ ++ \/\/\ /\+++/\ /\ /++.+/ \\backslash /++++.+++++++++++++++++++++++++++ / \bug! /\- -# ++. -. +/ \++++\ /++++\ ++ /---\- -+ + /\ + ++ ++ +. -.- -> + +. + ++ ++- -+- . +> + ++ ++- -+- -. \.+/\++/ \++++/ ++\ /-.+/- -- \/\.</\/ \/You forgot the '$'. --AnonymousDonor
It's not strictly necessary for this program, since you start at the top left by default.
print "Hello World\n"Type this into a file and run it with the single command, perl hello.pl.
Or provide the program on the command line, as:
perl -e "print 'Hello, world'"(Note: The double-quotes are placed at the outer level to be compatible with DOS-based systems - and still work with Un*x.)
Or, invoke Perl as an interactive interpreter/compiler ala Forth, BASIC, etc.
perl -e "while(<>){eval;print $@;}"
or
perl -ne "eval; print $@;"
or
perl -de 1 # given appropriate CPAN bits, this has command-line editing
and input the program directly:
print "Hello, world" Hello, world # Perl's immediate responseor even:
sub hello { print "Hello, world" };
hello; # Call the subroutine we just defined
Hello, world # Perl's immediate response
Perl subsumes all languages eventually...
perl -e 'use Inline C=>q{void hw(){printf("Hello, world!\n");}};hw'
perl -e 'use Inline Ruby=>q{def hw;puts "Hello, world!";end};hw'
-- BrianIngerson
Perl "Obfuscation" (taken from http://www.perlmonks.net/index.pl?node_id=329174)
package Earth;sub Greet{
%_=('Y','~');$_='$;=!(Middle
Earth.age~~~<Eart~~~~~~~~~~~~~h
.age)?!(defined$ti~~~~~~~~~~~mez~~~On
e[2])?!(push@time~~~~~~~~~~~~~~~~Zone,loc
~altime())?rotation?~~~~~~~~~~~~~q~~?The Worl
~~d?:q:[\w]::q=[\~~~~~~~~~~~~~~~~~d~a-f]=:q?..~~
~~~?:q:.:;"42b3d3~~~~~~~~~~~~~~~~~~~~~728656c6c6f6
~~~~~0277f627c64672~~~~~~~~~~~~~~~~~~~~~b3072796e647
~~~~~~~42b3b3rg7d"=Ym~~~~~~~~~~~~~~~~~~~\$;~~*\;p~~~~u
~~~~~~~~~sh@_,$&;bless~~~~~~~~~~~~~~~~~~~~~~~~~$c~~~~~~~
~~~~~~~~~o~ntine~~~~~nt~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~s=\~~~~~~~$~~~~~~~~~~~~~~~~~~~~~~~pangaea~~~~
~~~~~~~~~~~~~~~;{l~~~~~~~~~~~~~~~~~~~~~~~~~~~~ocal@_;local$;
~~~~~~~~~~~~~~~~~="o~~~~~~~~~~~~~~~~~~~~~~~~~cean";$^A=(defi
~~~~~~~~~~~~~~~~~~~n~~~~~~~~~~~~~~~~~~~~~~~~~ed$continents)?
~~~~~~~~~~~~~~~~~~~(vec(~~~~~~~~~~~~~~~~~~~~~~$;, YYsplit(\'
~~~~~~~~~~~~~~~~~\',${\$;}~~~~~~~~~~~~~~~~~~~~~~)%3,YYsplit(
~~~~~~~~~~~~~~~~q??,$;)**2-~~~~~~~~~~~~~~~~~~~~~~(($;=Ytr/oa
~~~~~~~~~~~~~~~~eiu//)**2))=~~~~~~~~~~~~~~~~~~~~~~=28160)?q:
~~~~~~~~~~~~~~~~~.::q?!?:\'?~~~~~~~~~~~~~~~~~~~~~~\';}$^A=Ys
~~~~~~~~~~~~~~~~:\Q.\E:pack(~~~~~~~~~~~~~~~~~~~~~~\'h*\',j
~~~~~~~~~~~~~~~~~oin(q(),~~~~~~~~~~~~~~~~~~~~~~~grep{$_=
~~~~~~~~~~~~~~~~~~Ym,$,,}~~~~~~~~~~~~~~~~~~~~~~~split("
~~~~~~~~~~~~~~~~~",@_~~~~~~~~~~~~~~~~~~~~~~~~~~[0]))
~~~~~~~~~~~~~~~~):e~~~~~~~~~~~~~~~~~~~~~~~~~~~gexe
~~~~~~~~~~~~~~~;$d~~~~~~~~~~~~~~~~~~~~~~~~~~~="s
~~~~~~~~~~~~~~ort~~~~~~~~~~~~~~~~~~~~~~~~~~<=
~~~~~~~~~~~~>,~~~~~~~~~~~~~~~~~~~~~~~~~~YY
~~~~~~~~~~~@_~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~"~~~~~~~~~~~~~~~~~~~';;
s,(~|\r|\n|\s),,g;s.Y.\x7e.g;
eval};Greet;'the world';
<?="Hello World"?>
But you have to have short tags turned on in the ini file, otherwise:
<?php echo "Hello World"; ?>
-- BrynJones?
Or just type "Hello, world!" in a file, and run php -f helloworld.php (doesn't have to pre-process plain old text, now does it?)
-- Phil
Pike
int main() {
write("Hello World\n");
}
PlbLanguage (or Databus)
DISPLAY "HELLO WORLD" STOP
PL/SQL
BEGIN
DBMS_OUTPUT.PUT_LINE('Frank and Beans');
END;
(Hello World) =or (only strings, to stdout)
(Hello World\n) printor (to any file)
(%stdout) (w) file (Hello World\n) writestringor (put on paper)
/Times-Roman findfont 12 scalefont setfont 100 100 moveto (Hello World) show showpage
PowerScript?
(used in PowerSoft?/Sybase PowerBuilder) global type main from application end type global main main on main.create appname = "main" end on event open;MessageBox ('', 'Hello World') end event
"Hello World"
In this now-defunct, really visual dataflow OOP language, that was very cool and way ahead of its time, the program is:
(Note that in Prograph there was no "C code generation" or similar idiocy -- the compiler acted directly on this hierarchical hypergraph to create executable code. Alas for visionaries everywhere....) --BillTozier
Highlighting one DISadvantage of a really visual dataflow language, the above image link is now broken, while the code for the plain old behind the times textual languages remains.
Prolog:
go :-
writeln('Hello World').
-- TechnoKid?
You copy the following text into a file and call the file (hello.py) (remember python is sensitive of it's indenting, which rocks :) )
print "hello world"Now invoke the interpreter and pass it your file with the single command: python hello.py
QBasic:
? "Hello, world!"The only language so far with Q? (See G entry) ... No I haven't forgotten you, dear QB (See BASIC entry)
-- Phil
P.S. (Anyone brave enough for a QuickBasic version? How about QB4.5 (mmm, compiled basic...)? VBDOS???)
Rebol
print "Hello World"or:
"Hello World"In a script:
Rebol [] print "Hello World"-- AndrewMartin
say 'hello, world';
RpgLanguage - RPG Column positions are crucial - in old style RPG
Columns . . . :6 76BrowseTESTLIB/QRPGLESRC SEU==>TESTPGM FMT C CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len++D+HiLoEq?
FQSYSPRTO PRINTER OFLIND(*IN88) D* CEXFMTRECFMT CEVAL*INLR = *ON O RECFMT R O11 'HELLO WORLD'Free format RPG IBM finally put the cash in for something a little more readable.
Columns . . . :6 76BrowseTESTLIB/QRPGLESRC SEU==>TESTPGM
/Free dsply 'Hello World';
/end-free-- JoshuaRobinson
puts "Hello, world"(run with ruby hello.rb or ruby -e 'puts "Hello, world"')
HelloWorld in Scala is discussed in several steps on this page: http://www.artima.com/scalazine/articles/steps.html
println("Hello, world, from a script!")
(display "Hello, World!") (newline)The following version does not work unless your Scheme system contains the writes procedure, which is non-standard.
(define hello-world (lambda () (writes 'nil "Hello, World!")))-- IainLowe
I thought that at the Scheme interpreter prompt, since strings evaluate to themselves, you would just type
"Hello World"and the interpreter would print it right back at you. -- EdwardKiser
That's true, I hadn't thought of that. That bodes ill for SimplestThingThatCouldPossiblyWork.
The same thing works in FalseLanguage.
I'd even venture:
(display "Hello, world!\n")We all love Closures - don't we:
(define function lambda) ; for non-lispers only (define greet-constructor (function (x y) (cons x y))) (define get-greeting-function (function (a) (function (b) (greet-constructor a b)))) (define my-greeting-function (get-greeting-function 'hello)) (my-greeting-function 'world)-- ClausGittinger?
sed:
s;.*;Hello, Ward; qActually, this fails on empty input files. How about this:
0i\ Hello, world! d
ShellScript?:
#!/bin/sh echo "Hello World"
Small Basic (Microsoft):
TextWindow.WriteLine("Hello, World")
Also
GraphicsWindow.DrawText(10, 10, "Hello, World")
Transcript cr; show: 'Hello World'.Type this into a workspace, select it and choose doit. Or, if you prefer a prototype, just type the quoted string, select it and choose printit.
Then let's see how to build an "executable" that will run in something like the same way all the other languages will. We can do anything in Smalltalk, but the packaging, oy! -- RonJeffries
I always show this, when asked by C/C++ programmers, as a typing in of "Hello, World!," preferably into an empty Transcript pane. And then I save the image. Loading the program subsequently brings up: "Hello, World!" Individuals will quibble over this relentlessly, saying, "It's not the same!" I can only agree that it's not the same, but that was my point about the languages and their environments in the first place. -- JerryArchibald
(Eeeh - I have an eerie feeling I've just walked through this exact thing from the POV of a non-Smalltalk programmer on SmalltalkHelloWorld)
I don't think this argument holds any longer - there are smalltalks around which can do this kind of stuff quite neatly (GNU-ST, ST/X...) -- ClausGittinger?
SmileBASIC
print "Hello World"
val () = print "Hello, world!\n"
output = "Hello, world"end
SnuspLanguage (possibly the most fun I've ever had writing Hello world!)
/e+++++++++++++++++++++++++++++.\ ./\/\/\ /+++\!>.+++o.l.+++++++l/ #/?\ $H!\++++++\ +\comma.------------ .<w++++++++.\ /?\<!\-/ /++++++/ +/\/.--------o/ \-/!.++++++++++/?\n /=\++++++\ +\\!=++++++\\r+++.l------.d--------.>+.!\-/ \!\/\/\/\/ \++++++++++/or in Modular SNUSP:
/@@@@++++##+++@@\#-----@@@\n $@\H.@/e.+++++++l.l.+++o.>>++++.< .<@/w.@\o.+++r.++@\l.@\d.>+.@/.# \@@@@=>++++>+++++<<@+++++##---@@/!=========/!==/Skeleton key (the flexiblity of PathLanguage or BefungeLanguage combined with the aesthetics of Brainf**k):
SQL (StructuredQueryLanguage):
SQL has no branching or conditionals. It is not a programming language. It is a query language.
Hmm, well.
SELECT 'Hello World!';And how about the Oracle SQL flavour?
SELECT 'Hello World!' FROM dual;I don't know if there is a vendor-neutral way to specify this. Most dialects require the specification of a table in a SELECT statement, if I'm not mistaken.
println("Hello, World")
TeX
Hello,~world!or (messing with subroutines / macros)
\def\hw#1{Hello,~#1}
\hw{world!} \\
\hw{Ward.}
(BTW, writing these examples I ran across a bug: end-of-line backslashes are eaten (together with the linefeed) at edit.)
in LaTeX, you should use \newcommand:
\newcommand{\hw}[1]{Hello,~#1}
While we're at it, let's see the same definition in other macro processors:
m4: define(`hw',`Hello, $1') cpp: #define hw(who) Hello, whoIt was claimed that TeX did not qualify as a programming language, according to the test given at the top of the page. However, consider the following:
\long\def\repeat#1#2{
\count0=0
\def\onceMore{
\ifnum\count0<#1
#2
\advance \count0 by 1
\onceMore
\fi
}
\onceMore
}
\repeat{10}{Hello,~World\par}
\bye
And let's not forget that there exists a BasicLanguage interpreter written in TeX: http://texcatalogue.sarovar.org/entries/basix.html
Implementation class HelloWorld int main Array arguments { [[[stdio out] print "Hello, world"] nl]; } end; Implementation instance HelloWorld end;
puts "Hello, world"
page = PAGE page.typeNum = 0 page.10 = TEXT page.10.value = HELLO WORLD!
`r```````````.H.e.l.l.o. .w.o.r.l.di
Sub Main() MessageBox("Hello World") End Sub
VisualFoxPro: - will also work in Clipper and almost any other DBase III-driven scripting language, known collectively as "Xbase" (ExBase)
? "Hello World"
MS VJ++ 6.0 version:
import com.ms.wfc.app.*;
import com.ms.wfc.core.*;
import com.ms.wfc.ui.*;
import com.ms.wfc.html.*;
public class Form1 extends Form
{
public Form1()
{
// Required for Visual J++ Form Designer support
initForm();
}
public void dispose()
{
super.dispose();
components.dispose();
}
/**
* NOTE: The following code is required by the Visual J++ form
* designer. It can be modified using the form editor. Do not
* modify it using the code editor.
*/
Container components = new Container();
private void initForm()
{
this.setText("Form1");
this.setAutoScaleBaseSize(new Point(5, 13));
this.setClientSize(new Point(292, 273));
this.addOnClick(new EventHandler(this.Form1_click));
MessageBox.show("Hello, world");
}
public static void main(String args[])
{
Application.run(new Form1());
}
}
<?xml version="1.0"?> <vxml version="2.0"> <form> <block> <prompt>Hello, World!</prompt> </block> </form> </vxml>-- FredrikBreivald
XIML
<el eltype="txt" x="23" y="18" datatype="static" dataval="Hello, World!" font="Verdana" color="0xff0000" size="30" />
Whirl
110011100111000001111100000001000011111000011111100000000010 000011001111100001100010000010011111000100000000000001001111 100000111110001000000000000000001000111110010000001100001111 100011000000000100111110011100111000111000001000111000001111 100000111110010000011111000110011111100001111000001111000001 110011111100001111000110011100000111000100011111000001111100 100000110000000111000001110001111100011111000111000001000001 000011000111110001000001000000011100000111001000111110001111 000001111000011111100001111110000011110000000000000000011110 000011100111000011110011111000111110001111100000100000000000 000000000000111110001110000001110000011100011100111110001000 100000000011100001111100110000000010011111000111100000111100 111100010011100000111110000011111001100111100010001111000000 000001000111110010000010011110011001110001000111110001100000 100011111000011110011100111111000111100000111100011111000000 011110000011100100001111000100011111001100011111000111100000 111001110001100111100100000000000000011111000001111100010010 000011100001111100100000100011100000111000110011110001001111 110001100000111100011111000111100000111001000011110001001111 100000111110000000011110000011110000000000000000111000001110 000011000001100000111000111000001100111110000111111001001110 000011111000001100011000001001111110000011100110011111000000 000111000001110000111100001100 -- by Kang Seonghoon 2005.1.7
Whitespace - A real language (http://compsoc.dur.ac.uk/whitespace/)
Say hello.
(To be "Readable" and also so that it isn't rejected by the WikiWiki formatting transform): <tab>
<tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <space> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <space> <space> <space> <tab> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <space> <space> <space> <space> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <tab> <space> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <space> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <tab> <tab> <space> <space> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <space> <space> <tab> <tab> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <tab> <tab> <space> <tab> <space> <space> <tab> <space> <tab> <tab> <space> <tab> <tab> <tab> <space> <space> <tab> <tab> <space> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <space> <tab> <tab> <tab> <space> <tab> <tab> <space> <space> <tab> <space> <space>Note that the newlines are significant, but the extra spaces between the <space>s and <tab>s should be removed before any s/<tab>/\t/ and s/<space/ /
Note: This appears to be complete whimsy, and much wasted space on top of that. Hmph.
VBScript:
WScript.StdOut.WriteLine "Hello, World";JScript:
WScript.StdOut.WriteLine("Hello, World");
Not a language.
Oh really? I'd have thought it was:
WikiWiki: Hello, world!Output:
WikiWiki: Hello, world!
EditText of this page
(last edited November 12, 2014)
or FindPage with title or text search