?

Log in

No account? Create an account
обучение любому языку программирования начинается (по традиции) с… - Заметки на обоях — ЖЖ [entries|archive|friends|userinfo]
Офигевший Стоун

[ website | drcrasher.ru ]
[ userinfo | livejournal userinfo ]
[ archive | journal archive ]

[сент. 12, 2007|04:31 pm]
Офигевший Стоун
обучение любому языку программирования начинается (по традиции) с программы "hello world"

Программа "Hello world" на всех языках программирования


Програмистам будет интересно:

ABAP4

REPORT ZHB00001.
*Hello world in ABAP/4 *
WRITE: 'Hello world'.



Actionscript-Flash5

// Hello World in Actionscript (up to Flash 5, IDE only)

trace ("Hello World");



Actionscript-FlashMX

// Hello World in Actionscript (Flash MX onwards)

_root.createTextField("mytext",1,100,100,300,100);
mytext.multiline = true;
mytext.wordWrap = true;
mytext.border = false;

myformat = new TextFormat();
myformat.color = 0xff0000;
myformat.bullet = false;
myformat.underline = true;

mytext.text = "Hello World!";
mytext.setTextFormat(myformat);



Ada

-- Hello World in Ada

with TEXT_IO; use TEXT_IO;
procedure Hello is
pragma MAIN;
begin
PUT ("Hello World!");
end Hello;



Algol-60

'BEGIN'
'COMMENT' Hello World in Algol 60;
OUTPUT(4,'(''('Hello World!')',/')')
'END'



Algol-68

( # Hello World in Algol 68 # print(("Hello World!",newline)))



Amiga-E

-> Hello World in Amiga-E

PROC main() IS WriteF('Hello World\n')



APL

Hello World for APL. "[]" and "<-" are a single character in APL.
Comment character is Alt-comma.

[]<-'Hello World!'



AppleScript

Hello World in AppleScript

tell application "Finder"
display dialog "Hello World"
end tell



ASP-JavaScript

Hello World for Microsoft ASP (in JavaScript)

<%@ language="javascript" %>

<%
Response.Write('Hello World!');
%>




ASP-VBS

Hello World for Microsoft ASP (in VBScript)

<%@ language="vbscript" %>

<%
Response.write "Hello World!"
%>




Assembler-6502

; Hello World for 6502 Assembler (C64)

ldy #0
beq in
loop:
jsr $ffd2
iny
in:
lda hello,y
bne loop
rts
hello: .tx "Hello World!"
.by 13,10,0



Assembler-68000-Amiga

; Hello World in 68000 Assembler for dos.library (Amiga)

move.l #DOS
move.l 4.w,a6
jsr -98(a6) ;OldOpenLibrary
move.l d0,a6
beq.s .Out
move.l #HelloWorld,d1

A) moveq #13,d2
jsr -AE(a6) ;WriteChars

B) jsr -B4 ;PutStr

move.l a6,a1
move.l 4.w,a6
jsr -9E(a6) ;CloseLibrary
.Out rts

DOS dc.b 'dos.library',0
HelloWorld dc.b 'Hello World!',$A,0



Assembler-68000-AtariST

; Hello World in 68000 Assembler (Atari ST)

move.l #helloworld,-(A7)
move #9,-(A7)
trap #1
addq.l #6,A7
move #0,-(A7)
trap #1
helloworld:
dc.b "Hello World!",<#body#>d,<#body#>a,0



Assembler-68008

; Hello World in 68008 Assembler (Sinclar QL)

move.l #0,a0
lea.l mess,a1
move.w $d0,a2
jsr (a2)
rts
mess dc.w 12
dc.b 'Hello World!',10
end



Assembler-IBM-370

ITLE 'Hello World for IBM Assembler/370 (VM/CMS)'
HELLO START
BALR 12,0
USING *,12
*
WRTERM 'Hello World!'
*
SR 15,15
BR 14
*
END HELLO



Assembler-Intel

; Hello World for Intel Assembler (MSDOS)

mov ax,cs
mov ds,ax
mov ah,9
mov dx, offset Hello
int 21h
xor ax,ax
int 21h

Hello:
db "Hello World!",13,10,"$"



Assembler-PDP11

; Hello World in Assembler for the DEC PDP-11 with the
; RSX-11M-PLUS operating system
;
.title Hello
.ident /V0001A/
.mcall qiow$s, exit$s
.psect $code,ro,i
start: qiow$s #5,#5,,,,<#str, #len, #40>
exit$s
.psect $data,ro,d
str: .ascii / Hello World!/
len=.-str
.end start



Assembler-Z80-Console

; This is a "Hello World" program for Z80 and TMS9918 / TMS9928 / TMS9929 /
; V9938 or V9958 VDP.
; That means that this should work on SVI, MSX, Colecovision, Memotech,
; and many other Z80 based home computers or game consoles.
;
; Because we don't know what system is used, we don't know where RAM
; is, so we can't use stack in this program.
;
; This version of Hello World was written by Timo "NYYRIKKI" Soilamaa
; 17.10.2001
;
;----------------------------------------------------------------------
; Configure this part:

DATAP: EQU #98 ; VDP Data port #98 works on all MSX models
; (TMS9918/TMS9929/V9938 or V9958)
; #80 works on SVI
; (for other platforms you have to figure this out by your self)

CMDP: EQU #99 ; VDP Command port #99 works on all MSX models
; (TMS9918/TMS9929/V9938 or V9958)
; #81 works on SVI
; (for other platforms you have to figure this out by your self)
;-----------------------------------------------------------------------
; Program starts here:

ORG 0 ; Z80 starts always from here when power is turned on
DI ; We don't know, how interrupts works in this system, so we disable them.

; Let's set VDP write address to #0000
XOR A
OUT (CMDP),A
LD A,#40
OUT (CMDP),A

; Now let's clear first 16Kb of VDP memory
LD B,0
LD HL,#3FFF
LD C,DATAP
CLEAR:
OUT (C),B
DEC HL
LD A,H
OR L
NOP ; Let's wait 8 clock cycles just in case VDP is not quick enough.
NOP
JR NZ,CLEAR

; Now it is time to set up VDP registers:
;----------------------------------------
; Register 0 to #0
;
; Set mode selection bit M3 (maybe also M4 & M5) to zero and
; disable external video & horizontal interrupt
LD C,CMDP
LD E,#80

