php-deluxe.net - description Hello world program

Hello world program

A hello world program is a computer program that prints out Hello, world! on a display device. It is used in many introductory tutorials for teaching a programming language and many students use it as their first programming experience in a language.

Such a program is typically one of the simplest programs possible in a computer language. Some are surprisingly complex, especially in some graphical user interface (GUI) contexts. Some others are very simple, however, especially those which rely heavily on a particular command line interpreter to perform the actual output. In many embedded systems, the text may be sent to a one or two-line liquid crystal display (LCD) (and in yet other systems, a simple light emitting diode being turned on may substitute for Hello world! ).

A hello world program can be a useful sanity test to make sure that a language s Compiler, development environment, and run-time environment are correctly installed. Configuring a complete programming Toolchain from scratch to the point where even trivial programs can be compiled and run may involve substantial amounts of work. For this reason, a simple program is used first when testing a new tool chain.

While small test programs existed since the development of programmable computers, the tradition of using the phrase Hello world! as the test message was influenced by an example program in the book The C Programming Language (book) , by Brian Kernighan and Dennis Ritchie, published in 1978. The example program from that book prints hello, world (i.e., no capital letters, no exclamation sign; those entered the tradition later). The book had inherited the program from a 1974 Bell Labs internal memorandum by Kernighan — Programming in C: A Tutorial — which shows the first known version of the program: main( ) { printf( Hello, world! ); }

