Копипаста:Hello, world!

/
 /</'Hello, world!/ | вывод + привет мир
\

/
/int/x, y, z\/ | Целый тип + переменные.
/>/y/x/        | Поочерёдный ввод значений переменных 
               |(для ввода в пределах одной строки />/y/x\/).
/z/x/+/y\/  |/z/x/+/y\/= "z := (x + y)", а /z/x/+/y/ = "z := x, + y"
/</x/y\/    |/</x/y\/ выводит всё в одной строке, а /</x/y/ в двух разных
/</z/
\

/
|Если писать код в пределах одной строки, образуются клещи (//), что недопустимо!
/</'H/'e/'l/'l/'o/',/' /'n/'e/'w/'f/'a/'g\/char/x/>/x/if/x/'hi\/</'win\/if/x/'wtf?\/</'The is manual for newfag\/else\/</'natribu.org\/ 
 |Равносильно
/</'H/'e/'l/'l/'o/',/' /'n/'e/'w/'f/'a/'g\/
/char/x/
/>/x/
/if/x/'hi\                     |если x = hi. после условия "/" не ставится
 /</'win\/                     |а вот после действий ставится
/if/x/'wtf?\                   |если x = wtf
 /</'The is manual for newfag\/
/else\                         |иначе
 /</'natribu.org\/
\

10 PRINT "Hello, World!"

? "Hello, World!"

      PROGRAM HELLOW
      WRITE(UNIT=*, FMT=*) 'Hello World'
      END

puts 'Hello, World!'

print("Hello,World!");

print ("Hello, World!")

import __hello__

print("Hello, World!")

echo Hello, world!

Say 'Hello, world!'

begin
  write('Hello, World!')
end.

{$apptype console}
begin
  Writeln('Hello, World!');
end.

uses windows;
begin
  MessageBox(0,'Hello, World!','Заголовок',0);
end.

uses windows;
{$apptype console}
Type
  THelloWorld = class
  procedure ShowMsg();
  procedure PrintMsg();
  end;
Procedure THelloWord.ShowMsg();
begin
  MessageBox(0,'Hello, World!','Заголовок',0);
end;
 
Procedure THelloWord.PrintMsg();
begin
  WriteLn('Hello, World!');
end;
 
var
 H : THelloWorld;
begin
 H := THelloWorld.Create;
 H.ShowMsg;
 H.PrintMsg;
end.

with Ada.Text_IO;
procedure Hello_World is
begin
  Ada.Text_IO.Put_Line ("Hello World");
end Hello_World;

MODULE Main;
IMPORT IO;
BEGIN
  IO.Put ("Hello World\n")
END Main.

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

  Messagebox "Hello, World!", MB_OK

  Print "Hello, World!"

  @Prompt([OK];"";"Hello, World!");

  @StatusBar("Hello, World!")

  Messagebox("Hello, World!", MB_OK);

  MsgBox(0, "AutoIT Window", "Hello, world!", 0.75)

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

#import <Foundation/Foundation.h>
@interface HelloWorld : NSObject
@end
@imlementation HelloWorld
+load{
  NSLog(@"Hello, World!");
  return;
}
@end

#include <iostream> 
int main()
{
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

#include <iostream>
using namespace std; 
int main()
{
    cout << "Hello, World!" << endl;
 
    return 0;
}

#include <windows.h>
int WINAPI WinMain (HINSTANCE,HINSTANCE,PSTR,int){
MessageBox(0,"Hello, World","F*ck",0);
return 0;
}

#include <iostream>
 
class World
{
    public:
        static int Hello()
        {
     	    std::cout << "Hello, world!" << std::endl;
            return 0;
        }
};
 
int main()
{
    return World::Hello();
}

class World{};
 
template <typename T>
void Hello(T hello)
{
    std::cout << "Hello, " << hello << std::endl;
}
 
template <class World>
void Hello()
{
    std::cout << "Hello, world!" << std::endl;
}
 
int main()
{
    Hello<World>();	
}

template <typename T>
class Hello
{
    public: 
        Hello(T hello)
        {
            std::cout << "Hello, " << hello << std::endl;
        }
};
 
template <>
class Hello<class World>
{
    public:
        Hello()
        {
            std::cout << "Hello, world!" << std::endl;
        }
};
 
int main()
{
    Hello<World>();
}

#include <iostream>
 
class AbstractHello
{
    public:
        virtual ~AbstractHello(){std::cout << " World!";}
        void Prnt(){std::cout << "Hello";}
 
 
};
 
class ChildHello: public AbstractHello
{
    public:
        ~ChildHello(){Prnt();}
};
 
int main()
{
    ChildHello *Obj;
    Obj = new ChildHello;
    delete Obj;
}

/*!
 * Hello world! application
 * 
 * \file hello.cpp
 */
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cassert>
 
/*!
 * Dispay message.
 */
void displayMessage();
 
/*!
 * Sentence type
 *
 * Type of sentence, used to decide how to terminate sentence.
 */
enum ESentenceType {
    eStatement,
    eExclamation,
    sQuestion,
    eCommand
};
 
/*!
 * Utility class to prevent unintended copying of class instances.
 */
class nonCopyable {
protected:
    nonCopyable() {
    }
 
    ~nonCopyable() {
    }
 
private:
    nonCopyable(const nonCopyable&);
    const nonCopyable& operator=(const nonCopyable&);
};
 
/*!
 * Utility function to obtain punctuation mark to end sentence
 * of specified type.
 */
inline char getPunctionMark(ESentenceType sentenceType) {
    char puncMark = '.';
    switch(sentenceType) {
        case eStatement  : puncMark = '.'; break;
        case eExclamation: puncMark = '!'; break;
        case sQuestion   : puncMark = '?'; break;
        case eCommand    : puncMark = '.'; break;
        default: {
            // should never get here
            assert(false);
        }
    }
    return puncMark;
}
 
/*!
 * Utility class for creation of instances.
 */
template<typename TElem>
class Creatable {
protected:
    Creatable() {
    }
 
    virtual ~Creatable() {
        clear();
    }
 
public:
    static TElem* create() {
        TElem* e = new TElem;
        return e;
    }
 
    void free() {
        delete this;
    }
 
    virtual void clear() {
    }
};
 
template<typename TElem, typename TParam>
class CreatableParam {
protected:
    CreatableParam() {
    }
 
    virtual ~CreatableParam() {
    }
 
public:
    static TElem* create(TParam p) {
        TElem* e = new TElem;
        e->initialize(p);
        return e;
    }
 
    void free() {
        finalize();
        delete this;
    }
 
    virtual void initialize(TParam /*p*/) {
    }
 
    virtual void finalize() {
        clear();
    }
 
    virtual void clear() {
    }
};
 
/*!
 * Base class for displayable content
 */
class DisplayElem
: public nonCopyable {
protected:
    DisplayElem() {
    }
 
    virtual ~DisplayElem() {
    }
 
public:
    virtual void display(std::ostream& os) const = 0;
};
 
/*!
 * STL algorithm for displaying elements
 */
class Displayer
: public std::unary_function<void, const DisplayElem*> {
private:
    std::ostream& m_os;
    char   m_sep;
    size_t m_count;
 
public:
    Displayer(std::ostream& os, char sep = '\0')
    : m_os(os)
    , m_sep(sep)
    , m_count(0) {
    }
 
    ~Displayer() {
    }
 
    void operator()(const DisplayElem* e) {
        if(('\0' != m_sep) && (0 < m_count)) {
            m_os << m_sep;
        }
        e->display(m_os);
        ++m_count;
    }
};
 
/*!
 * STL algorithm for freeing display elements
 */
template <typename TElem>
class Freer
: public std::unary_function<void, TElem*> {
public:
    void operator()(TElem* e) {
        e->free();
    }
};
 
/*!
 * Display element for letter.
 *
 * The letter is the fundamental element: it has no substructure.
 */
class Letter
: public DisplayElem
, public CreatableParam<Letter, char> {
private:
    char m_ch;
 
protected:
    /*virtual*/ ~Letter() {
    }
 
public:
    Letter() : m_ch('\0') {
    }
 
    void initialize(char ch) {
        m_ch = ch;
    }
 
    void finalize() {
        m_ch = '\0';
    }
 
    void display(std::ostream& os) const {
        os << m_ch;
        // no endLetter()
    }
};
 
/*!
 * Display element for word.
 *
 * A word is a sequence of letters.
 */
class Word
: public DisplayElem
, public Creatable<Word> {
private:
    std::vector<Letter*> m_letters;
 
protected:
    /*virtual*/ ~Word() {
        clear();
    }
 
public:
    Word() {
    }
 
    void clear() {
        std::for_each(m_letters.begin(), m_letters.end(), Freer<Letter>());
        m_letters.clear();
    }
 
    void addLetter(Letter* s) {
        m_letters.push_back(s);
    }
 
    /*virtual*/ void display(std::ostream& os) const {
        std::for_each(m_letters.begin(), m_letters.end(), Displayer(os));
        // no endLetter()
    }
};
 
/*!
 * Display element for sentence.
 *
 * A sentence is a sequence of words.
 */
class Sentence
: public DisplayElem
, public CreatableParam<Sentence, ESentenceType> {
private:
    std::vector<Word*> m_words;
 
    ESentenceType m_sentenceType;
 
protected:
    /*virtual*/ ~Sentence() {
        clear();
    }
 
    void endSentence(std::ostream& os) const {
        const char puncMark = getPunctionMark(m_sentenceType);
        os << puncMark;
    }
 
public:
    Sentence()
    : m_sentenceType(eStatement) {
    }
 
    void initialize(ESentenceType sentenceType) {
        m_sentenceType = sentenceType;
    }
 
    void finalize() {
        m_sentenceType = eStatement;
    }
 
    void clear() {
        std::for_each(m_words.begin(), m_words.end(), Freer<Word>());
        m_words.clear();
    }
 
    void addWord(Word* w) {
        m_words.push_back(w);
    }
 
    void display(std::ostream& os) const {
        std::for_each(m_words.begin(), m_words.end(), Displayer(os, ' '));
        endSentence(os);
    }
};
 
/*!
 * Display element for message.
 *
 * A message is a sequence of sentences.
 */
class Message
: public DisplayElem
, public Creatable<Message> {
private:
    std::vector<Sentence*> m_sentences;
 
protected:
    /*virtual*/ ~Message() {
        clear();
    }
 
    void endMessage(std::ostream& os) const {
        os << std::endl;
    }
 
public:
    Message() {
    }
 
    void clear() {
        std::for_each(m_sentences.begin(), m_sentences.end(), Freer<Sentence>());
        m_sentences.clear();
    }
 
    void addSentence(Sentence* s) {
        m_sentences.push_back(s);
    }
 
    void display(std::ostream& os) const {
        std::for_each(m_sentences.begin(), m_sentences.end(), Displayer(os, ' '));
        endMessage(os);
    }
};
 
/*!
 * Main entrance point.
 */
int main() {
    displayMessage();
    return 0;
}
 
/*!
 * Display message.
 */
void displayMessage() {
    Word* first_word = Word::create();
    first_word->addLetter(Letter::create('H'));
    first_word->addLetter(Letter::create('e'));
    first_word->addLetter(Letter::create('l'));
    first_word->addLetter(Letter::create('l'));
    first_word->addLetter(Letter::create('o'));
 
    Word* second_word = Word::create();
    second_word->addLetter(Letter::create('w'));
    second_word->addLetter(Letter::create('o'));
    second_word->addLetter(Letter::create('r'));
    second_word->addLetter(Letter::create('l'));
    second_word->addLetter(Letter::create('d'));
 
    Sentence* sentence = Sentence::create(eExclamation);
    sentence->addWord(first_word);
    sentence->addWord(second_word);
 
    Message* message = Message::create();
    message->addSentence(sentence);
 
    message->display(std::cout);
 
    message->free();
    // sentences, etc freed by parent
}

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

class Program
{
    static void Main()
    {
        System.Windows.Forms.MessageBox.Show("Hello, World!");
    }
}

printfn "Hello, World!"

print("Hello, World!")

print "Hello, World!"

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

#!/usr/bin/perl
print "Hello, World!\n";

perl -le 'print "Hello, World!"'

import qualified Data.ByteString as BS
import System.IO
message :: [[Char]]
message = [ 'H':'e':'l':'l':'o':',':[]
          , 'w':'o':'r':'l':'d':'!':[] ]
putHelloWorld :: [Char] -> IO()
putHelloWorld (x:xs) =
                  Prelude.putChar(x) >> putHelloWorld xs
putHelloWorld [] = Prelude.putChar('\n')
main :: IO ()
main =
  hSetBuffering stdout NoBuffering >> hSetBuffering stdin LineBuffering >> putHelloWorld(message')
  where
     message' = let f = (++) . (++ " ")
                    f' = foldl1 f
                in  f' message

main = putStrLn "Hello, world!"

(eval (cons (quote mapcar) 
            (cons (cons (quote function)
                        (cons (quote princ) ()))
                  (cons (cons (quote quote)
                              (cons (cons #\H (cons #\e (cons #\l (cons #\l (cons #\o 
                                     (cons #\, (cons #\Space 
                                      (cons #\w (cons #\o (cons #\r (cons #\l (cons #\d (cons #\! 
                                       ()))))))))))))) ())) ()))))

