Unconfigured Ad Widget

Collapse

Anúncio

Collapse
No announcement yet.

Hello world em 300 tipos diferentes

Collapse
X
 
  • Filter
  • Tempo
  • Show
Clear All
new posts

  • Font Size
    #1

    Hello world em 300 tipos diferentes

    Ae galera trago ai uma curiosidade,hello world em 300 linguaguens diferentes.
    pra vcs conhecerem as outras linguagens.


    4DOS Batch

    @echo Hello, world

    4GL

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

    4Test

    // Hello World in 4Test
    testcase printHelloWorld()
    print("Hello World!")

    A+

    []<-’Hello World!’

    Abap – SAP AG

    WRITE 'Hello, World!'.

    ABC

    WRITE "Hello, world!"

    ActionScript

    trace("Hello, World!");

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

    ActionScript 3

    package{
    import flash.display.Sprite;
    public class HelloWorld extends Sprite{
    public function HelloWorld(){
    trace("Hello, world!");
    }
    }
    }

    Ada

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

    Adobe Flex MXML

    <?xml version="1.0" encoding="utf-8"?>
    <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">
    <mx:Label text="Hello, world!"/>
    </mx:Application>

    Algol 60

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

    Algol 68

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

    ( print("Hello, World!") )

    Alma-0

    Hello, World!

    AmigaE

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

    AMX NetLinx

    program_name = 'Hello'
    define_start
    send_string 0,'Hello World!'

    Apl

    'Hello, World!'

    AppleScript

    return "Hello, World!"

    -- "Hello World!"

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

    Ascii

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

    Asp

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

    <%="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 Languages
    Aassembler – 6502

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

    Assembler – 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

    Assembler – 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

    Assembler – General-purpose fictional computer: MIX, MIXAL

    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

    RISC processor: MIPS architecture

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

    Arm, Risc OS:

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

    SWI"OS_WriteS":EQUS"Hello, World!":EQUB0:ALIGN:MOVPC,R14

    AutoHotkey

    MsgBox, "Hello, World!"

    Autoit

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

    Avenue – Scripting language for ArcView GIS

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

    AviSynth

    BlankClip()
    Subtitle("Hello, world!")

    Awk

    # Hello

    BEGIN { print "Hello, World!" }

    B

    /* Hello */
    main()
    {
    extern a, b, c;
    putchar (a); putchar (b); putchar (c); putchar ('!*n');
    }
    a 'hell' ;
    b 'o, w' ;
    c 'orld' ;

    Baan Tools

    function main()
    {
    message("Hello, world!")
    }

    Ball

    write Hello, *s world *n

    Bash or sh

    #!/bin/sh echo "Hello, World!"

    printf 'Hello, world!\n'

    Basic

    10 PRINT "Hello, World!"
    20 END

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

    PRINT "Hello, World!"
    END

    BlitzBasic

    Print "Hello, world!"
    WaitKey

    DarkBasic

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

    Liberty BASIC

    print "Hello, world"

    nomainwin
    open "Hello, world!" for graphics as #main
    print #main, "place 50 50"
    print #main, "\Hello, world!"
    print #main, "flush"
    wait

    PBasic

    DEBUG "Hello, World!", CR

    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

    Basic – StarOffice/OpenOffice

    sub main
    print "Hello, World!"
    end sub

    TI-BASIC

    :hellowld()
    :Prgm
    isp "Hello, world!"
    :EndPrgm

    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

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

    bc

    "Hello, world!"

    print "Hello, world!\n"

    Bcpl

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

    Beta

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

    BITGGAL AgileDog

    T
    1 "Hellow, World"
    0

    BITGGAL Jihwaja

    J( 1 TM 5 ZV 3 "Hellow, world" )

    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!"

    Burning Sand 2

    WRITE ELEMENT:Earth 210 230 40 CENTER TEXT "Hello World!"

    C

    #include <stdio.h>
    int main(void){
    printf("Hello, world!\n");
    return 0;
    }

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

    C#

    class HelloWorldApp{
    static void Main(){
    System.Console.WriteLine("Hello, world!");
    }
    }

    Caché Server Pages (CSP)

    Class Test.Hello Extends %CSP.Page [ ProcedureBlock ]
    {
    ClassMethod OnPage() As %Status
    {
    &html<<html>
    <head>
    </head>
    <body>>
    Write "Hello, world!",!
    &html<</body>
    </html>>
    Quit $$$OK
    }
    }

    Caml light

    (* Hello World *)

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

    CCL

    call echo("Hello, world!")

    Ch

    printf("Hello, world!\n");

    Chuck

    <<<"Hello World">>>;

    Chrome

    namespace HelloWorld;
    interface
    type
    HelloClass = class
    public
    class method Main;
    end;
    implementation
    class method HelloClass.Main;
    begin
    System.Console.WriteLine('Hello, world!');
    end;

    end.

    Cil

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

    Clarion

    PROGRAM
    MAP
    END
    CODE
    MESSAGE('Hello, world!!','Clarion')
    RETURN

    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

    ColdFusion

    <cfoutput>Hello, World!</cfoutput>

    Comal

    PRINT "Hello, World!"

    ConTeXt

    \starttext
    Hello, world!
    \stoptext

    Curl

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

    Hello, World!

    D

    import std.stdio ;

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

    D++

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

    Dataflex

    /tela
    Hello world
    /*
    clearscreen
    page tela

    dBase

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

    DC an arbitrary precision calculator

    [Hello, world!]p

    Dcl batch

    $ write sys$output "Hello, World!"

    DIV

    PROGRAM hello;
    BEGIN
    write(0, 0, 0, 0, "Hello, world!");
    LOOP
    FRAME;
    END
    END

    Delphi, Kylix

    program Hello_World;
    uses
    Windows;

    begin
    ShowMessage("Hello, World!");

    end.

    Doll

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

    Dream Maker

    mob
    Login()
    ..()
    world << "Hello, world!"

    Dylan

    module: hello
    format-out("Hello, world!\n");

    EAS 0.0.1.*

    set disp to "Hello, world!"
    set dispto to item unit 5 //5 = default screen
    release disp into dispto.

    import system ea.helloworld
    wait

    Ed and Ex (Ed extended)

    a
    hello World!
    .
    p

    Eiffel

    class HELLO_WORLD
    create make
    feature
    make is
    do
    io.put_string("Hello, world!%N")
    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#

    print_endline "Hello, World!"

    printfn "Hello, world!

    Factor

    "Hello, World!" print

    Ferite

    uses "console";
    Console.println("Hello, world!");

    filePro

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

    Fjölnir

    "halló" < main
    {
    main ->
    stef(
    stofn
    skrifastreng(;"Halló, veröld!"),
    stofnlok
    }
    *
    "GRUNNUR"
    ;

    Focal

    type "Hello, World!",!

    t "Hello, world!",!

    Focus

    -TYPE Hello world

    Forte TOOL

    begin TOOL HelloWorld;
    includes Framework;
    HAS PROPERTY IsLibrary = FALSE;
    forward Hello;
    -- START CLASS DEFINITIONS
    class Hello inherits from Framework.Object
    has public method Init;
    has property
    shared=(allow=off, override=on);
    transactional=(allow=off, override=on);
    monitored=(allow=off, override=on);
    distributed=(allow=off, override=on);
    end class; -- END CLASS DEFINITIONS
    -- START METHOD DEFINITIONS
    ------------------------------------------------------------
    method Hello.Init
    begin
    super.Init();
    task.Part.LogMgr.PutLine('Hello, world!');
    end method;
    -- END METHOD DEFINITIONS HAS PROPERTY
    CompatibilityLevel = 0;
    ProjectType = APPLICATION;
    Restricted = FALSE;
    MultiThreaded = TRUE;
    Internal = FALSE;
    LibraryName = 'hellowor';
    StartingMethod = (class = Hello, method = Init);
    end HelloWorld;

    Forth

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

    CR ." Hello, world!" CR

    Fortran

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

    FreeBasic

    PRINT "Hello World"
    SLEEP
    END

    Fril

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

    Frink

    println["Hello, World!"]

    Gambas

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

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

    Game Maker

    draw_text(x,y,"Hello, world!")

    show_message("Hello, world!")

    GEMBase 4GL

    procedure_form hello
    begin_block world
    print "Hello, world!"
    end_block
    end_form

    GraalScript 1

    if (created){
    echo Hello, world!;
    }

    GraalScript 2

    function onCreated() {
    echo("Hello, world!");
    }

    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:n_button_clicked));
    add(m_button);
    m_button.show();
    }

    HelloWorld::~HelloWorld() {}

    void HelloWorld:n_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();
    }

    }

    Haskell

    main = putStrLn "Hello, world!"

    module Main (main) where

    main = putStrLn "Hello, World!"

    haXe

    class HelloWorldApp
    {
    static function main()
    {
    trace("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 33s

    LBL H
    SF 10
    EQN
    RCL H
    RCL E
    RCL L
    RCL L
    RCL O
    R/S
    RCL W
    RCL O
    RCL R
    RCL L
    RDL D
    ENTER
    R/S

    HP-41, HP-42S

    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

    put "Hello, World!"

    Answer "Hello, World!"

    Icon

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

    IDL

    print,"Hello World!"

    Inform 5/6

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

    Inform 7

    Hello World is a room. The printed name is "Hello, world!"

    Intercal

    IN INTERCAL
    HELLO WORLD

    Io

    "Hello, world!" println

    writeln("Hello, world!")

    Iptscrae

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

    J

    'Hello world'

    'Hello, world!' NB. echoes the string in interactive mode, doesn't work in script

    'Hello World!' 1!:2(2) NB. prints it to (2) - screen, (4) - stdout

    Jal

    include 16f877_20
    include hd447804
    hd44780_clear
    hd44780 = "H"
    hd44780 = "e"
    hd44780 = "l"
    hd44780 = "l"
    hd44780 = "o"
    hd44780 = " "
    hd44780 = "W"
    hd44780 = "o"
    hd44780 = "r"
    hd44780 = "l"
    hd44780 = "d"
    hd44780 = "!"

    Java

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

    Java byte-code

    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.printlnLjava/lang/StringV
    8: return
    }

    JavaFX

    Frame {
    title: "Hello World JavaFX"
    width: 200
    content: Label {
    text: "Hello World"
    }
    visible: true
    }

    var win = new Frame();
    win.title = "Hello World JavaFX";
    win.width = 200;
    var label = new Label();
    label.text = "Hello World";
    win.content = label;
    win.visible = true;

    import java.lang.System;
    System.out.println("Hello World");

    println("Hello World");

    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

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

    JavaScript

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

    alert('Hello, world!');

    print('Hello, world!');

    WScript.Echo('Hello, world!');

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

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

    JSP

    <% out.println("Hello, world!"); %>

    Hello, world!

    Joy

    "Hello, world!\n" putchars .

    K

    `0:"Hello world\n"

    Kogut

    WriteLine "Hello, World!"

    KPL (Kids Programming Language)

    Program HelloWorld
    Method Main()
    ShowConsole()
    ConsoleWriteLine("Hello, world!")
    End Method
    End Program

    Lasso

    Output: 'Hello, world!';

    Output('Hello, world!');

    'Hello, world!';

    LaTeX

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

    Lexico Mobile (in spanish)

    tarea muestre "Hola mundo !"

    clase Saludo derivada_de Form
    publicos
    mensajes
    Saludo copie "Hola mundo !" en saludo.Text

    Limbo

    implement Command;
    include "sys.m"
    sys: Sys;
    include "draw.m";
    include "sh.m";
    init(nil: ref Draw->Context, nil: list of string)
    {
    sys = load Sys Sys->PATH;
    sys->print("Hello, world!!\n");
    }

    Linden Scripting Language

    default
    {
    state_entry()
    {
    llSetText("Hello, World!" , <0,0,0> , 1.0);
    }
    }

    Lingo (Macromedia Director scripting language)

    on exitFrame me
    put "Hello, world!"
    end

    Linotte

    Livre : HelloWorld
    Paragraphe : Affichage
    Actions :
    "Hello, World !" !

    Lisaac

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

    Lisp
    Common Lisp

    (format t "Hello World!~%")

    (write-line "Hello World!")

    "Hello World!"

    Scheme

    (display "Hello, World!")

    Emacs Lisp

    (print "Hello, World!")

    AutoLisp

    (print "Hello, World!")

    XLisp

    (print "Hello, World!")

    Arc

    (prn "Hello, world!")

    Logo

    print [Hello World!]

    pr [Hello World!]

    messagebox [Hi] [Hello, world!

    LPC

    void create()
    {
    write("Hello, world!\n");
    }

    Lua

    print "Hello, World!"

    LuaPSP

    screenrint(1,1,"Hello, world!")
    screen:flip()

    M (MUMPS)

    W "Hello, world!"

    M4

    Hello, World!

    Macsyma, Maxima

    print("Hello, World!")$

    Maple

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

    Mathematica

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

    "Hello, world!"

    Matlab

    disp('Hello world')

    fprintf('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;

    Maya Embedded Language

    print( "Hello, world!\n" );

    Microsoft Foundation Classes (in C++)

    #include <afx.h>
    #include <afxwin.h>
    class CHelloWin : public CWnd
    {
    protected:
    DECLARE_MESSAGE_MAP()
    afx_msg void OnPaint(void)
    {
    CPaintDC dc(this);
    dc.TextOut(15, 3, TEXT("Hello, world!"), 13);
    }
    };
    BEGIN_MESSAGE_MAP(CHelloWin, CWnd)
    ON_WM_PAINT()
    END_MESSAGE_MAP()
    class CHelloApp : public CWinApp
    {
    virtual BOOL InitInstance();
    };
    CHelloApp theApp;
    LPCTSTR wndClass;
    BOOL CHelloApp::InitInstance()
    {
    CWinApp::InitInstance();
    CHelloWin* hello = new CHelloWin();
    m_pMainWnd = hello;
    wndClass = AfxRegisterWndClass(CS_VREDRAW | CS_HREDRAW, 0, (HBRUSH)::GetStockObject(WHITE_BRUSH), 0);
    hello->CreateEx(0, wndClass, TEXT("Hello MFC"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 120, 50, NULL, NULL);
    hello->ShowWindow(SW_SHOW);
    hello->UpdateWindow();
    return TRUE;
    }

    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.

    Moo

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

    Mouse

    "Hello, World!" $

    Ms-Dos batch

    @echo Hello, World!

    Muf

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

    Natural

    WRITE "Hello, World!"
    END

    Nemerle

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

    using System.Console;
    module HelloWorld
    {
    Main():void
    {
    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");
    }

    NSIS

    OutFile "HelloWorld.exe"
    Name "Hello, world!"
    Caption "Hello, world!"

    Section Hello, world!
    SectionEnd

    Function .onInit
    MessageBox MB_OK "Hello, world!"
    Quit
    FunctionEnd

    Oberon

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

    Object-Oriented C Version

    #import <stdio.h>
    #import <objc/Object.h>
    @interface Hello : Object { }
    - hello;
    @end

    @implementation Hello
    - hello {
    printf("Hello, world!\n");
    }
    @end
    int main(void) {
    id obj;
    obj = [Hello new];
    [obj hello];
    [obj 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!'}

    Parrot assembly language

    print "Hello, World!\n"
    end

    Parrot intermediate representation

    .sub hello :main
    print "Hello, world!!\n"
    .end

    Pascal

    program hello;

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

    PAWN

    main()
    {
    print("Hello World");
    }

    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!';
    ?>

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

    <?='Hello, World!'?>

    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

    (Hello, world!\n) print

    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.

    Pure Data

    #N canvas 0 0 300 300 10;
    #X obj 100 100 loadbang;
    #X msg 100 150 Hello, world!;
    #X obj 100 200 print;
    #X connect 0 0 1 0;
    #X connect 1 0 2 0;

    Protocol Buffers

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

    PureBasic

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

    Python

    print "Hello, World!"

    Qt toolkit (C++)

    #include <qapplication.h>
    #include <qpushbutton.h>
    #include <qwidget.h>
    #include <iostream>

    class HelloWorld : public QWidget
    {
    Q_OBJECT

    public:
    HelloWorld();
    virtual ~HelloWorld();
    public slots:
    void handleButtonClicked();
    QPushButton *mPushButton;
    };

    HelloWorld::HelloWorld() :
    QWidget(),
    mPushButton(new QPushButton("Hello, World!", this))
    {
    connect(mPushButton, SIGNAL(clicked()), this, SLOT(handleButtonClicked()));
    }

    HelloWorld::~HelloWorld() {}

    void HelloWorld::handleButtonClicked()
    {
    std::cout << "Hello, World!" << std::endl;
    }

    int main(int argc, char *argv[])
    {
    QApplication app(argc, argv);
    HelloWorld helloWorld;
    app.setMainWidget(&helloWorld);
    helloWorld.show();
    return app.exec();
    }

    QuakeC

    bprint("Hello World\n");

    QuickBasic

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

    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!"

    Robotic (MegaZeux)

    * "Hello, world!"
    end

    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!];

    RT Assembler

    _name Hello~World!
    pause Hello~World!
    exit _end

    Rtf

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

    RTML

    Hello ()
    TEXT "Hello, world!"

    Ruby

    puts "Hello, World!"

    S

    cat("Hello world\n")

    S-Lang

    message("Hello, world!");

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

    SCAR

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

    Scheme

    (display "Hello world!")
    (newline)

    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;

    Simula

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

    Smalltalk

    Transcript show: 'Hello, World!'; cr

    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

    ShadowScript

    'set up initial variables
    struct.follow
    {
    cpu.fan.speed(500.rpm)
    cpu.max.process(100)
    }
    <
    logic.handle(0)
    int main()
    int var()
    array.max(100000000)
    >
    'open and write the text in a free handle window
    open mainwin(io<std>) as free(1)
    {
    write.free(1).("Hello",&sym," world",&sym)(&sym<",">&sym<"!">
    apply.free(1) to text
    }
    'reset the fan, cpu, and vars
    <
    logic(std)
    fan(std.auto)
    cpu.max(auto)
    unint main()
    unint var()
    un.array.max(std)
    >
    'end
    end
    .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

    SSPL

    1.0
    print 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!").

    STATA

    Define program in script (.do-file) or at command line:

    program hello /*Define Hello, world! program*/
    di "Hello, world!"
    end
    hello /*run Hello, world! program*/

    di "Hello, world!"

    SuperCollider

    "Hello World".postln;

    Svg

    <?xml version="1.0" encoding="utf-8" standalone="no"?>
    <svg width="240" height="100" viewBox="0 0 240 100" zoomAndPan="disable"
    xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
    <title>Hello World</title>
    <g>
    <text x="10" y="50">Hello World</text>
    <animate attributeName='opacity' values='0;1' dur='4s' fill='freeze' begin="0s"/>
    </g>
    </svg>

    T programming language

    %begin @jump $main
    %main.0 @echo %msg
    %main.1 @end
    %main.count 2
    %msg Hello, world!

    Tacl

    ?TACL HELLO
    #OUTPUT Hello, World!

    Tcl (Tool command language)

    puts "Hello, World!"

    Teco

    !Hello in TECO
    FTHello World$

    Template Toolkit

    [% GET "Hola mundo!"; %]

    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

    TOM (rewriting language)

    public class HelloWorld {
    %include { string.tom }
    public final static void main(String[] args) {
    String who = "world";
    %match(String who) {
    "World" -> { System.out.println("Hello, " + who + "!"); }
    _ -> { System.out.println("Don't panic"); }
    }
    }

    TSQL

    Declare @Output varchar(16)
    Set @Output='Hello, world!'
    Select 'Output' = @Output

    Select 'Hello, world!'
    Print 'Hello, world!'

    TTCN-3

    module hello_world {
    control {
    log("Hello, world!");
    }
    }

    Turing

    put "Hello, World!"

    Ubercode

    Ubercode 1 class Hello
    public function main()
    code
    call Msgbox("Hello", "Hello, world!")
    end function
    end class

    Uniface

    message "Hello, world!"

    Unix shell

    echo 'Hello, World!'

    cat <<'DELIM'
    Hello, World!
    DELIM

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

    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
    {
    }

    XUL

    <?xml version="1.0"?>
    <?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
    <window id="yourwindow" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
    <label value="Hello, World!"/>
    </window>

    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 Script

    WScript.Echo "Hello, world!"

    VBA

    Sub Main()
    MsgBox "Hello, world!"
    End Sub

    Visual Basic .Net 2003

    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

    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!").

    Vms

    $ WRITE SYS$OUTPUT "Hello World!"

    Vmrl

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

    Windows API (C Language)

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

    Windows PowerShell

    "Hello, world!"

    Write-Host "Hello, world!"

    echo "Hello, world!"

    [System.Console]::WriteLine("Hello, world!")

    Wscript

    WScript.Echo("Hello World!");

    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>

    XL

    use XL.UI.CONSOLE
    WriteLn "Hello, world!"

    import IO = XL.UI.CONSOLE
    IO.WriteLn "Hello, world!"

    Xml

    <?xml version="1.0" encoding="ISO-8859-1"?>
    <?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

    XS programming language

    <print>Hello, world!</print>

    XSLT

    <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>

    Yorick

    write, "Hello, world!";


    o site que achei foi esse aqui : Apenas usuários registrados e ativados podem ver os links., Clique aqui para se cadastrar...

    legal né.Tem até em ada.

    Foi util o post clique em obrigado.Gostaram??? comentem.
    Desculpem a falta de acentuação e os pontos,é que tô com preguiça.
    Valeu,até mais.

  • Font Size
    #2
    Desmaiei , chame a AMBULANCIA

    Cara que isso , diferencia os tipos em cores .. e preferencia fracas..
    Mas é um bom tutorial D:
    #antigov

    Comment


    • Font Size
      #3
      É que tava com preguiça de "arrumar",ai postei assim.
      Prometo melhorar.
      Valeu

      Comment


      • Font Size
        #4
        Boa Franco continue assim cara, tem uns bem interessantes, principalmente o em PDF, obrigado por compartilhar.

        Abraços.

        WCG147
        sigpic

        Comment


        • Font Size
          #5
          Você podia colocar o código em
          quote

          Comment


          • Font Size
            #6
            Você podia colocar o código em
            quote

            Comment


            • Font Size
              #7
              Maldito Hello World
              "Não subestime os fracos pois eles não agem com a força e sim com a mente."

              Comment

              X
              Working...
              X