ITT Post Hello World in your language of choice

main = putStrLn "Hello World! "

$ echo "puts {hello world}" | tclsh
hello world

fn main () {
putstrln!("Hello world!");
}

never heard of this language; weird.

>alofa lalolagi
Subhumanish

tcl / tk is a reasonably famous (defunct i think) graphic toolkit for linux

Ööliä läikkyy
Finnish

sudo xbps-install -Sy espeak
espeak "hello world"

It's still getting bugfixes and new features at a steady rate.

"Hello world!\n";

vim helloworld

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
* simple hello world program
PROCEDURE DIVISION.
DISPLAY 'Hello world!'.
STOP RUN.

#!/bin/bash

printf "Hello World!\n"

ld hl,data
loop:
ld a,(hl)
out ($98),a
cp 0
jp nz,loop
ret
data: .db "hello world!",0

#include
#include
#include

int main () {
char *str;

str = (char *) malloc(15);
strcpy(str, "hello world!");
printf("%s", str);
free(str);
return 0;
}

Guten tag
Fuck I suck at Deutsch

echo "Hello, World!"

Hallo wereld

$letters = array("H","e","l","l","o"," ","W","o","r","l","d");

foreach ($letters as $letter) {
$message .= $letter;
}
echo $message;

#!/usr/bin/env ciao-shell

main(_) :-
write('Hello world!'), nl.

#include
#define H "Hello world!"

main(){
printf("%s", H);
return 0;
}