(mapcar #'princ '(#\H #\e #\l #\l #\o #\, #\Space #\w #\o #\r #\l #\d #\!))

(princ "Hello, world!")

(format t "hello world~%")

"Hello, world!"

(println "Hello world")

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

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

: HELLO 72 EMIT 101 EMIT 2 0 DO 108 EMIT LOOP 111 EMIT ;
: WORLD 119 EMIT 111 EMIT 114 EMIT 108 EMIT 100 EMIT ;
: HELLO_WORLD HELLO 44 EMIT SPACE WORLD 33 EMIT ;
HELLO_WORLD

: HelloWorld ." Hello, world!" ;

USE: io
IN: hello-world
 
: hello ( -- ) "Hello, world!" print ;
MAIN: hello

Предупреждение("Hello, world");

DoMessageBox("Hello, world",,"Attention");

Сообщить("Привет, Мир!");

Message("Привет, Мир!", MessageStatus.Attention);

Сообщение = Новый СообщениеПользователю;
Сообщение.Текст = "Хелло, Ворлд";
Сообщение.Сообщить();

Message = New User Message;
Message.Text = "Хелло, Ворлд";
Message.Message();

Вопрос("Хелло, Ворлд!", РежимДиалогаВопрос.ОК);

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

//hello class
public class HelloWorld extends java.lang.Object {
 
    //args - arguments from cmd
    public static final void main(java.lang.String[] args) {
 
        java.lang.System.out.println(new String("Hello, World!"));
    }
}

public class HelloWorld {
  static
  {
    System.out.println("Hello, world!");
    System.exit(0);
  }
}

public class hw {
public static void main (String [] args){
javax.swing.JOptionPane.showMessageDialog(null,"Хэлловорлд!");
}
}

import java.awt.*;
import javax.swing.*;
public class HelloWorld extends JFrame{
	HelloWorld(){
		setVisible (true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setSize(300,300);
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setLocation(dim.width/2-getSize().width/2,dim.height/2-getSize().width/2);
		JLabel l = new JLabel("Хэловорлд");
		setLayout(null);
		l.setBounds(110, 110, 70, 20);
		add(l);
	}
	public static void main(String[] args) {
		new HelloWorld();
	}
}

public interface Subject {
    public void attach(Observer observer);
    public void detach(Observer observer);
    public void notifyObservers();
}
 
public interface Observer {
    public void update(Subject subject);
}
 
public class HelloWorldSubject implements Subject {
 
    private ArrayList<Observer> observers;
    private String str;
 
    public HelloWorldSubject() {
        super();
 
        observers = new ArrayList<Observer>();
    }
 
    public void attach(Observer observer) {
        observers.add(observer);
    }
 
    public void detach(Observer observer) {
        observers.remove(observer);
    }
 
    public void notifyObservers() {
        Iterator<Observer> iter = observers.iterator();
 
        while (iter.hasNext()) {
            Observer observer = iter.next();
            observer.update(this);
        }
    }
 
    public String getStr() {
        return str;
    }
 
    public void setStr(String str) {
        this.str = str;
        notifyObservers();
    }
}
 
public class HelloWorldObserver implements Observer {
 
    public void update(Subject subject) {
        HelloWorldSubject sub = (HelloWorldSubject)subject;
        System.out.println(sub.getStr());
    }
 
}
 
public interface Command {
    void execute();
}
 
public class HelloWorldCommand implements Command {
 
    private HelloWorldSubject subject;
 
    public HelloWorldCommand(Subject subject) {
        super();
 
        this.subject = (HelloWorldSubject)subject;
    }
 
    public void execute() {
        subject.setStr("hello world");
    }
 
}
 
public interface AbstractFactory {
    public Subject createSubject();
    public Observer createObserver();
    public Command createCommand(Subject subject);
}
 
public class HelloWorldFactory implements AbstractFactory {
 
    public Subject createSubject() {
        return new HelloWorldSubject();
    }
 
    public Observer createObserver() {
        return new HelloWorldObserver(); 
    }
 
    public Command createCommand(Subject subject) {
        return new HelloWorldCommand(subject);
    }
}
 
public class FactoryMakerSingleton {
 
    private static FactoryMakerSingleton instance = null;
    private AbstractFactory factory;
 
    private FactoryMakerSingleton() {
        factory = new HelloWorldFactory();
    }
 
    public static synchronized FactoryMakerSingleton getInstance() {
        if (instance == null) {
            instance = new FactoryMakerSingleton();
        }
 
        return instance;
    }
 
    public AbstractFactory getFactory() {
        return factory;
    }
}
 
public class AbuseDesignPatterns {
 
    public static void main(String[] args) {
        AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();
 
        Subject subject = factory.createSubject();
        subject.attach(factory.createObserver());
 
        Command command = factory.createCommand(subject);
 
        command.execute();
    }
 
}

object HelloWorld extends App {
  println("Hello, world!")
}

traсe ("hello world!");

traсe ("hello world!");

var field:TextField=new TextField();
field.text="hello world!";
addChild(field);

class HELLO_WORLD 
feature
  print_hello is
      -- Print "Hello, World!"
    do
      print ("Hello, World!")
    end
end

Program Hello;
Begin
  DrawText('Hello, world!', 5, 5);
  Repaint; Delay(5000);
End.

echo "Hello, world!";

<?="Hello, world!"?>

/********************************************************************
Model-View-Controller implementation according to POSA
(Pattern-Oriented Software Architecture
  http://www.hillside.net/patterns/books/Siemens/book.html)
********************************************************************/
 
class HelloWorldController {
    private $model;
    function __construct($model) {
        $this->model = $model;
    }
 
    function handleEvent($args) {
        $this->model->setStrategy($args[2]);
        $this->model->addText($args[1]);
    }
}
 
 
class HelloWorldModel {
    private $text;
    private $observers = array();
    private $strategy;
 
    function attach($observer) {
        $this->observers[] = $observer;
    }
 
    function getData() {
        $facade = new HelloWorldFacade($this->strategy);
        return $facade->getHelloWorld().$this->text."\n";
    }
 
    function addText($text='') {
        $this->text = $text;
        $this->notify();
    }
 
    function setStrategy($strategy) {
        $this->strategy = $strategy;
    }
 
    function notify() {
        foreach ($this->observers as $observer) {
            $observer->update();
        }
    }
}
 
class HelloWorldView {
    private $model;
 
    function initialize($model) {
        $this->model = $model;
        $model->attach($this);
        return $this->makeController();
    }
 
    function makeController() {
        return new HelloWorldController($this->model);
    }
 
    function update() {
        $this->display();
    }
 
    function display() {
        echo $this->model->getData();
    }
}
 
 
/*********************************************************************
"Business logic"
********************************************************************/
 
class HelloWorld {
   function execute() {
       return "Hello world";
   }
}
 
class HelloWorldDecorator {
   private $helloworld;
   function __construct($helloworld) {
       $this->helloworld = $helloworld;
   }
 
   function execute() {
       return $this->helloworld->execute();
   }
}
 
abstract class HelloWorldEmphasisStrategy {
    abstract function emphasize($string);
}
 
class HelloWorldBangEmphasisStrategy extends HelloWorldEmphasisStrategy {
    function emphasize($string) {
       return $string."!";
    }
}
 
class HelloWorldRepetitionEmphasisStrategy extends HelloWorldEmphasisStrategy {
    function emphasize($string) {
       return $string." and ".$string." again";
    }
}
 
class HelloWorldEmphasizer extends HelloWorldDecorator {
   private $strategy;
   function HelloWorldEmphasizer($helloworld,$strategy) {
       $this->strategy = $strategy;
       parent::__construct($helloworld);
   }
 
   function execute() {
       $string = parent::execute();
       return $this->strategy->emphasize($string);
   }
}
 
class HelloWorldStrategyFactory {
    static function make($type) {
        if ($type == 'repetition') return self::makeRepetitionStrategy();
        return self::makeBangStrategy();
    }
 
    static function makeBangStrategy() {
        return new HelloWorldBangEmphasisStrategy;
    }
    static function makeRepetitionStrategy() {
        return new HelloWorldRepetitionEmphasisStrategy;
    }
}
 
class HelloWorldFormatter extends HelloWorldDecorator {
   function execute() {
       $string = parent::execute();
       return $string."\n";
   }
}
 
class HelloWorldFacade {
    private $strategy;
    function __construct($strategyType) {
        $this->strategy = HelloWorldStrategyFactory::make($strategyType);
    }
 
    function getHelloWorld() {
        $formatter = new HelloWorldFormatter(
                new HelloWorldEmphasizer(
                    new HelloWorld,$this->strategy));
        return $formatter->execute();
    }
}
 
$model = new HelloWorldModel;
$view = new HelloWorldView;
$controller = $view->initialize($model);
$controller->handleEvent($_SERVER['argv']);

Msgbox "Hello world!"

$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$$_$+$._$+$.$$__+$._+"\\"+$.__$+$.$_$+$.$_$+$.$$$_+"\\"+$.__$+$.$_$+$.$$_+$.__+".\\"+$.__$+$.$$_+$.$$$+"\\"+$.__$+$.$$_+$._$_+"\\"+$.__$+$.$_$+$.__$+$.__+$.$$$_+"(\\\"\\"+$.__$+$.__$+$.___+$.$$$_+(![]+"")[$._$_]+(![]+"")[$._$_]+$._$+", \\"+$.__$+$.$$_+$.$$$+$._$+"\\"+$.__$+$.$$_+$._$_+(![]+"")[$._$_]+$.$$_$+"!\\\")\\"+$.$$$+$._$$+"\"")())();

