Her dilde "Hello World!"

"Hello World!" / "Merhaba Dünya!"

18 senedir, öğrenmeye başladığım her programlama dilinde, ekrana "Hello World!" yazdıran bir program ile mutlaka karşılaşmışımdır.

Geçen aklıma geldi. Ufak bir Google taraması yaptım ve güzel bir site ile karşılaştım.

Bilmem kaç dilde (sayamadım tek tek ) ekrana "Hello World!" yazdıran programcıkları ben de kendi sayfamdan yayınlayayım dedim. 

Buradan buyrun:

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

---

A

4GL

message "Hello, World!" with style = popup;

Abap

WRITE 'Hello, World!'.

Abc

WRITE "Hello, World!"

ActionScript

trace("Hello, World!");

Graphical version:

this.createTextField("hello_txt",0,10,10,100,20);
this.hello_txt.text="Hello, World!";

Ada

with TEXT_IO;

procedure HELLO is
begin
 TEXT_IO.PUT_LINE ("Hello, World!");
end HELLO;

Algol 60

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

Algol 68

BEGIN

print(("Hello, World!", newline))

END

Using the short form of begin and end:

( print("Hello, World!") )

Alma-0

Hello, World!

AmigaE

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

Apl

'Hello, World!'

AppleScript

return "Hello, World!"

or:

-- "Hello World!"

Graphical:

display dialog "Hello World!" buttons {"OK"} default button 1

Ascii

In hexadecimal notation (0D = carriage return, 0A = newline):

48 65 6C 6C 6F 2C 20 77 6F 72 6C 64 21 0D 0A

Asp

<%
Response.Write("Hello, World!")
%>

or

<%="Hello, World!" %>

Asp.Net

Response.Write("Hello, World!")

AspectJ

public aspect HelloWorld 
{
 pointcut mainCall() : call(public static void *.main(String[] args));
 before() : mainCall() 
 {
 System.out.println( "Hello World!" );
 }
}

Assembly language

6502 assembler

MSG: .ASCIIZ "Hello, World!"
START: LDX #0
LOOP: LDA MSG,X ; load character
 JSR $FFD2 ; output to current output device
 INX
 BNE @LOOP 
 RTS

Intel x86, Dos, Tasm

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 ; output ascii string
 INT 21H
 MOV AX, 4C00H
 INT 21H
 END Start

Intel x86, Linux

SECTION .data
msg:
 db "Hello, World!\n"
 len equ $ - msg
SECTION .text
 global start
start:
 mov edx,len
 mov ecx,msg
 mov ebx,1
 mov eax,4
 int 0x80
 mov ebx,0
 mov eax,1
 int 0x80

Assembler 68000:

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

Arm, Risc OS:

.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

Risc processor and Mips architecture

 .data
msg: .asciiz "Hello, World!"
 .align 2
 .text
 .globl main 
main:
 la $a0,msg
 li $v0,4
 syscall
 jr $ra

AutoHotkey

MsgBox, "Hello, World!"

Autoit

MsgBox(1,'','Hello, World!')

Avenue - Scripting language for ArcView GIS

MsgBox("Hello, World!","aTitle")

Awk

# Hello
BEGIN { print "Hello, World!" }

B

B

/* Hello */

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

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

Bash

#!/bin/sh

echo "Hello, World!"

Basic

General

ANSI/ISO-compliant BASIC implementation. The "END" statement is optional in many implementations of BASIC.

10 PRINT "Hello, World!"
20 END

Immediate mode.

PRINT "Hello, World!"
? "Hello, World!"

Later implementations of BASIC. Again, the "END" statement is optional in many BASICs.

PRINT "Hello, World!"
END

DarkBasic

PRINT "HELLO WORLD"
TEXT 0,0,"Hello, World!"
WAIT KEY

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)
 PAUSE 500 'Sleep for half a second
LOOP
END

StarOffice/OpenOffice Basic