>main(){

Attached: 1505170110878.jpg (1132x1698, 245K)

fun main(args: Array) {
Optional.of("hello world")
.ifPresent { msg -> println(msg) }
}

why would you do that

пpивeт миp

This is why people see C programmers as code monkeys.

>OP posts innovative, efficient, cutting-edge code
>everyone else posts boring shit

Attached: wat.png (185x186, 4K)

hi OP,

please don't do that to structs

thanks,
james x

>please don't use structs as data structures
huh?

Bonjour le monde !
Froglang

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
section .data
msg db "Hello, world!",0xa
len equ $ - msg

#lang racket/base

(printf "~a"
(list->string
(map integer->char
(map
(lambda (num)
(+ (/ num 420) 69))
'(1260 13440 16380 16380 17640 -15540 21000 17640 18900 16380 13020 -15120 -24780)))))

Пиздyй нaхyй шпиoн cpaный

Hello worlds a hard program so I build a DSL in kotlin to make it easier and more modular for y'all.

PART 1 (defintion)

class HelloWorldContext(private var state: String = "") {
fun append(char: String) {
state += char
}

fun run() {
println(state)
}

operator fun plusAssign(char: String) {
state += char
}
}

fun buildHelloWorld(cont: HelloWorldContext.() -> Unit) {
cont.invoke(HelloWorldContext(""))
}

fun HelloWorldContext.h(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "h"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.e(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "e"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.o(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "o"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.space(cont: (HelloWorldContext.() -> Unit)? = null) {
this += " "
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.w(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "w"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.r(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "r"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.l(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "l"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

fun HelloWorldContext.d(cont: (HelloWorldContext.() -> Unit)? = null) {
this += "d"
if (cont == null) {
this.run()
} else {
cont.invoke(this)
}
}

using System;

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

PART 2 (usage)

fun main(args: Array) {
buildHelloWorld {
h {
e {
l {
l {
o {
space {
w {
o {
r {
l {
d()
}
}
}
}
}
}
}
}
}
}
}
}

look at how simple this was, isnt kotlin amazing? you should try it instead of becomming a rust tranny!

echo '1488'

But that 's "i check under my bed for jews every night because i can feel the nose poking", not hello world.

decided to refactor it a bit to show you the beauty of kotlin

class HelloWorldContext(private var state: String = "") {
fun append(char: String) {
state += char
}

fun run() {
println(state)
}

operator fun plusAssign(char: String) {
state += char
}
}

typealias Cont = (HelloWorldContext.() -> Unit)
typealias MaybeCont = Cont?

fun buildHelloWorld(cont: Cont) {
cont.invoke(HelloWorldContext(""))
}

fun MaybeCont.runOrContine(ctx: HelloWorldContext) {
if (this == null) {
ctx.run()
} else {
this.invoke(ctx)
}
}

fun HelloWorldContext.h(cont: MaybeCont = null) {
this += "h"
cont.runOrContine(this)
}

fun HelloWorldContext.e(cont: MaybeCont = null) {
this += "e"
cont.runOrContine(this)
}

fun HelloWorldContext.o(cont: MaybeCont = null) {
this += "o"
cont.runOrContine(this)
}

fun HelloWorldContext.space(cont: MaybeCont = null) {
this += " "
cont.runOrContine(this)
}

fun HelloWorldContext.w(cont: MaybeCont = null) {
this += "w"
cont.runOrContine(this)
}

fun HelloWorldContext.r(cont: MaybeCont = null) {
this += "r"
cont.runOrContine(this)
}

fun HelloWorldContext.l(cont: MaybeCont = null) {
this += "l"
cont.runOrContine(this)
}

fun HelloWorldContext.d(cont: MaybeCont = null) {
this += "d"
cont.runOrContine(this)
}

echo '88'

Я из бывшeй Югocлaвии, идиoт

Hallo Welt

echo hello world

That's easy OP, in my language of choice it would be simply

"Hello, world."

>racket
based

Attached: recursion.jpg (256x256, 4K)

HolyC, God's programming language
"Hello, World!\n";

print('Hello World')
Nothing wrong with Python

It is too slow and high level for some tasks.
But for many, many, many tasks, you're better off waiting the 20 seconds python will take to run rather than spending several hours into something that will execute in 5 seconds.

void main()
{
import std.stdio : writeln;
writeln = "Hello World!";
}

bump quality thread

did you forget to increment hl? also wouldn't you want to compare to 0 before outputting? (if input is an empty string, which it isn't in this case, but...)

+[-[-.---.>..>..>.

main(argc, argv)
int argc;
char **argv;
{
printf("Hello World");
return 0;
}

:then:(_ X) |> X

:prints:() |> ()
:prints:(X R) |> :then:(:printc:X :prints:R)
:prints:(X) |> :printc:X

:main:() |> :prints:'Hello World'

Does the english language count?
Hello World

hallo wereld

what abomination is this?

IO.puts "Hello world"

require("hello-world").greetWorld()

#include

int main(){
std::cout

Sveika, pasaule!

package main

import "fmt"

func main() {
fmt.Println("Hello World")
}

Something I wrote during my IT bachelor's. Here's fizzbuzz for you (sans some helper rules):
# Fizzbuzz

%:import:(read) |> r.

:do:(_ _ :Xs:X) |> :Xs:X
:do:(_ _ _ _ :Xs:X) |> :Xs:X

:if:(|T :Xa:X :_:_) |> :Xa:X
:if:(|F :_:_ :Ya:Y) |> :Ya:Y

:fizzbuzz:(101) |> ()
:fizzbuzz:(X) |> :do:(
:r.printn:X
:if:(
:==:(:mod:(X 3) 0)
:r.prints:" Fizz"
()
)
:if:(
:==:(:mod:(X 5) 0)
:r.prints:" Buzz"
()
)
:printc:'\n'
:fizzbuzz:(:+:(X 1))
)

:main:() |> :fizzbuzz:(1)

PRINT "Hello World!"

niggers

? "Hello World"
is shorter and still in BASIC.

move over faggots
play.rust-lang.org/?gist=a35ffcde768e7544efa1e4b7170d9c14

gonna larp as apple user:

hello world

recursivePrint [] = putChar '\n'
recursivePrint (x:xs) = putChar x >> recursivePrint xs

main = recursivePrint "Hello World"

Alexa say hello world

+[-[-.---.>..>..>.

>>.