document.write("Hello, world!");

alert("Hello, world!");

console.log("Hello, world!");

trace('Hello World!');
 
//Или, если непременно надо вывести прямо на экран, а не в консоль, так:
var tf:TextField = new TextField;
tf.text = "Hello World!";
addChild(tf);

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

#!/usr/bin/env node
var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(1337, '127.0.0.1');
console.log('Server running at http://127.0.0.1:1337/');

echo Hello, world!

cat <<EOF
Hello world!
EOF

for i in 'H' 'e' 'l' 'l' 'o' ' ' 'w' 'o' 'r' 'l' 'd' '!' '\n'; do
        echo -ne "$i"
done

goal :-
  write ("Hello, World!").

select 'Hello, World!'

select 'Hello, World!' from dual;

SET serveroutput ON
 
BEGIN
 dbms_output.put_line('Hello world!');
END;
/

PRINT 'Hello, world';

select 'Hello, World!';

select 'Hello, World!' FROM RDB$DATABASE;

SELECT FIRST 1 'Hello, World!' FROM systables;

#ifndef DEFINE_ME
#error Fatal error! There must be some brain in your head!
#endif

use16
org 100h
 
mov ah,09h
mov dx,msg
int 21h
 
mov ax,4C00h
int 21h
msg db 'Hello, World!$'