sub main
 print "Hello, World!"
end sub

Visual Basic

Sub Main()
 Print "Hello, World!"
End Sub

Visual Basic .Net

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

or:,

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

Bcpl

// Hello

GET "LIBHDR"

LET START () BE
$(
 WRITES ("Hello, World!*N")
$)

Beta

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

Bliss

%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

print "Hello, World!"

C

C (ANSI)

#include <stdio.h>

/* Hello */
int main(void)
{
 printf("Hello, World!");
 return 0;
}

C Windows

#include 
int WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
{
MessageBox( NULL, "Hello World!\n", "", MB_OK );
return 0;
}
.h>

C#

using System;
class HelloWorld
{
 static void Main()
 {
 System.Console.WriteLine("Hello, World!");
 }
}

C++ (ISO)

#include <iostream>

int main()
{
 std::cout << "Hello, World!\n";
}

C++ / Cli

int main()
{
 System::Console::WriteLine("Hello, World!");
}

C++ Managed (.Net)

#using <mscorlib.dll>

using namespace System;

int wmain()
{
 Console::WriteLine("Hello, World!");
}

Caml light

(* Hello World *)

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

Cil

.method public static void Main() cil managed
{
 .entrypoint
 .maxstack 8
 ldstr "Hello, World!"
 call void [mscorlib]System.Console::WriteLine(string)
 ret
}

Clean

module hello

Start = "Hello, World!"

Clist

PROC 0
WRITE Hello, World!

Clipper

? "Hello, World!"

Clu

start_up = proc ()
 po: stream := stream$primary_output ()
 stream$putl (po, "Hello, World!")
 end start_up

Cobol

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.

ENVIRONMENT DIVISION.

DATA DIVISION.

PROCEDURE DIVISION.
DISPLAY "Hello, World!".
STOP RUN.

Cocoa or GnuStep (Objective C)

#import <Cocoa/Cocoa.h>
@interface hello : NSObject {
}
@end

@implementation hello

-(void)awakeFromNib
{ 
 NSRunAlertPanel(@"Message from your Computer", @"Hello, World!", @"Hi!",
 nil, nil);
}

@end

CoffeeScript

alert "Hello World!"

ColdFusion

<cfoutput>Hello, World!</cfoutput>

Comal

PRINT "Hello, World!"

Curl

{curl 3.0, 4.0 applet}
{curl-file-attributes character-encoding = "utf-8"}

Hello, World!

D

D

import std.stdio ;
void main () 

{
  writef("Hello, World!");
}

D++

function main()
{
  screenput "Hello, World!";
}

Dart

main() 

{
  print('Hello, World!');
}

Dataflex