OUT (C),A
OUT (C),E
;----------------------------------------
; Register 1 to #50
;
; Select 40 column mode, enable screen and disable vertical interrupt

LD A,#50
INC E
OUT (C),A
OUT (C),E
;----------------------------------------
; Register 2 to #0
;
; Set pattern name table to #0000

XOR A
INC E
OUT (C),A
OUT (C),E
;----------------------------------------
; Register 3 is ignored as 40 column mode does not need color table
;
INC E
;----------------------------------------
; Register 4 to #1
; Set pattern generator table to #800

INC A
INC E

OUT (C),A
OUT (C),E
;----------------------------------------
; Registers 5 (Sprite attribute) & 6 (Sprite pattern) are ignored
; as 40 column mode does not have sprites

INC E
INC E
;----------------------------------------
; Register 7 to #F0
; Set colors to white on black

LD A,#F0
INC E
OUT (C),A
OUT (C),E
;----------------------------------------

; Let's set VDP write address to #808 so, that we can write
; character set to memory
; (No need to write SPACE it is clear char already)
LD A,8
OUT (C),A
LD A,#48
OUT (C),A

; Let's copy character set
LD HL,CHARS
LD B, CHARS_END-CHARS
COPYCHARS:
LD A,(HL)
OUT (DATAP),A
INC HL
NOP ; Let's wait 8 clock cycles just in case VDP is not quick enough.
NOP
DJNZ COPYCHARS

; Let's set write address to start of name table
XOR A
OUT (C),A
LD A,#40
OUT (C),A

; Let's put characters to screen
LD HL,ORDER
LD B,ORDER_END-ORDER
COPYORDER:
LD A,(HL)
OUT (DATAP),A
INC HL

JR OVERNMI
NOP
NOP

; Here is address #66, that is entry for NMI
RETN ;Return from NMI

OVERNMI:
DJNZ COPYORDER

; The end
HALT

; Character set:
; --------------
ORDER:
DEFB 1,2,3,3,4,0,5,4,6,3,7
ORDER_END:

CHARS:

; H
DEFB %10001000
DEFB %10001000
DEFB %10001000
DEFB %11111000
DEFB %10001000
DEFB %10001000
DEFB %10001000
DEFB %00000000
; e
DEFB %00000000
DEFB %00000000
DEFB %01110000
DEFB %10001000
DEFB %11111000
DEFB %10000000
DEFB %01110000
DEFB %00000000
; l
DEFB %01100000
DEFB %00100000
DEFB %00100000
DEFB %00100000
DEFB %00100000
DEFB %00100000
DEFB %01110000
DEFB %00000000
; o
DEFB %00000000
DEFB %00000000
DEFB %01110000
DEFB %10001000
DEFB %10001000
DEFB %10001000
DEFB %01110000
DEFB %00000000
; W
DEFB %10001000
DEFB %10001000
DEFB %10001000
DEFB %10101000
DEFB %10101000
DEFB %11011000
DEFB %10001000
DEFB %00000000

; r
DEFB %00000000
DEFB %00000000
DEFB %10110000
DEFB %11001000
DEFB %10000000
DEFB %10000000
DEFB %10000000
DEFB %00000000
; d
DEFB %00001000
DEFB %00001000
DEFB %01101000
DEFB %10011000
DEFB %10001000
DEFB %10011000
DEFB %01101000
DEFB %00000000
chars_end:



Assembler-ZX81

; Hello World in Assembler for the ZX81 (Zilog Z80)

CALL SPRINT
DEFM HELLO WORLD.
DEFB FF
RET
SPRINT POP HL
LD A,(HL)
INC HL
PUSH HL
CP FF
RET Z
CALL PRINT
JR SPRINT



AviSynth

Hello World for AviSynth Video Editor.
Requires AVI and WAV file.

video = AVISource("someoneSayingHelloWorld.avi")
sound_track = WAVSource("someoneSayingHelloWorld.wav")
AudioDub(video, sound_track)
subtitle("Hello World!")



awk

# Hello World in awk
BEGIN {
print "Hello World!"
exit
}



Axel

Hello World in AXEL (lip-synched speech)

... too large for this page, can be found here:
http://medieskolan.avc.edu.stockholm.se/axel/index.htm



B

/* Hello World in B */

main() {
extern a, b, c;
putchar (a); putchar (b); putchar (c); putchar ('!*n');
}

a 'hell' ;
b 'o, w' ;
c 'orld' ;



BAL

Hello World in IBM mainframe Basic Assembler Language (BAL)

HELLO CSECT
STM R14,R12,12(R13)
LR R12,R15
USING HELLO,R12
LA R10,SAVEAREA
ST R13,4(R10)
ST R10,8(R13)
LR R13,R10
*
WTO 'HELLO WORLD',ROUTCDE=1
*
L R13,4(R13)
LM R14,R12,12(R13)
SR R15,R15
BCR B'1111',R14
*
SAVEAREA DS 18F
LTORG
R0 EQU 0
R1 EQU 1
R2 EQU 2
R3 EQU 3
R4 EQU 4
R5 EQU 5
R6 EQU 6
R7 EQU 7
R8 EQU 8
R9 EQU 9
R10 EQU 10
R11 EQU 11
R12 EQU 12
R13 EQU 13
R14 EQU 14
R15 EQU 15
END HELLO



BASIC

10 REM Hello World in BASIC
20 PRINT "Hello World!"



bc

#!/usr/bin/bc -q
# Hello World for the Unix "bc" calculator

print "Hello World!\n"



BCPL

// Hello world in BCLP
GET "libhdr"

LET start() = VALOF
$( writes("Hello world*N")
RESULTIS 0
$)



Beta