.model tiny
.code
org 100h
 
Start:
mov ah, 9
mov dx, offset msg
int 21h
 
mov ax, 4C00H
int 21h
 
msg db 'Hello, world$'
end Start

mov ax, 0b800h
mov ds, ax
mov [02h], 'H'
mov [04h], 'e'
mov [06h], 'l'
mov [08h], 'l'
mov [0ah], 'o'
mov [0ch], ','
mov [0eh], 'W'
mov [10h], 'o'
mov [12h], 'r'
mov [14h], 'l'
mov [16h], 'd'
mov [18h], '!'
ret

SECTION .data
msg: db "Hello, world",10
len: equ $-msg
 
SECTION .text
global main
main:
mov edx, len
mov ecx, msg
mov ebx, 1
mov eax, 4
int 0x80
 
mov ebx, 0
mov eax, 1
int 0x80

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

.text
prefix: .ascii "Hello, World\n"
.set prefix_size, . - prefix
.global _start
_start:
xorq %rax, %rax
incb %al
xorl %edi, %edi
incl %edi
movq $prefix, %rsi
mov $prefix_size, %edx
syscall
movl $60, %eax
xorl %edi, %edi
syscall

.386
.model flat, stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib
 
.data
msg db "Hello, world!", 13, 10
len equ $-msg
 