However, the first known instance of the usage of the words hello and world together in computer literature is in A Tutorial Introduction to the Language B , by Brian Kernighan, 1973. [http://cm.bell-labs.com/cm/cs/who/dmr/bintro.html]

There are many variations on the punctuation and casing of the phrase, and the examples on this page print out several of these variations. Variations include the presence or lack of the comma and exclamation mark, and the capitalisation of the H , both H and W , or neither. The most commonly accepted variation, despite not being the original text, is Hello, world! Some languages are forced to implement different forms, such as HELLO WORLD!, on systems that only support capital letters, while many Hello world program in esoteric languages print out a slightly modified string. Hello world programs also normally print a newline character or character sequence (either ASCII-10 or 13,10).

A collection of hello world programs written in various computer languages is often used as a very simple Rosetta Stone to assist in learning and comparing the languages. This is somewhat ironic, in that the original intent of the hello world program was to be a trivially simple, uninteresting program used to demonstrate every part of the programming process besides the code itself. Arguably, then, a hello world program is, by design, a poor choice to showcase a language. However, since it is common practice, a number of examples are included below.

Here are some examples in different languages:

=Text user interface (Known as text user interface, console or line-oriented)=

== 4GL - Computer Associates with Ingres/DB ==

message Hello, World! with style = popup;

== ABAP - SAP AG ==

REPORT ZELLO. WRITE Hello, World! .

== ABC programming language ==

WRITE Hello, world!

== Ada programming language ==

Ada.Text_IO; Ada.Text_IO.Put_Line ( Hello, world! ); Hello;

For explanation see .

== ALGOL 68 ==

In the popular upper-case ALGOL 68#Program representation for bold words:

BEGIN print END

or using prime stropping suitable for punch cards:

BEGIN PRINT END

or minimally using the short form of begin and end, and implied newline at program termination:

( print( Hello, World! ) )

== AmigaE programming language ==

PROC main() WriteF( Hello, World! ); ENDPROC

== APL programming language ==

Hello World

== AppleScript ==

== Assembly language ==

=== Accumulator-only architecture: PDP-8, PAL-III assembler ===

See the PDP-8#Example_program section of the PDP-8 article .

=== First successful µP/OS combinations: Intel 8080/Zilog Z80, CP/M operating system, RMAC assembler ===

bdos equ 0005H ; BDOS entry point start: mvi c,9 ; BDOS function: output string lxi d,msg$ ; address of msg call bdos ret ; return to CCP msg$: db Hello, world!$ end start

=== Accumulator + index register machine: MOS Technology 6502, Commodore International KERNAL, ca65 assembler ===

MSG: .ASCIIZ Hello, world! LDX #$F3 @LP: LDA MSG-$F3,X ; load character JSR $FFD2 ; CHROUT (KERNAL), output to current output device (screen) INX BNE @LP ; RTS

=== Accumulator/Index microcoded machine: Data General Nova, RDOS ===

See the Data General Nova#Assembly_language_example section of the Nova article.

=== Expanded accumulator machine: x86, DOS, Turbo Assembler ===

MODEL SMALL IDEAL STACK 100H DATASEG MSG DB Hello, world! , 13, $ CODESEG Start: MOV AX, @data MOV DS, AX MOV DX, OFFSET MSG MOV AH, 09H ; DOS: output ASCII$ string INT 21H MOV AX, 4C00H INT 21H END Start

=== Expanded accumulator machine: x86, Microsoft Windows, FASM ===

;Assumes that enviromnent variable %fasminc% is set format PE GUI 4.0 include %fasminc%win32a.inc section .code code readable executable invoke MessageBox,0,hellomsg,hellolb,MB_OK+MB_ICONINFORMATION invoke ExitProcess,0 section .data data readable writable hellomsg db Hello, World! ,0 hellolb db Hello World ,0 data import library user32, user32.dll ,kernel32, kernel32.dll include %fasminc%apiauser32.inc include %fasminc%apiakernel32.inc end data

=== Expanded accumulator machine: x86, Linux, GNU Assembler ===

.data msg: .ascii Hello, world! len = . - msg .text .global _start _start: movl $len,%edx movl $msg,%ecx movl $1,%ebx movl $4,%eax int $0x80 movl $0,%ebx movl $1,%eax int $0x80

=== General-purpose fictional computer: MIX, MIXAL ===

TERM EQU 19 console device no. (19 = typewriter) ORIG 1000 start address START OUT MSG(TERM) output data at address MSG HLT halt execution MSG ALF HELLO ALF WORL ALF D END START end of program

=== General-purpose fictional computer: MMIX, MMIXAL ===

string BYTE Hello, world! ,#a,0 string to be printed (#a is newline and 0 terminates the string) Main GETA $255,string get the address of the string in register 255 TRAP 0,Fputs,StdOut put the string pointed to by register 255 to file StdOut TRAP 0,Halt,0 end process

=== General-purpose-register CISC: PDP-11, RT-11, MACRO-11 ===

.MCALL .REGDEF,.TTYOUT,.EXIT .REGDEF HELLO: MOV #MSG,R1 MOVB (R1),R0 LOOP: .TTYOUT MOVB +(R1),R0 BNE LOOP .EXIT MSG: .ASCIZ /HELLO, WORLD!/ .END HELLO

=== CISC on advanced multiprocessing OS: VAX, Virtual Memory System, MACRO-32 ===

.title hello .psect data, wrt, noexe chan: .blkw 1 iosb: .blkq 1 term: .ascid SYS$OUTPUT msg: .ascii Hello, world! len = . - msg .psect code, nowrt, exe .entry hello, ^m ; Establish a channel for terminal I/O $assign_s devnam=term, - chan=chan blbc r0, end ; Queue the I/O request $qiow_s chan=chan, - func=#io$_writevblk, - iosb=iosb, - p1=msg, - p2=#len ; Check the status and the IOSB status blbc r0, end movzwl iosb, r0 ; Return to operating system end: ret .end hello

=== RISC processor: ARM architecture, RISC OS, BBC BASIC s in-line assembler ===

.program ADR R0,message SWI OS_Write0 SWI OS_Exit .message DCS Hello, world! DCB 0 ALIGN

or the even smaller version (from qUE);

SWI OS_WriteS :EQUS Hello, world! :EQUB0:ALIGN:MOVPC,R14

== [http://www.autohotkey.com AutoHotkey] ==

MsgBox, Hello, World!

== [http://www.autoitscript.com AutoIt] ==

MsgBox(1, , Hello, world! )

== AWK programming language ==

BEGIN { print Hello, world! }

== Bash ==

echo Hello, world!

== BASIC programming language ==

=== General ===

The following example works for any ANSI/ISO-compliant BASIC implementation, as well as most implementations built into or distributed with microcomputers in the 1970s and 1980s (usually some variant of Microsoft BASIC):

10 PRINT Hello, world! 20 END

Such implementations of BASIC could also execute instructions in an immediate mode when line numbers are omitted. The following examples work without requiring a RUN instruction.

PRINT Hello, world! Hello, world!

Later implementations of BASIC allowed greater support for structured programming and did not require line numbers for source code. The following example works when RUN for the vast majority of modern BASICs.

PRINT Hello, world! END

Again, the END statement is optional in many BASICs.

=== PBASIC ===

DEBUG Hello, world! , CR

or, the typical microcontroller Hello World program equivalent with the only output device present being a light-emitting diode (LED) (in this case attached to the seventh output pin):

DO HIGH 7 Make the 7th pin go high (turn the LED on) PAUSE 500 Sleep for half a second LOW 7 Make the 7th pin go low (turn the LED off) LOOP END

=== StarOffice Basic ===

sub main print Hello, World end sub

=== TI-BASIC programming language ===

On Texas Instruments calculators of the TI-80 through TI-86 range:

:Disp HELLO, WORLD! or :Output(x,y, HELLO, WORLD! ) or :Text(x,y, HELLO, WORLD! ) or :Text(-1,x,y, HELLO, WORLD! ) ;only on the 83+ and higher

or simply : HELLO, WORLD!

On TI-89/TI-92(+)/Voyage 200 calculators:

:hellowld() :Prgm :Disp Hello, world! :EndPrgm

=== Visual Basic ===

Sub Main MsgBox Hello World! End Sub

=== Visual Basic .NET ===

Module HelloWorldApp Sub Main() System.Console.WriteLine( Hello, world! ) End Sub End Module

or, defined differently,

Class HelloWorldApp Shared Sub Main() System.Console.WriteLine( Hello, world! ) End Sub End Class

==== Blitz BASIC ==== Print Hello, World!

==== DarkBASIC ==== PRINT HELLO WORLD TEXT 0,0, Hello World WAIT KEY

== BCPL ==

GET LIBHDR LET START () BE $( WRITES ( Hello, world!*N ) $)

== BLISS programming language ==

%TITLE HELLO_WORLD MODULE HELLO_WORLD (IDENT= V1.0 , MAIN=HELLO_WORLD, ADDRESSING_MODE (EXTERNAL=GENERAL)) = BEGIN LIBRARY SYS$LIBRARY:STARLET ; EXTERNAL ROUTINE LIB$PUT_OUTPUT; GLOBAL ROUTINE HELLO_WORLD = BEGIN LIB$PUT_OUTPUT(%ASCID %STRING( Hello World! )) END; END ELUDOM

== boo programming language ==

== Casio fx-7950 ==

This program will work on the fx-9750 graphing calculator and compatibles.

HELLO WORLD ↵

== C programming language ==

#include int main(void) { printf( hello, world ); return 0; } or

#include #include int main(void) { puts( Hello, world! ); return EXIT_SUCCESS; }

== Ch interpreter ==

The above C code can run in Ch as examples. The simple one in Ch is:

printf( Hello, world );

== C Sharp programming language ==

See also #C# 2 . class HelloWorldApp { static void Main() { System.Console.WriteLine( Hello, world! ); } }

== C plus plus ==

#include int main() { std::cout

== Processing (programming language) ==

println( Hello world! );

== Prolog ==

write( Hello world ),nl.

== Python programming language ==

print Hello, world!

== REFAL ==

$ENTRY GO{=;}

== REXX, NetRexx, and Object REXX ==

say Hello, world!

== RPL programming language ==

== Ruby programming language ==

==SAS Institute==

data _null_; put Hello World! ; run;

== Sather ==

class HELLO_WORLD is main is #OUT+ Hello World ; end; end;

== Scala ==

object HelloWorld with Application { Console.println( Hello, world! ); }

== Scriptol ==

print Hello world!

== Sed ==

(note: requires at least one line of input)

sed -ne 1s/.*/Hello, world!/p

== Self programming language ==

Hello, World! print.

== Simula ==

BEGIN OutText( Hello World! ); OutImage; END

== Smalltalk programming language ==

Transcript show: Hello, world! ; cr

== SML programming language ==

print Hello, world! ;

== SNOBOL ==

OUTPUT = Hello, world! END

== Span programming language ==

class Hello { static public main: args { Console begin(); Widget *box = new Widget(20, 40, 260, 100, Hello, World! ); box->box(UP_BOX); box->labelfont(HELVETICA_BOLD_ITALIC); box->labelsize(36); box->labeltype(SHADOW_LABEL); window->end(); window->show(argc, argv); return run(); }

== Gambas ==

== GTK (in C++) ==

#include #include #include #include using namespace std; class HelloWorld : public Gtk::Window { public: HelloWorld(); virtual ~HelloWorld(); protected: Gtk::Button m_button; virtual void on_button_clicked(); }; HelloWorld::HelloWorld() : m_button( Hello, world! ) { set_border_width(10); m_button.signal_clicked().connect(SigC::slot(*this, &HelloWorld::on_button_clicked)); add(m_button); m_button.show(); } HelloWorld::~HelloWorld() {} void HelloWorld::on_button_clicked() { cout