We have had an interesting competition once, where everyone would write their implementation of hello world program. One requirement was that is should be less than 20 bytes in compiled form. the winner would be the one whose version is the smallest...
What would be your solution? :)
Platform: 32bit, x86
OS: DOS, Win, GNU/Linux, *BSD
Language: Asm, C, or anything else that compiles into binary executable (i.e. no bash scripts and stuff ;)
There's a print string function in the BIOS, I'd call that BIOS address with the address of the string, which would follow my small block of code.
I've only done this on an old 8-bit micro and CP/M, but I assume it would work on a PC as the BIOS is similar to CP/M's functions.
The Hello World Literal is what, 13 bytes as is? So that definitely makes a challenge :)
In shell, 19 bytes:
:
echo Hello World
I know you tagged this question 'asm'. I'm just offering this as an example of higher-level coding.
m db 'hello world$' ; store literal
mov dx, OFFSET m ; Pointer to m in dx
mov ah, 9 ; Prep for interupt
int 21h; ; BIOS interupt, will read dx and ah,
; ah=9 makes it print dx
I haven't assembled it yet, but that's about as small as you can make it. This is from memory from doing assembly about a decade ago, so I might have made a syntax error or two.
EDIT: 21 bytes assembled :(
title Hello World
dosseg
.model small
.stack 100h
.data
hello_message db 'Hello World',0dh,0ah,'$'
.code
main proc
mov ax,@data
mov ds,ax
mov ah,9
mov dx,offset hello_message
int 21h
mov ax,4C00h
int 21h
main endp
end main
actually it's from: http://robertsundstrom.wordpress.com/2008/02/17/assembly-x86/
hello world msg edited for smaller executable
and i'm new on this site i wasn't aware i had to post links to everything, he just asked how to do it so i found a resource and gave it to him, what you get for helping i guess.
20 bytes
.MODEL TINY
.CODE
CODE SEGMENT BYTE PUBLIC 'CODE'
ASSUME CS:CODE,DS:CODE
ORG 0100H
DB 'HELLO WORLD$', 0
INC DH
MOV AH,9
INT 21H
RET
Assemble with Microsoft Macro Assembler using:
ML /AT HELLO.ASM
File size: 20 bytes
That's about as short as it's going to get and still be a well behaved program.
Now, if you just want it shorter and don't care about a few extra characters being output on the screen, you could do it this way:
17 bytes and it does output HELLO WORLD before exiting nicely back to DOS.
.MODEL TINY
.CODE
CODE SEGMENT BYTE PUBLIC 'CODE'
ASSUME CS:CODE,DS:CODE
ORG 0100H
MOV AH,9
INT 21H
RET
DB 'HELLO WORLD$'
CODE ENDS
Unfortunately, Jonathan's solution won't work.
From the reference of int 21h, function 09:
"Sends a string to standard output. The string must end with '$' (ascii 36/24h). The '$'-char is not displayed."
So you have to end your "Hello World" string with a "$", so it's 21 bytes. Then, you have to exit the program (otherwise the behaviour is undefined) with two more instructions:
mov ah,4Ch
int 21h
See boltbait's solution for a working one in less than 20 bytes.
Very simple:
h
This is from my unreleased "HelloWorld" language. It's an interpreted language, so there's no real compiled form. The language is very simple though - the above is the only valid program, with the well-defined behaviour of printing "Hello World".
Arguably I could have designed it to only accept an empty file as input, but that would have been silly.
Its highly unlikely the actual compiled executable would be ever only 20 bytes. You have normally lots of OS specific loading code, ELF headers are huge as it is.
The only way to get something running in that short a space would be a "new" compiled format which was merely the string "hello world", that could be injected directly into the parent OS, and somehow the OS just "knew" that that file was to be printed.
But then your getting into technicalities, becuase you are, by proxy, calling an entire kernel to do the real work, and that averages between 2 and 8 MB.
If your going to do something that works without an OS, then you have initialization routines you have to do just to make it work.
And then the question evolves, does "20 bytes" include or exclude the byte-code in the bios?
If you really want to do this, maybe you should have a dedicated hardware architecture, with a hard wired rom chip with the "20 bytes" of code programmed in electronically.
outside these weird technical constraints, I argue that i have my own "interpreted language", known as "cat".
"cat" is also my os, and i use it to create the initial source file
1) Coding, and compiling my bytecode:
cat > helloworld.txt
Hello World^D^D
2) Executing the "compiled" bytecode
cat helloworld.txt
Hello World
see. marvelous. I'll take the gold medal thanks :)
Only 11 bytes.
Late linux trick
$ cd /tmp
$ echo '#!/bin/echo' >> hello
$ chmod u+x hello
$ ./hello world
> ./hello world
$ wc -c ./hello
> 12 ./hello
If you want shortest source code, "Hello World" is a valid program in quite a few languages.
Are you all using AH=09h/INT21h function?
There is an undocumented INT 29h which echoes the character in AL on the screen. So here is an alternative solution with a loop.
Not "well behaved", but better than BoltBaits which can randomly end prematurely if there is a '$' in the PSP. This program will output "Hello World" among with some junk characters.
17 bytes
bits 16
org 100h
next:
lodsb ; AC
int 29h ; CD29
loop next ; E2FB
ret ; C3
msg db "Hello World"
Assuming CX is 0 and SI < 106h on entry.
Here's a 32-byte version using Linux system calls:
.globl _start
_start:
movb $4, %al
xor %ebx, %ebx
inc %ebx
movl $hello, %ecx
xor %edx, %edx
movb $11, %dl
int $0x80 ;;; sys_write(1, $hello, 11)
xor %eax, %eax
inc %eax
int $0x80 ;;; sys_exit(something)
hello:
.ascii "Hello world"
00000000 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 |.ELF............| 00000010 02 00 03 00 01 00 00 00 54 80 04 08 34 00 00 00 |........T...4...| 00000020 00 00 00 00 00 00 00 00 34 00 20 00 01 00 00 00 |........4. .....| 00000030 00 00 00 00 01 00 00 00 00 00 00 00 00 80 04 08 |................| 00000040 00 80 04 08 74 00 00 00 74 00 00 00 05 00 00 00 |....t...t.......| 00000050 00 10 00 00 b0 04 31 db 43 b9 69 80 04 08 31 d2 |......1.C.i...1.| 00000060 b2 0b cd 80 31 c0 40 cd 80 48 65 6c 6c 6f 20 77 |[email protected] w| 00000070 6f 72 6c 64 |orld| 00000074
I win!
1 byte!
ret ; C3
But! First you have to install this little interrupt vector so that we are a part of the operating system :) Works perfectly under the NTVDM too.
Binaries and source code here for a working example. First run "hw_hook.com", then "hello.com".
The RET will end up invoking the INT 20h, so I hook the INT 20h with my "Hello World" interrupt vector.
%macro sethook 3
push es
push ds
xor ax, ax
mov es, ax
mov ds, ax
mov di, (%1 * 4) ; calculate IDT offset
mov si, di
cli
lodsd ; get the old handler
mov [cs:%3], eax ; save the old handler
mov ax, %2 ; and the offset to the new handler
rol eax, 16
push cs
pop ax
rol eax, 16
stosd ; set the new handler
sti
pop ds
pop es
%endmacro
bits 16
org 100h
_start:
int 12h ; get total free memory in ax
dec ax ; reserve one kilobyte
push ds
push 40h
pop ds
mov [ds:13h], ax ; store the new memory size
pop ds
; now relocate
push cs
pop ds
mov si, hook_size
shl ax, 6
mov es, ax
xor di, di
mov cx, hook_size
rep movsb
; setup "hello world" hook :)
sethook 20h, hello_hook, orig_vector
mov ax, 4c00h
int 21h
hello_hook:
pusha
pushf
mov ah, 09h
mov dx, msg
int 21h
popf
popa
pushf
call far [cs:orig_vector]
iret
msg db "Hello World$"
orig_vector dd 0
hook_size equ $ - hello_hook
0-byte Hello World program
Language? Processor?
I define an language with the following grammar: {Start} -> nil
All statements in this language are defined to print "Hello World" on execution.
The following string is a program in this language that prints "Hello World".
""
Zero bits. I win.
The smallest PE files (win32) you can create is 97 bytes.
See the Tiny PE page for all the gory details.
henk@korhal ~ $ xxd Hello\ World\!
0000000: 00 .
henk@korhal ~ $ ./Hello\ World\!
bash: ./Hello World!: cannot execute binary file
henk@korhal ~ $
1 byte binary, prints hello world!
in DOS:
C:\>debug
-e 10 "Hello World!$"
-a
139B:0100 mov ah,09
139B:0102 mov dl,10
139B:0104 int 21
139B:0106 int 20
139B:0108
-g
Hello World!
Program terminated normally
-
from 0100 to 0108, EIGHT BYTES. Of course the "Hello World!" wasn't really part of the program it was just hanging out in the memory.
I win, competition over.
I quite like the shell script
#!/bin/ls -1
although it needs to be named "Hello, world!" and be the only file in its directory (hey, at 12 bytes the program is shorter than the output). A little better, and shorter too (7 bytes), is
echo $0
This needs to be named Hello world, but works in any directory (that's gotta' be the weirdest "feature" of a program).
Of course, there's always the empty string as a program in my HelloWorldLanguage in which every string is a program which prints the famous greeting. You can use any of the above as an interpreter for it ;-)
By the way, I think Jon Skeets language is inadequate: it doesn't allow for comments, in-line documentation or in-line test cases. In practice, I think I'd prefer
module Greeter
/**
* print the given message, defaulting to "Hello world"
* @argument message The message to be printed
* @return whether the print was succesful
* @postcondition Either nothing is printed, or (only if message is non-null) the message is printed
*/
boolean printMessage(String message) {
try { System.console.OutPut(message); }
except (InputOutPutException theexception) {
return false;
}
return true;
}
/***
* void testTestFrameworkIO(String arguments[]) {
* assert(printMessage("Hello, world"));
*/
Which is also a valid program in HelloWorldLanguage. I think it's been underengineered: there has to be some applicable design pattern I can use... :D
not serious... but today is April 1st:
if letting the shell do the job is valid, just set the prompt to "Hello World" and everytime you type the enter-key you get a new "Hello World" (or change to a directory called that way...) :-)
In MSIL
.method private hidebysig static void Main() cil managed
{
.entrypoint
// Code size 13 (0xd)
.maxstack 8
IL_0001: ldstr "Hello World"
IL_0006: call void [mscorlib]System.Console::Write(string)
IL_000c: ret
}
Well it says 13, doesn't it?
[Edit]
Made the WriteLine to Write..
I know you said no interpreted languages, but...
In IRB, a Ruby shell, 13 bytes: "Hello world"
Create a file called void main(){puts("Hello, World!");}, assuming your filesystem will allow it.
Its contents should be:
A
Compile it with -istdio.h and -DA=__FILE__
If your filesystem supports newlines in giant filenames, you can write entire programs like this.
Hello World
BrainFuck
Below is another program to print Hello World in BrainFuck
+++++ +++++ initialize counter (cell #0) to 10
[ use loop to set the next four cells to 70/100/30/10
> +++++ ++ add 7 to cell #1
> +++++ +++++ add 10 to cell #2
> +++ add 3 to cell #3
> + add 1 to cell #4
<<<< - decrement counter (cell #0)
]
> ++ . print 'H'
> + . print 'e'
+++++ ++ . print 'l'
. print 'l'
+++ . print 'o'
> ++ . print ' '
<< +++++ +++++ +++++ . print 'W'
> . print 'o'
+++ . print 'r'
----- - . print 'l'
----- --- . print 'd'
> + . print '!'
> . print '\n'
I Won, because all of you used more charachters.
Open a Notepad, write only Hello World
File > Save As > a.cmd
11 Bytes
No bash, no batch, no asm, no any exotic solution, just python:
print"Hello World"
Many of these answers stretch the boundaries of what is to be accepted. Numerous implementations, albeit clever, rely on the OS's underlying functionalities. There is no reasonable reason to include such submissions, yet there is also no concise and unequivocal criteria for seclusion of code that relies entirely too much on compiler/interpreter/assembler/OS dependencies.
So then the only real distinction we may use to discern "valid" code is OS portability. The code must be able to run on some form of popular operating system.
But then a new conundrum appears: How much of the system's built in resources are we allowed? Does simply writing "echo Hello World" count? However, I guess this is addressed by the language limitation that it must be compilable. In which case, plenty submissions seems to have missed this restriction. :)
In that case, the only discernibly sane approach is the following:
Rewire the CPU datapath to interpret all instructions as output register 0, then using a powerful magnet and steady hands, burn the "Hello World" representation into register 0 bit by bit.
(Actually, Hello World can not possibly fit onto even a 64bit register, ok use the entire register block).
There you go, a real 0 byte implementation. :)