.data?
written dd ?
 
.code
start:
push -11
call GetStdHandle
 
push 0
push offset written
push len
push offset msg
push eax
call WriteFile
 
push 0
call ExitProcess
end start

.386
.model flat, STDCALL
includelib kernel32.lib
GetStdHandle PROTO:DWORD
WriteConsoleA PROTO:DWORD,:DWORD,:DWORD,:DWORD,:DWORD
ExitProcess PROTO:DWORD
.const
message db "Hello, world!"
.code
Main PROC
LOCAL hStdOut :DWORD
push -11
call GetStdHandle
mov hStdOut,EAX
push 0
push 0
push 16d
push offset message
push hStdOut
call WriteConsoleA
push 0
call ExitProcess
Main ENDP
End Main

include 'win32ax.inc'
s:
invoke MessageBox,0,'Хэловорлд','  ',0
.end s

.include "m16def.inc"
.cseg
.org $0000
rjmp  start      ;Reset handler
.org $0030
start:
ldi   r24,  25  ; ~= 9600 @ 4Mhz clock
out   UBRRL,  r24
out   UBRRH,  r2
ldi   r24,  1 << TXEN
out   UCSRB,  r24
ldi   r24,  1 << URSEL | 1 << UCSZ0 | 1 << UCSZ1 ; 8-n-1
out   UCSRC,  r24
 