{ *** Hello World in BETA ***}
(#
do
'Hello World!'->putLine
#)



BrainFxxx

Hello World in BrainF***, posted by Dmitri Katchalov <DMITRIK@MY-DEJA.COM>
on comp.lang.misc on Feb. 14, 2000.

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++.+++++++++++++++++++++++++++++.+++++++..+++.--------------
-----------------------------------------------------.-----------
-.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++.--------.+++.------.--------.-----------
--------------------------------------------------------.



BS2000

/BEGIN-PROCEDURE LOGGING=N
/REMARK "HELLO WORLD" IN BS2000 (SDF)
/ASSIGN-SYSDTA TO-FILE=*SYSCMD
/WRITE-TEXT 'HELLO WORLD!'
/SET-JOB-STEP
/ASSIGN-SYSDTA TO-FILE=*PRIMARY
/END-PROCEDURE



C++

// Hello World in C++

#include <IOSTREAM.H>

main()
{
cout << "Hello World!" << endl;
return 0;
}



C++-ISO

// Hello World in ISO C++

#include <IOSTREAM>

int main()
{
std::cout << "Hello World!" << std::endl;
}



C++-MFC

// Hello World in C++ for Microsoft Foundation Classes
// (Microsoft Visual C++).

#include <AFXWIN.H>

class CHello : public CFrameWnd
{
public:
CHello()
{
Create(NULL,_T("Hello World!"),WS_OVERLAPPEDWINDOW,rectDefault);
}
};

class CHelloApp : public CWinApp
{
public:
virtual BOOL InitInstance();
};

BOOL CHelloApp::InitInstance()
{
m_pMainWnd = new CHello();
m_pMainWnd->ShowWindow(m_nCmdShow);
m_pMainWnd->UpdateWindow();
return TRUE;
}

CHelloApp theApp;



C++-Qt

// Hello World in C++ for the Qt framework

#include <QAPPLICATION.H>
#include <QLABEL.H>

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QLabel l("Hello World!", 0);
l.setCaption("Test");
l.setAlignment(Qt::AlignCenter);
l.resize(300, 200);
a.setMainWidget(&l);
l.show();
return(a.exec());
}



C-Ansi

/* Hello World in C, Ansi-style */

#include <STDIO.H>
#include <STDLIB.H>

int main(void)
{
puts("Hello World!");
return EXIT_SUCCESS;
}



C-Curses

/* Hello World in C for Curses */

#include <CURSES.H>
main()
{
initscr();
addstr("Hello World!\n");
refresh();
endwin();
return 0;
}



C-GEM

/* Hello World for C with GEM */

#include <AES.H>
main()
{
appl_init();
form_alert(1,"[0][Hello World!][Ok]");
appl_exit();
return 0;
}



C-Intuition

/* Hello World in C for Intution (Amiga GUI) */

#include <INTUITION intuition.h>

struct IntuitionBase *IntuitionBase = NULL;

struct IntuiText hello_text = {-1,-1,JAM1,0,0,NULL,"Hello World!",NULL };
struct IntuiText ok_text = {-1,-1,JAM1,0,0,NULL,"Ok",NULL };

void main(void)
{
IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library", 0);
AutoRequest(NULL, &hello_text, NULL, &ok_text, NULL, NULL, 100, 50);
CloseLibrary(IntuitionBase);
}



C-K+R

/* Hello World in C, K&R-style */

main()
{
puts("Hello World!");
return 0;
}



C-Objective

/* Hello World in Objective-C.
** Since the standard implementation is identical to K&R C,
** a version that says hello to a set of people passed on
** the command line is shown here.
*/

#include <STDIO.H>
#include <OBJPAK.H>
int main(int argc,char **argv)
{
id set = [Set new];
argv++;while (--argc) [set add:[String str:*argv++]];
[set do:{ :each | printf("hello, %s!\n",[each str]); }];
return 0;
}



C-PresManager

/* Hello World for C with PresentationManager / OS/2 2.11 */

#define INCL_WIN

#include <OS2.H>

int main( void )
{
HMQ hmq;

hmq = WinCreateMsgQueue( 0, 0 );

WinMessageBox( HWND_DESKTOP, HWND_DESKTOP, (PSZ)"Hello World!",
(PSZ)"", 0, MB_OK );

WinDestroyMsgQueue( hmq );

return 0;
}



C-Sharp

// Hello World in Microsoft C# ("C-Sharp").

using System;

class HelloWorld
{
public static int Main(String[] args)
{
Console.WriteLine("Hello, World!");
return 0;
}
}



C-Windows

/* Hello world in C for MS-Windows */

#include <WINDOWS.H>

int PASCAL WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance, LPSTR CmdLine, int Show)
{
MessageBox(GetActiveWindow(), "Hello World!", "Hello Windows World", MB_OK);
return 0;
}



C-X11-Athena

/* Hello World in C with X11 using Athena widgets */

#include <X11 intrinsic.h>
#include <X11 stringdefs.h>
#include <X11 label.h xaw>

main(int argc,char **argv)
{
XtAppContext app_context;
Widget toplevel,hello;

toplevel = XtVaAppInitialize(&app_context,"XHello",NULL,0,
&argc,argv,NULL,NULL);
hello = XtVaCreateManagedWidget("Hello World!",labelWidgetClass,
toplevel,(void*)0);

XtRealizeWidget(toplevel);

XtAppMainLoop(app_context);
return 0;
}



CAML-Light

(* Hello World in CAML Light *)

let hello =
print_string "Hello World!";
;;



Clean

// Hello World in Clean

module hello

Start :: String
Start = "Hello World!\n"



Clipper

// Hello World in Clipper

@ "Hello World"



Cobol

* Hello World in Cobol

*****************************
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
MAIN SECTION.
DISPLAY "Hello World!"
STOP RUN.
****************************



CommandScript

#Hello World in Command Script 3.1
#Meta.Name: "Hello World"

#Block(Main).Start
echo "Hello World!"
#Block(Main).End



D

// Hello World in D

void main()
{
printf("Hello World!\n");
}



dBase

* Hello World in dBase IV

? "Hello World!"



dc

#!/usr/bin/dc
# Hello world! in dc (Unix desk calculator)
[Hello world!]p



Delphi

// Hello World in Delphi
Program Hello_World;

{$APPTYPE CONSOLE}

Uses
Dialogs;

Begin
WriteLn('Hello World');
End.



Dylan

module: hello-world
author: Homer
copyright: (c) 1994 Homer
version: 1.0

// Hello World in DYLAN