/tela
Hello world
/*
clearscreen
page tela

dBase

* Hello World in dBase IV
? "Hello World!"

Dcl batch

$ write sys$output "Hello, World!"

Delphi, Kylix

program Hello_World;
uses 
 Windows;

begin
 ShowMessage("Hello, World!");
end.

Doll

this::operator()
{
 import system.cstdio;
 puts("Hello, World!");
}

Dylan

module: hello

format-out("Hello, World!\n");

E

Ed and Ex (Ed extended)

a
hello World!
.
p

EGL

Program Hello
   const MYVAR string = "Hello World!";
   function main()
      SysLib.writeStdOut(MYVAR);
   end     
 end

Eiffel

class HELLO_WORLD

creation
 make
feature
 make is
 local
 io:BASIC_IO
 do
 !!io
 io.put_string("%N Hello, World!")
 end -- make
end -- class HELLO_WORLD

Elan

(* Elan *)
putline ("Hello World!");

Erlang

-module(hello).
-export([hello_world/0]).

hello_world() -> io:fwrite("Hello, World!\n").

Euphoria

puts(1, "Hello, World!")

F

F#

print_endline "Hello, World!"

Factor

"Hello, World!" print

filePro

 @once:
 mesgbox "Hello, World!" ; exit

Focal

type "Hello, World!",!

Focus

-TYPE Hello world

Forth

: HELLO ( -- ) ." Hello, World!" CR ;
HELLO

Fortran

 PROGRAM HELLO
 PRINT *, 'Hello, World!'
 END

Fril

 ?((pp "Hello, World!"))

Frink

println["Hello, World!"]

G

Gambas

PUBLIC SUB Main()
 Print "Hello, World!"
END

Graphical:

PUBLIC SUB Main()
 Message.Info("Hello, World!")
END

Go

package main

import fmt "fmt"



func main() 

{

   fmt.Printf("Hello, World!\n");

}

Groovy

println "Hello, World"

Gtk+ in C++

#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
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 << "Hello, World!" << endl;
}

int main (int argc, char *argv[]) {
 Gtk::Main kit(argc, argv);
 HelloWorld helloworld;
 Gtk::Main::run(helloworld);
 return 0;
}

Gtk# in C#

using Gtk;
using GtkSharp;
using System;

class Hello {

 static void Main()
 {
 Application.Init ();

 Window window = new Window("");
 window.DeleteEvent += cls_evn;
 Button close = new Button ("Hello world");
 close.Clicked += new EventHandler(cls_evn);

 window.Add(close);
 window.ShowAll();

 Application.Run ();

 }

 static void cls_evn(object obj, EventArgs args)
 {
 Application.Quit();
 }

}

H

Haskell

module Main (main) where

main = putStrLn "Hello, World!"

Heron

program HelloWorld;
functions {
 _main() {
 print_string("Hello, World!");
 }
}
end

HLA (High Level Assembly)

program helloWorld;
#include("stdlib.hhf")
begin helloWorld;

 stdout.put( "Hello World" nl );

end helloWorld;

HP-41, HP-42S

Hewlett-Packard RPN-based alphanumeric engineering calculators.

01 LBLTHELLO
02 THELLO, WORLD
03 PROMPT

Html

<html>
<body>
 Hello, World!
</body>
</html>

HTML 4.01 Strict

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <title>Hello, World!</title>
 </head>
 <body>
 <p>Hello, World!</p>
 </body>
</html>

HyperTalk

Apple HyperCard's scripting programming language.

put "Hello, World!"

or

Answer "Hello, World!"

I

Icon

# In Icon
procedure main()
 write("Hello world")
end

IDL

print,"Hello World!"

Inform

[ Main;
 "Hello, World!";
];

Intercal

 IN INTERCAL 
 HELLO WORLD

Io

"Hello, World!" print

or

write("Hello, World!\n")

Iptscrae

ON ENTER {
 "Hello, " "World!" & SAY
}

J

J

'Hello world'

Java

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

Java byte-code

Disassembler output of javap -c HelloWorld.

public class HelloWorld extends java.lang.Object{
public HelloWorld();
 Code:
 0: aload_0
 1: invokespecial #1; //Method java/lang/Object."<init>":()V
 4: return
public static void main(java.lang.String[]);
 Code:
 0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
 3: ldc #3; //String Hello, World!
 5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
 8: return
}

Java Swing

import javax.swing.JOptionPane;

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

Java SWT

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Label;

public class SWTHello {
 public static void main (String [] args) {
 Display display = new Display ();
 final Shell shell = new Shell(display);
 RowLayout layout = new RowLayout();
 layout.justify = true;
 layout.pack = true;
 shell.setLayout(layout);
 shell.setText("Hello, World!");
 Label label = new Label(shell, SWT.CENTER);
 label.setText("Hello, World!");
 shell.pack();
 shell.open ();
 while (!shell.isDisposed ()) {
 if (!display.readAndDispatch ()) display.sleep ();
 }
 display.dispose ();
 }
}

Java applet

Java applets work in conjunction with HTML files.

<HTML>
<HEAD>
<TITLE>Hello world</TITLE>
</HEAD>
<BODY>

HelloWorld Program says:

<APPLET CODE="HelloWorld.class" WIDTH=600 HEIGHT=100>
</APPLET>

</BODY>
</HTML>

import java.applet.*;
import java.awt.*;

public class HelloWorld extends Applet {
 public void paint(Graphics g) {
 g.drawString("Hello, World!", 100, 50);
 }
}

JavaFX Script (F3)

var win = new Frame();

win.title = "Hello World!";

win.width = 400;

var label = new Label();

label.text = "Hello World!";

win.content = label;

win.visible = true;

Visual version:

Stage {   

    title: "Hello World!"    

    width: 320    

    height: 240    

    visible: true  

}   

JavaScript

<script language="JavaScript">

    document.write('Hello, World!');

</script>

or with an alert

alert('Hello, World!');

or

<script type="text/javascript">
function helloWorld()
{
 alert("Hello, World!");
}
</script>

<a href="#" onclick="helloWorld(); return false;">Hello World Example</a>

or

<a href="#" onclick="alert('Hello, World!'); return false;">Hello World Example
</a>

K

K

`0:"Hello world\n"

Kogut

WriteLine "Hello, World!"

L

LaTeX

\documentclass{article}
\begin{document}
 Hello, World!
\end{document}

Lisaac

section HEADER
 + name := HELLO_WORLD;
 - category := MACRO;
section INHERIT
 - parent_object:OBJECT := OBJECT;
section PUBLIC
 - make <-
 ( 
 "Hello World !\n".print;
 );

Lisp

Lisp has many dialects that have appeared over its almost fifty-year history.

Common Lisp

(format t "Hello World!~%")

or

(write-line "Hello World!")

or merely:

 "Hello World!"

Scheme

(display "Hello, World!")

Emacs Lisp

 (print "Hello, World!")

AutoLisp

 (print "Hello, World!")

XLisp

 (print "Hello, World!")

Logo

print [Hello World!]

or

pr [Hello World!]

Lua

print "Hello, World!"

M

M4

Hello, World!

Macsyma, Maxima

print("Hello, World!")$

Maple

>> print("Hello, World!");

Mathematica

(* Hello World in Mathematica *)
Print["Hello world"]

Matlab

disp('Hello world')

Maude

fmod HELLOWORLD is
protecting STRING .
 op helloworld : -> String .
 eq helloworld = "Hello, World." .
endfm
red helloworld .

Max

max v2;
#N vpatcher 10 59 610 459;
#P message 33 93 63 196617 Hello World!;
#P newex 33 73 45 196617 loadbang;
#P newex 33 111 31 196617 print;
#P connect 1 0 2 0;
#P connect 2 0 0 0;
#P pop;

mIrc Script

echo Hello World

Model 204

BEGIN
PRINT 'Hello, World!'
END

Modula-2

MODULE Hello;

FROM InOut IMPORT WriteLn, WriteString;

BEGIN
 WriteString ("Hello, World!");
 WriteLn
END Hello.

(* Modula-2 R10 *)  



MODULE Hello; 

IMPORT PervasiveIO;

BEGIN

   WRITE("Hello, World!\n");

END Hello. 

Moo

notify(player, "Hello, World!");

Ms-Dos batch

The @ symbol is optional and prevents the system from displaying the command before executing it.

@echo Hello, World!

Muf

: main
 me @ "Hello, World!" notify
;

Mumps

W "Hello, World!"

N

 

Natural

WRITE "Hello, World!"
END

Nemerle

System.Console.WriteLine("Hello, World!");

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"
 };

Nice

void main(String[] args)
{ 
 println("hello world"); 
}

O

Oberon

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

Objective C

Functional C Version

#import <stdio.h>

int main() {
 printf( "Hello, World!\n" );
 return 0;
}

Object-Oriented C Version

#import <stdio.h>

//An object-oriented version.
@interface Hello : Object
{
 const char str[] = "Hello world";
}
- (id) hello (void);
@end

@implementation Hello
- (id) hello (void)
{
 printf("%s\n", str);
}
@end

int main(void)
{
 Hello *h = [Hello new];
 [h hello];

 [h free];
 return 0;
}

OpenStep/Cocoa Version

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
 NSLog(@"Hello, World!");
 return 0;
}

OCaml

print_endline "Hello World!"

Occam

#USE "course.lib"

PROC hello.world(CHAN OF BYTE screen!)
 out.string("Hello World!*n", 0, screen!)
:

Octave

printf("Hello World\n");

Opl

PROC hello:
 PRINT "Hello, world"
ENDP

Ops5

(object-class request
 ^action)

(startup
 (strategy MEA)
 (make request ^action hello)
)

(rule hello
 (request ^action hello)
 (write |Hello World!| (crlf))
)

Ops83

module hello (main)
{ procedure main( )
 {
 write() |Hello, World!|, '\n';
 };
};

Oz

{Browse 'Hello World!'} 

P

Parrot assembly language

print "Hello, World!\n"
end

Pascal

program hello;

begin
writeln('Hello, World!');
end.

Pdf

%PDF-1.0
1 0 obj
<<
/Type /Catalog
/Pages 3 0 R
/Outlines 2 0 R
>>
endobj
2 0 obj
<<
/Type /Outlines
/Count 0
>>
endobj
3 0 obj
<<
/Type /Pages
/Count 1
/Kids [4 0 R]
>>
endobj
4 0 obj
<<
/Type /Page
/Parent 3 0 R
/Resources << /Font << /F1 7 0 R >>/ProcSet 6 0 R
>>
/MediaBox [0 0 612 792]
/Contents 5 0 R
>>
endobj
5 0 obj
<< /Length 44 >>
stream
BT
/F1 24 Tf
100 100 Td (Hello World) Tj
ET
endstream
endobj
6 0 obj
[/PDF /Text]
endobj
7 0 obj
<<
/Type /Font
/Subtype /Type1
/Name /F1
/BaseFont /Helvetica
/Encoding /MacRomanEncoding
>>
endobj
xref
0 8
0000000000 65535 f
0000000009 00000 n
0000000074 00000 n
0000000120 00000 n
0000000179 00000 n
0000000322 00000 n
0000000415 00000 n
0000000445 00000 n
trailer
<<
/Size 8
/Root 1 0 R
>>
startxref
553
%%EOF

Perl

# Hello
print "Hello, World!\n";

Perl 6

say "Hello world";

PHP

<?php
 echo 'Hello, World!';
?>

or

<?php
 print 'Hello, World!' . PHP_EOL;
?>

or

<?='Hello, World!'?>

PHP-GTK

<?php

$wnd = new GtkWindow();
$wnd->set_title('Hello');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));
$lblHello = new GtkLabel("Hello world!'");
$wnd->add($lblHello);
$wnd->show_all();
Gtk::main();
?>

Pike

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

Pilot

T:Hello, World!

Pl/Sql

-- start anonymous block
set serveroutput on size 10000000;
begin
 dbms_output.enable(1000000);
 dbms_output.put_line('Hello World!'); 
end;
-- end anonymous block

Pl/I

Test: proc options(main) reorder;
 put skip edit('Hello, World!') (a);
end Test;

Pop-11

'Hello world' =>

PostScript

% Displays on console.
(Hello World!) =

%!
% Displays as page output.
/Courier findfont
24 scalefont
setfont
100 100 moveto
(Hello World!) show
showpage

Pov-Ray

#include "colors.inc"
camera {
 location <3, 1, -10>
 look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
 ttf "timrom.ttf" "Hello World!" 1, 0
 pigment { White }
}

Processing

println("Hello, World!");

Profan

' Hello in Profan 
cls
print "Hello World!"
waitkey

Progress

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

Prolog

:- write('Hello world'),nl.

Protocol Buffers

message hello
{
  required string data = 1 [default="Hello World!"];
} 

PureBasic

; In PureBasic console
OpenConsole()
 ConsoleTitle ("Hello World!")
 PrintN ("Hello World!")
CloseConsole()

Python 2

print "Hello, World!" 

Python 3

print("Hello, World!") 

Q

QML

Text {          

     text: "Hello World"          

} 

Qt toolkit (C++)

#include <QApplication>

#include <QLabel>



int main(int argc, char *argv[])

{

  QApplication app(argc, argv);

  QLabel salut("Hello World!");

  salut.show();

  return app.exec();

}

QuakeC

bprint("Hello World\n");

QuickBasic

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

R

R

cat("Hello world\n")

Ratfor

print *, 'hello, world'
end

RealBasic

' Hello
msgBox "Hello World!"

Rebol

print "Hello, World!"

Refal

$ENTRY GO{=<Prout 'Hello, World!'>;}

Rexx, ARexx, NetRexx, and Object REXX

say "Hello, World!"

or, Windows:

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

Rpg

Free-Form Syntax

 /FREE
 DSPLY 'Hello, World!';
 *InLR = *On;
 /END-FREE 

Traditional Syntax

 d TestMessage 
 c Const( 'Hello, World!' )
 c TestMessage DSPLY
 c EVAL *InLR = *On

Rpg Code

Message Window

mwin("Hello, World!")
wait()

On Screen Text

text(1,1"Hello, World!")
wait()

RPL (HP calculators)

<<

     CLLCD

     "Hello, World!" 1 DISP

     0 WAIT

     DROP

   >>

Rsl

[Hello World!];

Rtf

{\rtf1\ansi\deff0
{\fonttbl {\f0 Courier New;}}
\f0\fs20 Hello, World!
}

Ruby

puts "Hello, World!"

S

S

cat("Hello world\n")

Sas

data _null_;
put 'Hello, World!';
run;

Sather

class HELLO_WORLD is
 main is 
 #OUT+"Hello world\n"; 
 end; 
end;

Scala

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

Scriptol

 print "Hello World!"

sed

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

Seed7

$ include "seed7_05.s7i";

const proc: main is func
 begin
 writeln("Hello, World!");
 end func;

Self

'Hello, World!' print.

Setl

-- Hello in Setl2

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

Scheme

 (display "Hello world!")

 (newline)

Simula

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

Smalltalk

Transcript show: 'Hello, World!'; cr

Graphical:

('Hello, World!' asMorph openInWindow) submorphs second color: Color black

Smil

<!-- Hello World in SMIL -->
<smil>
 <head>
 <layout>
 <root-layout width="300" height="160" background-color="white"/>
 <region id="text_region" left="115" top="60"/>
 </layout>
 </head>
 <body>
 <text src="data:,Hello%20World!" region="text_region">
 <param name="fontFace" value="Arial"/>
 </text>
 </body>
</smil>

Sml

print "Hello, World!\n";

Snobol

 OUTPUT = "Hello, World!"
END

Span

class Hello {
 static public main: args {
 Console << "Hello, World!\n";
 }
}

Spark

with Spark_IO;
--# inherit Spark_IO;
--# main_program;

procedure Hello_World
--# global in out Spark_IO.Outputs;
--# derives Spark_IO.Outputs from Spark_IO.Outputs;
is
begin
 Spark_IO.Put_Line (Spark_IO.Standard_Output, "Hello, World!", 0);
end Hello_World;

Spitbol

 OUTPUT = "Hello, World!"
END

Spss Syntax

ECHO "Hello, World!".

Sql

CREATE TABLE message (text char(15));
INSERT INTO message (text) VALUES ('Hello, World!');
SELECT text FROM message;
DROP TABLE message;

MySQL or PostgreSQL:

SELECT 'Hello, World!';

Starlet

RACINE: HELLO_WORLD.

NOTIONS:
HELLO_WORLD : ecrire("Hello, World!").

SuperCollider

"Hello World".postln;

Svg

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<svg width="240px" height="100px" viewBox="0 0 240 100" 

     xmlns="http://www.w3.org/2000/svg">
 <title>Hello World</title>
 <g>
 <text x="20" y="50">Hello World</text>
 </g>
</svg>

T

Tacl

?TACL HELLO
#OUTPUT Hello, World!

Tcl

puts "Hello, World!"

Teco

!Hello in TECO
FTHello World$

TeX

Hello world
\bye

Ti-Basic

10 REM Hello World in TI BASIC
20 REM for the TI99 series computer
100 CALL CLEAR
110 PRINT "HELLO WORLD"
120 GOTO 120

Tk

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

Turing

put "Hello, World!"

U

Unix shell

echo 'Hello, World!'

or using an inline 'here document'

cat <<'DELIM'
Hello, World!
DELIM

or

printf '%s' $'Hello, World!\n'

or for a curses interface:

dialog --msgbox 'Hello, World!' 0 0

UnrealScript

class HelloHUD extends HudBase;

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

defaultproperties
{
}

V

Verilog

module main;

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

 endmodule

VHDL

use std.textio.all;

ENTITY hello IS
END ENTITY hello;

ARCHITECTURE Scriptol OF hello IS
 CONSTANT message : string := "hello world";
BEGIN
 PROCESS
 variable L: line; 
 BEGIN
 write(L, message);
 writeline(output, L);
 wait;
 END PROCESS;
END ARCHITECTURE Scriptol;

Visual Basic .Net 2003

If the code is entered as part of a Form subclass:

Private Sub frmForm_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load
 MessageBox.Show("Hello World!", "HELLO WORLD") 
 Me.Close() 
End Sub

Traditional Visual Basic code:

Public Class MyApplication
 Shared Sub Main()
 MessageBox.Show("Hello World!", "HELLO WORLD")
 End Sub
End Class

Visual DialogScript

info Hello world!

Visual Prolog console program

#include @"pfc\console\console.ph"

goal
 console::init(),
 stdio::write("Hello, World!").

W

Windows api (in C)

#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
int nCmdShow)
{
 MessageBox(NULL, "Hello, World!", "", MB_OK);
 return 0;
}

Vms

$ WRITE SYS$OUTPUT "Hello World!"

Vmrl

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

Wscript

WScript.Echo("Hello World!"); 

X

X++

class classHello
{
}

static void main(args Args)
{
 dialog dialog;
 dialog = new dialog();
 dialog.addText("Hello World!");
 dialog.run();
}

XAML/WPF

<Page xmlns="http://schemas.microsoft.com/winfx/avalon/2005">
 <TextBlock>Hello, World!</TextBlock>
</Page>

XHTML 1.1

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <title>Hello</title>
 </head>
 <body>
 <p>Hello, World!</p>
 </body>
</html>

XML

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="HelloWorld.xsl" ?>
<!-- Hello in XML -->
<text>
   <string>Hello, World!</string>
</text>

XQuery

(: Hello with XQuery :)
let $i := "Hello World!"
return $i

XSLT

Simplest code:

<xsl:template match="/">
 <xsl:text>Hello, World!</xsl:text>
</xsl:template>

Generate HTML:

 <xsl:template match="/">
 <html>
 <body>
 <h1>Hello, World!</h1>
 </body>
 </html>
 </xsl:template>

XUL

<?xml-stylesheet href="chrome://global/skin" type="text/css" ?>
<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
 align="center" pack="center" flex="1">
 <description>Hello, World!</description>
</window>

---

 

İlgili bağlantılar:

• http://tr.wikipedia.org/wiki/Merhaba_d%C3%BCnya_program%C4%B1
• http://www.scriptol.com/programming/hello-world.php
• http://www.gnu.org/fun/jokes/helloworld.html

 

---

#hello #world #merhaba #dünya #programlama #dili