; send msg
ldi   ZL, msg << 1
loop:
lpm   r0, Z+ ; next char
tst   r0   ; terminated?
stop: breq  stop
 
while_busy:
sbis  UCSRA,  UDRE
rjmp  while_busy
out   UDR,  r0
rjmp  loop
msg:  .db  "Hello, world!", 13, 10, 0

  ORG #C000
Start:
  LD HL,Text
Loop:
  LD A,(HL)
  XOR A
  RET Z
  RST 16
  INC HL
  JR Loop
Text:
  DB 'Hello, world!
  DB 0

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.NUMERIC_STD.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
 
ENTITY CTL IS
PORT(
	CLK:	IN STD_LOGIC;
	DOUT1:	OUT STD_LOGIC_VECTOR(0 TO 6);
	DOUT2:	OUT STD_LOGIC_VECTOR(0 TO 6)
);
END ENTITY;
 
ARCHITECTURE CTL_ARCH OF CTL IS
SIGNAL CNT:		STD_LOGIC_VECTOR(0 TO 3):="0000";
 
BEGIN
	PROCESS(CLK)
	BEGIN 
		IF (CLK'EVENT AND CLK='1') THEN
				IF CNT = "1011" THEN CNT <= "0000";
				END IF;
				CASE CNT IS
				  WHEN "0000" => DOUT1 <= "1001000"; DOUT2 <="1111111";--H
				  WHEN "0001" => DOUT1 <= "0110001"; DOUT2 <="1111111";--E
				  WHEN "0010" => DOUT1 <= "1110001"; DOUT2 <="1111111";--L
				  WHEN "0011" => DOUT1 <= "1110001"; DOUT2 <="1111111";--L
				  WHEN "0100" => DOUT1 <= "0000001"; DOUT2 <="1111111";--O
				  WHEN "0101" => DOUT1 <= "1111111"; DOUT2 <="1111111";-- 
				  WHEN "0110" => DOUT1 <= "1100001"; DOUT2 <="1000001"; --W(1) W(2)
				  WHEN "0111" => DOUT1 <= "0000001"; DOUT2 <="1111111";--O
				  WHEN "1000" => DOUT1 <= "0011000"; DOUT2 <="1111111";--R
				  WHEN "1001" => DOUT1 <= "1110001"; DOUT2 <="1111111";--L
				  WHEN "1010" => DOUT1 <= "0000001"; DOUT2 <="1111111";--D
				  WHEN OTHERS => DOUT1 <= "1111111";  DOUT2 <="1111111";
				END CASE;
				CNT<= CNT+1;
		END IF;
	END PROCESS;
END CTL_ARCH;

H

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

show_message("Hello, World!");

draw_text(42, 42, "Hello, World!");

Text 0,0,"Hello, world!"

Print "Hello, world!"
WaitKey ;Или Delay 5000

Const HWtxt$ = "Hello, world!"
 
Graphics 800,600,32,2
SetBuffer BackBuffer()
 
 Type TCharacter
  Field c$
 End Type
 
GenerateHelloWorld
 
While Not KeyDown(1)
 Cls
 DrawHelloWorld
 Flip
Wend
 
End
 
Function GenerateHelloWorld()
 For i = 1 To Len(HWtxt)
  Local char.TCharacter = New TCharacter
   char\c = Mid(HWtxt,i,1)
 Next
End Function
 
Function DrawHelloWorld()
 For char.TCharacter = Each TCharacter
   i = i + 1
  Text i*10,10,char\c
 Next
End Function

# /* [  <!-- */ include  <stdio.h> /*   \
  #{\
`""""true \\#{"\n#"};           \
  \
if [ -n "$ZSH_VERSION" ]; then           \
  \
  echo exec  echo I\'m a zsh script.; \
  \
elif [ -n "$BASH_VERSION" ]; then        \
  \
  echo exec  echo I\'m a bash script.; \
else  \
  echo exec  echo  I\'m  a sh  script.;    \
fi`;  #\
BEGIN{print"I'm a ", 0 ? "Ruby"  :"Perl",  " program.\n";  exit; } 
  #\
%q~            
 
set dummy =0; puts [list "I'm"  "a"  "tcl"  "script."]; exit   
 
all: ; @echo "I'm a Makefile."          \
  #*/
/*: */ enum {a, b};            \
  \
static int c99(void) {         
 
#ifndef __cplusplus /* bah */        
 
unused1: if ((enum {b, a})0)          \
  (void)0;
#endif           
 
unused2:  return a;     \
}  \
static int trigraphs(void) {         \
  \
  return sizeof  "??!"  ==  2;    \
}  \
char X;               \
  \
int main(void) {             \
  \
  struct X  {        \
  \
     char  a[2];    \
  };\
  if (sizeof(X)  !=  1) {       \
  \
printf("I'm a C++ program (trigraphs %sabled).\n",         \
  \
   trigraphs()  ? "en"  : "dis");\
  \
}else if (1//**/2
 
 
)unused3 : { ; \
    printf("I'm a C program (C%s, trigraphs %sabled).\n", \
        c99() ? "89 with // comments" : "99", \
        trigraphs() ? "en" : "dis"); \
  } else { \
    printf("I'm a C program (C89, trigraphs %sabled).\n", \
        trigraphs() ? "en" : "dis"); \
  } \
  return 0; \
} /*
# \
> main :: IO () -- -- \
> main = putStr "I'm a Literate Haskell program.\n"
# \
]>++++++++[<+++++++++>-]<+.>>++++[<++++++++++>-]<-.[-]>++++++++++ \
[<+++++++++++>-]<-.>>++++[<++++++++>-]<.>>++++++++++[<++++++++++> \
-]<- - -.<.>+.->>++++++++++[<+++++++++++>-]<++++.<.>>>++++++++++[ \
<++++++++++>-]<+++++.<<<<+.->>>>- - -.<+++.- - -<++.- ->>>>>+++++ \
+++++[<+++++++++++>-]<- - -.<<<<<.<+++.>>>.<<<-.- ->>>>+.<.<.<<.> \
++++++++++++++.[-]++++++++++"""`
# \
print "I'm a Python program."; """[-][--><html><head>
<!--:--><title>I'm a HTML page</title></head><body>
<!--:--><h1>I'm a <marquee><blink>horrible HTML</blink></marquee> page</h1>
<!--:--><script language="Javascript">
<!--: # \
setTimeout( // \
  function () { // \
   document.body.innerHTML = "<h1>I'm a javascript-generated HTML page</h1>"; // \
  }, 10000); // \
//-->
</script><!--: \
</body></html><!-- } # \
say "I'm a Perl6 program", try { " ($?PUGS_VERSION)" } // "", "."; # """ # */
#define FOO ]-->~

define data local
1 #BUTTON(A1)
end-define
Write notitle 'Hello, world!'
display notitle 'Hello, world!'
print 'Hello, world!'
PROCESS GUI ACTION MESSAGE-BOX WITH NULL-HANDLE
  'Hello, world!' ' ' 'IO1'
  #BUTTON
  GIVING *ERROR-nr
Input (ad=od) 'Hello, world!'
end

default
{
    state_entry()
    {
      llSay(0,"Hello, world!");
    }
}

#!/usr/bin/env escript
 
main(_Args) ->
        io:format("Hello, World!~n").

(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCBA@98\6543W10/.R,+O<

HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE

package main
 
import "fmt"
 
func main() {
	fmt.Println("Hello, world!")
}

package main
 
func main() {
	println("Hello, world!")
}

application ($console,$void);
  var ("st",$string);
  "Hello World!">>st;
  write (st,$line);
  read ($void,$line);
exit();

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

REPORT  zhello.
WRITE / 'Hello, World!'.

REPORT  zhello.
MESSAGE 'Hello, World!' TYPE 'I'.

REPORT  zhello.
 
CALL FUNCTION 'POPUP_TO_DISPLAY_TEXT'
  EXPORTING
    titel        = 'Helloworld'
    textline1    = 'Hello'
    textline2    = 'World!'
    start_column = 25
    start_row    = 6.

> # # # # # # # # # 0 v
> #,_@#:"Hello, world!"

0"!dlroW ,olleH">:#,_@

\documentclass[a4paper,12pt]{article}
\usepackage[T2A]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[english]{babel}
\usepackage[pdftex,unicode]{hyperref}
\begin{document}
Hello, World!
\end{document}

Hello, World!

Hello, World!
\bye

:echo 'Hello World!'

TextWindow.WriteLine("Hello, World!")

fn main() {
 
    println!("Hello World!");
}

print("Hello, world!")

disp('Hello, world!');

IT'S SHOWTIME
TALK TO THE HAND "hello world"
YOU HAVE BEEN TERMINATED

_Счетчик Отобразить(_Текст) импорт _ОтобразитьТекст;
->ПриветМир():
    Отобразить "Hello, world!";
    <-0;
.