define method main (#rest args)
princ("Hello world!");
end;

main();



DynaMorph

<<!! Hello World in DynaMorph >>
<#setString foo {Hello World!}#>





<#getString foo#>





Eiffel

indexing "Hello World in Eiffel"

class HELLO

creation
run

feature

run is
local
io : BASIC_IO;
do
!!io;
io.put_string("Hello World!");
io.put_newline;
end; -- run

end; -- class HELLO



Elan

(* Hello World in ELAN *)

putline ("Hello World!");



Erlang

%% Hello World in Erlang

-module(hello).

-export(hello/0).

hello() ->
io.format("Hello World!\n").



Euphoria

-- Hello World in Euphoria

procedure Hello()

print ("Hello World!")

end procedure



Focal

1.01 COMMENT HELLO WORLD IN FOCAL
1.02 TYPE "HELLO WORLD", !
1.03 QUIT



Forth

: Hello World in Forth
." Hello World!" cr
;



Fortran

C Hello World in Fortran

PROGRAM HELLO
WRITE (*,100)
STOP
100 FORMAT (' Hello World! ' /)
END



Fortran77

C Hello World in Fortran 77

PROGRAM HELLO
PRINT*, 'Hello World!'
END



FortranIV

PROGRAM HELLO
c
C Hello World in Fortran IV (supposedly for a TR440)
c
WRITE (6,'('' Hello World!'')')
END



Frink

// Hello World in Frink

println["Hello World!"]



Gofer

-- Hello World in Gofer
-- Simple version

helloWorld:: String
helloWorld = "Hello World!\n"


-- Hello World in Gofer
-- Dialog version

helloWorld :: Dialogue
helloWorld resps = [AppendChan stdout "Hello world!"]



GynkoSoft

; Hello World in GynkoSoft
; Simple version
0.00 Protocol "Hello, World!"


; Hello World in GynkoSoft
; Dialog box output
0.00 Message "Hello, World!"



Haskell

-- Hello World in Haskell

module Hello where
hello::String
hello = "Hello World!"



HDX

# Hello World as bdehaldia.exe external command

proc hdx_info {} {
set ::Titel "&Hello World"
set ::Menu GMA
}

proc hdx_run {} {
tk_messageBox -type ok -message "Hello World!"
destroy .
}



HP-41C

Hello World for the HP 41C. No comment character exists.

01 LBL "HELLO"
02 "HELLO WORLD"
03 AVIEW



HP-48

<<
@ Hello World for the HP-48
@ << and >> are one char each
"HELLO WORLD"
>>



HTML


<!-- Hello World in HTML -->




Hello World!





Human

Hello World in human languages.

Czech (1): Ahoj, svete!
Bengali: Shagatam Prithivi!
Brazilian Portuguese: Oi mundo!
Dutch: Hallo, wereld!
English: Hello World!
French: Salut le Monde!
Frisian: Hallo, wrвld!
German: Hallo Welt!
Hindi: Shwagata Prithvi!
Italian: Ciao Mondo!
Norwegian: Hallo Verden!
Portuguese: Ola mundo!
Spanish (2): !Hola mundo!
Swedish: Hejsan vдrld!
Turkish: Merhaba Dьnya!

(1) Upside-down "^" on the first "e"
(2) First "!" upside-down



IBM-Exec

Hello World for IBM EXEC (under VM/CMS)

&CONTROL
*
&TYPE Hello World!
*
&EXIT 0



IBM-Exec2

Hello World for IBM EXEC2 (under VM/CMS)

&TRACE OFF
*
&TYPE Hello World!
*
&EXIT 0



ici

# Hello World in ici (http://www.zeta.org.au/~atrn/ici/)
printf("Hello World!\n");



Icon

# Hello world in Icon (http://www.cs.arizona.edu/icon/)

procedure main()
write("Hello world")
end



Informix-4GL

# Hello World in Informix 4GL

MAIN

DISPLAY "Hello World"

END MAIN



InstallScript

// Hello World in InstallScript
// (Scripting language of InstallShield, a Windows install generator)

program
MessageBox("Hello World!",INFORMATION);
endprogram



Intercal

HELLO WORLD IN INTERCAL NOT FORTRAN

HELLO WORLD



Java

// Hello World in Java

class HelloWorld {
static public void main( String args[] ) {
System.out.println( "Hello World!" );
}
}



Java-Mobile

// Hello World on a mobile Java device

package helloworld;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class HelloWorld extends MIDlet {

public HelloWorld()
{
Form form = new Form("Hello World");
form.append("Hello world!");
Display.getDisplay(this).setCurrent(form);
}

protected void pauseApp() { }
protected void startApp() throws
javax.microedition.midlet.MIDletStateChangeException { }
protected void destroyApp(boolean parm1) throws
javax.microedition.midlet.MIDletStateChangeException { }
}



Java-Server-Pages

<!-- Hello World for Java Server Pages -->

<%@ page language='java' %>
<%="Hello World!" %>



Java-Servlet

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

//
// Hello World Java Servlet
//
public class HelloWorld extends HttpServlet {
public void service(HttpServletRequest request,
HttpServletResponse response)
throws IOException {

response.setContentType("text/html");
PrintWriter out = response.getWriter();

out.println("");
out.println("Hello World!");
out.println("");
}
}



Java-Swing

// Hello World in Java using Swing GUI

class HelloWorldSwing {
static public void main(String args[]) {
javax.swing.JOptionPane.showMessageDialog(null,"Hello world!");
}
}



JavaScript



<SCRIPT language=JavaScript type=text/javascript>
// Hello World in JavaScript
document.write('Hello World');
</SCRIPT>





JCL

//HERIB JOB ,'HERIBERT OTTEN',PRTY=12
//* Hello World for MVS
//HALLO EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSUT2 DD SYSOUT=T
//SYSUT1 DD *
Hello World!
/*
//



JudoScript

// Hello World in JudoScript (a Java scripting layer)

. "Hello World";



Limbo

Hello World in Limbo.
Limbo is the programming language of the Inferno OS
(from Lucent Bell Labs).


implement Cmd;

include "sys.m";
include "draw.m";

Cmd : module {
init : fn (ctxt : ref Draw->Context, args : list of string);
};

init(nil : ref Draw->Context, nil : list of string)
{
sys := load Sys Sys->PATH;
sys->print("Hello World\n");
}



Lingo

Hello World in Lingo (Macromedia Director)

on startmovie
alert "Hello World"
end



Lisp

;;; Hello World in Common Lisp

(defun helloworld ()
(print "Hello World!")
)



Logo

; Hello World in Logo

DRUCKEZEILE [Hello World!]



Logo-graphical

; Hello World in LOGO, graphical output.

go 20 , left 180,
go 40 , left 180,
go 20 , right 90,
go 20 , left 90 ,
go 20 , left 180,
go 40 , left 90 ,
go 20 , left 90 ,
go 20 , right 90 ,
go 20 , right 90 ,
go 10 , right 90 ,
go 20 , left 90 ,
go 10 , left 90 ,
go 30 , left 90 ,
go 40 , left 180,
go 40 , left 90 ,
go 20 , left 90 ,
go 40 , left 180,
go 40 , left 90 ,
go 40 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 60 , left 90 ,
go 40 , left 180,
go 40 , left 90 ,
go 20 , left 90 ,
go 20 , left 180,
go 20 , left 90 ,
go 20 , left 90 ,
go 40 , left 180,
go 40 , left 90 ,
go 40 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 40 , left 90 ,
go 20 , right 90,
go 20 , right 90,
go 5 , left 90 ,
go 5 , left 90 ,
go 25 , left 180,
go 40 , left 90 ,
go 40 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 20 , left 90 ,
go 40 , left 180,
go 40 ,



lua

# Hello World in lua

print "Hello world"



MACRO10

TITLE HELLO WORLD
; HELLO WORLD IN MACRO 10 FOR TOPS-10
ENTRY OUTPUT
SEARCH UUOSYM

LAB: ASCIZ /HELLO WORLD
/
OUTPUT: OUTSTR LAB ; OUTPUT MESSAGE
MONRT. ; RETURN TO MONITOR
END OUTPUT



Mathematica

(* Hello World in Mathematica *)

Hello[] := Print["Hello, World!"]



mIRC

; Hello World! for mIRC

echo Hello World!



Modula-2

(* Hello World in Modula-2 *)

MODULE HelloWorld;
FROM InOut IMPORT WriteString,WriteLn;
BEGIN
WriteString("Hello World!");
WriteLn;
END HelloWorld.



MSDOS

@ECHO OFF
REM Hello World for DOS batch

ECHO Hello World!



MSIL

//Hello World in MSIL (.NET assembler)

.assembly helloworld {}
.class helloworld
{
.method static void Main() cil managed
{
.entrypoint
ldstr "Hello World!"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
}



Mumps

; Hello World in Mumps-M
w !,"Hello World"



Natural

* Hello World in Natural (by Software AG)
FORMAT AD=M
DISPLAY 'Hello World!'
END




NewtonScript

// Hello World in NewtonScript

baseview :=
{viewBounds: {left: -3, top: 71, right: 138, bottom: 137},
viewFlags: 581,
declareSelf: 'base,
_proto: protoFloatNGo,
debug: "baseview"
};

textview := * child of baseview *
{text: "Hello World!",
viewBounds: {left: 33, top: 24, right: 113, bottom: 46},
viewFlags: 579,
_proto: protoStaticText,
debug: "textview"
};



Oberon.oberon

MODULE HelloWorld;

(* Hello World in Oberon for the Oberon System *)

IMPORT Oberon, Texts;

VAR
W: Texts.Writer;

PROCEDURE Do*;
BEGIN
Texts.WriteString(W,"Hello World!");
Texts.WriteLn(W);
Texts.Append(Oberon.Log,W.buf)
END Do;

BEGIN Texts.OpenWriter(W)
END HelloWorld.



Oberon.std

(* Hello World in Oberon for standard operating systems *)

MODULE HelloWorld;
IMPORT Out;
BEGIN
Out.String("Hello World!");
Out.Ln;
END HelloWorld;



OCaml

(* Hello World in OCaml *)

print_string "Hello World!\n";;



Occam

PROGRAM Hello
-- Hello world in Occam
#USE ioconv

SEQ
write.full.string(screen,"Hello World!")



Octave

#Hello World in Octave (http://www.octave.org/)
printf("Hello World\n");



OpenVMS

$! Hello World in OpenVMS DCL

$ write sys$output "Hello World"



OPL.dialog

REM Hello World for OPL (Psion Organizer 3a)
REM More complex version with menues and dialog boxes

PROC HELLO:
LOCAL M%
DO
REM Display menu bar
mINIT
mCARD "Sprache","Deutsch",%d,"English",%e
mCARD "Extras","Beenden",%x,"Info",%i
M%=MENU
REM process choosen function
IF M%=%d
REM Display german dialog box
REM with an ENTER button to continue
dBOX:(" ","Hallo Welt"," ","weiter",13)
ELSEIF M%=%e
REM Display english dialog box
REM with an ENTER button to continue
dBOX:(" ","Hello World"," ","continue",13)
ELSEIF M%=%i
REM Display copyright information ;-)
dBOX:("Info","(C) Klaus Mьller 0196","FrankfurtMain, Germany","",13)
ENDIF
UNTIL M%=%x
ENDP

PROC dBOX:(Z1$,Z2$,Z3$,Z4$,BUTTON%)
dINIT Z1$
dTEXT ""," ",0
dTEXT "",Z2$",2
dTEXT "",Z3$,2
dBUTTONS Z4$,BUTTON%
DIALOG
ENDP



OPL.simple

REM Hello World for OPL (Psion Organizer 3a)
REM Simple version

PROC HELLO:
PRINT "Hello World!"
GET
ENDP



OZ

Hello World in OZ, shell version:

Type the text
{Browse 'Hello World!'}
to a buffer in OZ mode and feed it for execution (e.g., by typing the
key M-l or by using the OZ menu). A window titled Oz Browser will pop
up showing the atom 'Hello World!'.



Pascal

{Hello World in Pascal}

program HelloWorld(output);
begin
WriteLn('Hello World!');
end.



Pascal-Windows

{ Hello World in Borland Pascal 7 for MS-Windows}

PROGRAM HelloWorld;

USES
WinCRT;

BEGIN
InitWinCRT;
WriteLn('Hello World!');
ReadLn;
DoneWinCRT;
END.



Perl

# Hello world in perl

print "Hello World!\n";



PHP





Pike

// Hello world in Pike (pike.roxen.com)

int main(){
write("Hello World!\n");
}



PL-SQL

-- Hello World in Oracle PL/SQL

set serveroutput on
Declare
txt varchar2(11);
begin
txt:='Hello World';
dbms_output.put_line(txt);
end;
/



PL1

/* Hello World in PL1 */

Hello: procedure options(main)
put list('Hello World!');
put skip;
end Hello



Pocket

Hello World for standard pocket calculators (7-segment display).
Type in and turn calculator upside down.

07734



POP-11

;;; Hello World in POP-11

: vars outputtext;
: "Hello World" -> outputtext;
: outputtext =>

** Hello World



Postscript

% Hello World in Postscript
%!PS
/Palatino-Roman findfont
100 scalefont
setfont
100 100 moveto
(Hello World!) show
showpage



POV-Ray

// Hello World for the Persistence of Vision Raytracer

#include "skies.inc"

camera{location <0,1,-5> look_at y}
light_source{<2,4,-7>,2}
sky_sphere{S_Cloud1}
plane{y 0 pigment{checker rgb 1,0} finish{reflection .5}}
text{ttf "timrom.ttf" "Hello World!" .3,0
pigment {agate scale .2} translate -2.5*x
}



Profan

' Hello World in Profan (http://www.profan.de/)

cls
print "Hello World!"
waitkey



Progress

/* Hello World in Progress */

message "Hello World" view-as alert-box.



Prolog

% Hello World in Prolog

hello :- display('Hello World!') , nl .



PureBasic-Console

; Hello World in PureBasic (console program)

OpenConsole()
ConsoleTitle ("Hello World!")
PrintN ("Hello World!")
CloseConsole()



PureBasic-Messagebox

; Hello World in PureBasic (message box)

MessageRequester("Hello World Messagebox","Hello World!")



PureBasic-Window

; Hello World in PureBasic (Window)

If OpenWindow(0, 216, 0, 268, 133, #PB_Window_SystemMenu | #PB_Window_TitleBar | #PB_Window_ScreenCentered , "Hello World Window")
If CreateGadgetList(WindowID())
TextGadget(1, 100, 60, 60, 20, "Hello World!")
EndIf
EndIf

Repeat ; Message Loop
Until WaitWindowEvent() = #PB_EventCloseWindow



Python

# Hello World in Python
print "Hello World"



QuickBASIC

REM Hello World in QuickBASIC
PRINT "Hello World!"
END



ratfor

# hello.world
# ratfor
print *, 'hello, world'
end



REALbasic

' Hello World in REALbasic (http://www.realsoftware.com/)

msgBox "Hello World!"



Rebol-view

Hello World in Rebol-view.

rebol[]
view layout[
text "Hello World!"
]



Redcode

; Hello World in Redcode
; Should work with any MARS >= ICWS-86
; (with 128x64 gfx core support, of course!)
;
Start MOV 0,2455
MOV 0,2458
MOV 0,2459
MOV 0,2459
MOV 0,2459
MOV 0,2459
MOV 0,2459
MOV 0,2460
MOV 0,2465
MOV 0,2471
MOV 0,2471
MOV 0,2471
MOV 0,2479
MOV 0,2482
MOV 0,2484
MOV 0,2484
MOV 0,2484
MOV 0,2486
MOV 0,2486
MOV 0,2486
MOV 0,2486
MOV 0,2488
MOV 0,2493
MOV 0,2493
MOV 0,2493
MOV 0,2493
MOV 0,2497
MOV 0,2556
MOV 0,2559
MOV 0,2560
MOV 0,2565
MOV 0,2570
MOV 0,2575
MOV 0,2578
MOV 0,2585
MOV 0,2588
MOV 0,2589
MOV 0,2592
MOV 0,2593
MOV 0,2596
MOV 0,2597
MOV 0,2603
MOV 0,2605
MOV 0,2608
MOV 0,2667
MOV 0,2670
MOV 0,2671
MOV 0,2676
MOV 0,2681
MOV 0,2686
MOV 0,2689
MOV 0,2696
MOV 0,2699
MOV 0,2700
MOV 0,2703
MOV 0,2704
MOV 0,2707
MOV 0,2708
MOV 0,2714
MOV 0,2716
MOV 0,2719
MOV 0,2778
MOV 0,2778
MOV 0,2778
MOV 0,2778
MOV 0,2778
MOV 0,2779
MOV 0,2779
MOV 0,2779
MOV 0,2782
MOV 0,2787
MOV 0,2792
MOV 0,2795
MOV 0,2802
MOV 0,2805
MOV 0,2806
MOV 0,2809
MOV 0,2810
MOV 0,2810
MOV 0,2810
MOV 0,2810
MOV 0,2812
MOV 0,2818
MOV 0,2820
MOV 0,2823
MOV 0,2882
MOV 0,2885
MOV 0,2886
MOV 0,2891
MOV 0,2896
MOV 0,2901
MOV 0,2904
MOV 0,2911
MOV 0,2912
MOV 0,2913
MOV 0,2914
MOV 0,2917
MOV 0,2918
MOV 0,2919
MOV 0,2922
MOV 0,2928
MOV 0,2930
MOV 0,2933
MOV 0,2992
MOV 0,2995
MOV 0,2996
MOV 0,3001
MOV 0,3006
MOV 0,3011
MOV 0,3014
MOV 0,3021
MOV 0,3022
MOV 0,3023
MOV 0,3024
MOV 0,3027
MOV 0,3028
MOV 0,3030
MOV 0,3032
MOV 0,3038
MOV 0,3040
MOV 0,3103
MOV 0,3106
MOV 0,3107
MOV 0,3107
MOV 0,3107
MOV 0,3107
MOV 0,3107
MOV 0,3108
MOV 0,3108
MOV 0,3108
MOV 0,3108
MOV 0,3108
MOV 0,3109
MOV 0,3109
MOV 0,3109
MOV 0,3109
MOV 0,3109
MOV 0,3111
MOV 0,3111
MOV 0,3111
MOV 0,3120
MOV 0,3121
MOV 0,3124
MOV 0,3124
MOV 0,3124
MOV 0,3126
MOV 0,3129
MOV 0,3130
MOV 0,3130
MOV 0,3130
MOV 0,3130
MOV 0,3130
MOV 0,3131
MOV 0,3131
MOV 0,3131
MOV 0,3131
MOV 0,3135
JMP 0



Rexx

/* Hello World in Rexx */

SAY "Hello World!"



Rexx.simple

/* Hello World in Rexx, simple version (writes to standard output) */

say 'Hello World!'
exit



Rexx.window

/* Hallo World in Rexx, opens window */

call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
call SysLoadFuncs
call RxMessageBox 'Hello World!', 'Hello World Window', 'OK', 'EXCLAMATION'
exit



Ruby

# Hello World in Ruby
STDOUT << "Hello World!"



SAL

// Hello World in SAL

proc main()
MsgBox("Hello from SAL", "Hello, World!")
end



Sather

-- Hello World in Sather

class HELLO is
main is #OUT + "Hello World!\n" end
end



Scheme

;;; Hello World in Scheme

(define helloworld
(lambda ()
(display "Hello World")
(newline)))



Self

(| "Hello World in Self"

hello = (| | 'Hello World!' print)
|)



SenseTalk

Hello World in SenseTalk.

on run put "Hello World!" end run



Setl2

-- Hello World in Setl2

procedure Hello();
print "Hello World!";
end Hello;



Shakespeare

The Infamous Hello World Program in Shakespeare.

Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.


Act I: Hamlet's insults and flattery.

Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet:
You lying stupid fatherless big smelly half-witted coward!
You are as stupid as the difference between a handsome rich brave
hero and thyself! Speak your mind!

You are as brave as the sum of your fat little stuffed misused dusty
old rotten codpiece and a beautiful fair warm peaceful sunny summer's
day. You are as healthy as the difference between the sum of the
sweetest reddest rose and my father and yourself! Speak your mind!

You are as cowardly as the sum of yourself and the difference
between a big mighty proud kingdom and a horse. Speak your mind.

Speak your mind!

[Exit Romeo]

Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
Thou art as sweet as the sum of the sum of Romeo and his horse and his
black cat! Speak thy mind!

[Exit Juliet]

Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
Thou art as lovely as the product of a large rural town and my amazing
bottomless embroidered purse. Speak thy mind!

Thou art as loving as the product of the bluest clearest sweetest sky
and the sum of a squirrel and a white horse. Thou art as beautiful as
the difference between Juliet and thyself. Speak thy mind!

[Exeunt Ophelia and Hamlet]


Act II: Behind Hamlet's back.

Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
Speak your mind. You are as worried as the sum of yourself and the
difference between my small smooth hamster and my nose. Speak your
mind!

Juliet:
Speak YOUR mind! You are as bad as Hamlet! You are as small as the
difference between the square of the difference between my little pony
and your big hairy hound and the cube of your sorry little
codpiece. Speak your mind!

[Exit Romeo]

Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
Thou art as good as the quotient between Romeo and the sum of a small
furry animal and a leech. Speak your mind!

Ophelia:
Thou art as disgusting as the quotient between Romeo and twice the
difference between a mistletoe and an oozing infected blister! Speak
your mind!

[Exeunt]



SIMPLE

[::PROGRAM:Hello World program in SIMPLE
A EQL @0
MSG A
END
]
{::DATA:Data part
@0:T
Hello World$$M
$$@
}



Simula

! Hello World in Simula;

BEGIN
OutText("Hello World!");
OutImage;
END



Smalltalk.simple

"Hello World in Smalltalk (simple version)"

Transcript show: 'Hello World!'.



Smalltalk.window

"Hello World in Smalltalk (in an own window)"
"(to be entered in a special browser)"

VisualComponent subclass: #HelloWorldView
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'test'

displayOn: aGraphicsContext

'Hello World!' asComposedText displayOn: aGraphicsContext.

open

|window|
window := ScheduledWindow new.
window label: 'Hello World Demo:'.
window component: self new.
window open.



SML

(* Hello World in SML *)

fun hello() = output(std_out, "Hello World!");



Snobol

* Hello World in Snobol

OUTPUT = "Hello World!"



Spiral

Hello World in Spiral. No comment character exists.

e0v *** *eXlv** *lX *2X **oXi
v * * * * * * 2 * o ** v*
* * * * * ***** * v * v * *iX *
* * * * * * * ^ v * * * w *
* *** * * ***** * v * * * * v *
* * * ^ * ^ * * * * * *
* *** * * ****v * v * * v * * *
* * * * * * * * * * ^ * * *
* * * * * ***** * ***** * ***** * *** *
* * * * * * * * * * ** **
*** *** ******* *****v^ ******* *****

*wX *** **3Xp *rX4.. d5* qd**
* 3 * * ** v^ * .. * * * ***
* v * ^ * #pX v * .. . * * * **
* *** v * # r # * .. . * * * !q* *
* * * * * # v # * 54 .. * * * * * *
* * * * * # * # * @X * * * * * *
* * * * * # * # * v * * * * * *
* * * * * # * # * * ** * * * * * *
* * * * # * # * ** ** * * * *** *
* * * * #v* ^ * *** * * ***** * **
** * ** ** *v * * * * * * * ***
***** *v^** *** *** ******* ****



SPL

HELLO: PROCEDURE OPTIONS(MAIN);
*
/* Hello World in SPL4 (Siemens) */
*
DCL PRINTC ENTRY;
*
CALL PRINTC('Hello World!', 12);
RETURN;
*
END HELLO;



SQL-Advantage

-- Hello World in SQL for Advantage Database

select 'Hello World" from system.iota



SQL-Oracle

# Hello World in SQL for Oracle

SELECT 'Hello World' FROM dual;



SQL

# Hello World in SQL

SELECT 'Hello World';



ST-Guide

## Hello World for ST-Guide

@node "Hello World!"

Hello World!

@endnode



TAL

! Hello world in Tandem TAL (Transaction Application Language)
proc Hello^World main;
begin
int .term[0:12] := [ 12 * [ “ “ ] ],
.out [0:19];
string .sout := @out ‘<<’ 1, .sp;

call myterm ( term[1] );
call open ( term[1], term );
if <> then call abend;

sout ‘:=’ “Hello World” -> @sp;
call write ( term, out, @sp’-‘@sout );
if <> then call abend;
end;



Tcl

#!/usr/local/bin/tclsh
# Hello World in Tcl

puts "Hello World!"



TeX

% Hello World in plain \TeX
\immediate\write16{Hello World!}
\end



Texinfo

\input texinfo
@c Hello World for Texinfo

@setfilename hello
@settitle Hello World

@node Top, Hello, (dir), (dir)

@menu
* Hello:: Hello World
@end menu

@node Hello, , Top, Top

Hello World!

@contents
@bye



TI-59

Hello World for the TI-59 with PC-100C thermo printer.
No comment character exists.

The TI-59/PC-100C can print up to 20 characters per line (upper case
only). They are coded as 2-digit decimal numbers (see manual for
details) in up to four print registers (of five characters each)
and then printed.
Before entering the program, press LRN to switch into learn mode.
After entering the program, cancel learn mode with LRN, turn on the
printer, and run the program with A.
A pleasant sound, and what a font! Real TRUE-TYPE!

The output looks like this:

+--------------------+
| HELLO WORLD!|
| |
+--------------------+


TI59 Code Comment

LBL A Start of program: label A
OP 00 Clear the four print registers
23 "H"
OP 02 Write into print register 2
17 "E"
27 "L"
27 "L"
32 "O"
00 " "
OP 03 Write into print register 3
43 "W"
32 "O"
35 "R"
27 "L"
16 "D"
73 "!"
OP 04 Write into print register 4
OP 05 Start printing
ADV Line feed (optional)
R/S End program



TI-8x

Hello World for TI 8x/9x basic (tested on a TI-83)

:ClrHome
:Disp "HELLO WORLD"



Tk

#!/usr/local/bin/wish -f
# Hello World in Tk

label .l -text "Hello World!"
pack .l



TSO-CLIST

PROC 0
/* Hello World in TSO CLIST */
write Hello World!



Turing

Hello World as a Turing machine.

State Read | Write Step Next state
---------------|---------------------------------
1 empty | H > 2
2 empty | e > 3
3 empty | l > 4
4 empty | l > 5
5 empty | o > 6
6 empty | blank > 7
7 empty | W > 8
8 empty | o > 9
9 empty | r > 10
10 empty | l > 11
11 empty | d > 12
12 empty | ! > STOP



Unix-Shell

# Hello World for the Unix shells (sh, ksh, csh, bash, ...)

echo "Hello World!"



UnrealScript

// Hello World for UnrealScript

class HelloWorldHUD extends HudBase;

simulated function DrawHudPassC (Canvas C)
{
C.SetPos( 0.50*C.ClipX , 0.50*C.ClipY);
C.DrawText("Hello World!");
}

defaultproperties
{
}



Vatical

+ Hello World in Vatical

LITURGY:
PRAY "Hello World!"
AMEN.



VAX-Macro

Hello World in VAX Macro.

.title helloworld
.ident /hello world/
;
.library /sys$library:lib/
$libdef
$lib$routinesdef


.psect $data,wrt,noshr,noexe,long

hello: .ascid /Hello World!/

.psect $code,nowrt,shr,exe,long

.entry helloworld,^m<R9,R10,R11>

pushaq hello ; output the
message
calls #1,g^lib$put_output ;

ret ; GTFOH
.end helloworld ;



Verilog

/* Hello World in Verilog. */

module main;

initial
begin
$display("Hello, World");
$finish ;
end

endmodule



VisualBasic

REM Hello World in Visual Basic for Windows

VERSION 2.00
Begin Form Form1
Caption = "Form1"
ClientHeight = 6096
ClientLeft = 936
ClientTop = 1572
ClientWidth = 6468
Height = 6540
Left = 876
LinkTopic = "Form1"
ScaleHeight = 6096
ScaleWidth = 6468
Top = 1188
Width = 6588
Begin Label Label1
Caption = "Hello World!"
Height = 372
Left = 2760
TabIndex = 0
Top = 2880
Width = 972
End
End
Option Explicit



VMS

$ ! Hello World for VMS-CLI

$ WRITE SYS$OUTPUT "Hello World!"



VRML

#VRML V2.0 utf8
# Hello World in VRML

Shape
{
geometry Text
{string "Hello World!"}
}



Whitespace

Hello #World #in #Whitespace * # # * # # #
+ *[Space]
+ #is #marked #with"#" # #[tab] #with"*" *line-feed #with #"+" * # *so
+it #would
+be #easier #to #write #again... #All *the *non-whitespace-characters #are *ignored... * # #
+ *
+ # # # # # * * # * * # #
+ *
+ # # # # # * * # * * * *
+ *
+ # # # # # * # # # # #
+ *
+ # # # # # * # * # * * *
+ *
+ # # # # # * * # * * * *
+ *
+ # # # # # * * * # # * #
+ *
+ # # # # # * * # * * # #
+ *
+ # # # # # * * # # * # #
+ *
+ # # # # # * # # # # *
+ *
+ # # # # # * # * #
+ *
+ # #
+
+
+



XHTML


"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<!-- Hello World in XHTML -->





<P>
Hello World!
</P>





XML



<!-- Hello World in XML -->
<TEXT><STRING>Hello, World</STRING></TEXT>



XSL-FO


<!-- Hello World in XSL-FO -->
<?xml:namespace prefix = fo /><fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master page-height="11in" page-width="8.5in" master-name="LetterPage">?
<fo:region-body margin="0.7in" region-name="PageBody"></fo:region-body>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="LetterPage">
<fo:flow flow-name="PageBody">
<fo:block font-family="courier" font-size="12pt">Hello, World</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>



XSLT


<!-- Hello World in XSLT -->
<?xml:namespace prefix = xsl /><xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="/">
<xsl:value-of select="text/string"></xsl:value-of>
</xsl:template>
</xsl:stylesheet>select="text/string" /> </xsl:template></xsl:stylesheet><PRE></PRE>
СсылкаОтветить

Comments:
[User Picture]From: 911_sobaka
2007-09-12 12:35 pm
Ай, маладца!
(Ответить) (Thread)
[User Picture]From: di_roll
2007-09-12 12:48 pm
У тебя там текст повторяется...

А вообще всплакнул =)
(Ответить) (Thread)
[User Picture]From: drcrasher
2007-09-12 12:55 pm
исправил, спасиб...

я тут над фокалом утирал скупую мужскую слезу...
(Ответить) (Parent) (Thread)
[User Picture]From: alena_mironova
2007-09-12 01:30 pm
бляяяяяя....
полфирмы рыдает...
(Ответить) (Thread)
From: migmit
2007-09-12 09:16 pm
Haskell:

module Hello where
main = putStrLn "Hello world!"

А не так, как у тебя.
(Ответить) (Thread)
[User Picture]From: sysmanone
2007-09-22 07:39 am
Или:

OpenVMS

$create hw.com

$ type sys$input
Hello World!
$ eod


$ @hw.com
(Ответить) (Parent) (Thread)