Empty program

Empty program
You are encouraged to solve this task according to the task description, using any language you may know.

In this task, the goal is to create the simplest possible program that is still considered "correct." =Programming Languages= ==Ada==

Works with: GCC version 4.1.2

procedure Empty is begin null; end;==Agena== Actually nothing is valid code, too.

ALGOL 68

Brief form

~

BOLD form

SKIP

AmigaE

PROC main() ENDPROC==AppleScript== An empty .scpt file is considered the smallest runnable code, but the following would also be acceptable. return==Argile== The empty string or file are valid and do nothing.

==AutoHotkey== An empty script would be enough. Adding "#Persistent" makes it persistent. #Persistent==AutoIt== An a single comment can be considered a valid program that does nothing. ;nothing==AWK== The empty string (or file) is recognised as valid program that does nothing. The program 1is the simplest useful program: like the UNIX command 'cat', it prints every line of the files given as arguments, or (if no arguments are given) the standard input. ==BASIC==

Works with: QBasic

10 END

Works with: ZX Spectrum Basic

On the ZX Spectrum, we can have a completely empty program with no lines. Here we attempt to run the empty program: RUN0 OK, 0:1 ==Batch File== An empty batch file is syntactically correct and does nothing.

But on windows 7 an empty .bat file is not recognized and thus a character must exist in it: REM==BBC BASIC== In BBC BASIC an empty program is syntactically correct.

==Befunge== @ The halt command @ is required because code wraps around. An empty file would be an infinite loop. ==Bracmat== An empty file is a valid program. However you need to load it, which requires a statement. In a Linux terminal, you could do touch empty bracmat 'get$empty'In DOS, you can do touch empty bracmat get$emptyIf we drop the requirement that the shortest program is stored in a file, we can do bracmat (Linux) or bracmat ""(Windows) If two quotes to demarcate an empty string are counted as bigger than a single undemarcated non-empty expression, we can do bracmat . The dot is a binary operator. So the input consists of three nodes: the operator and its lhs and rhs, both empty strings in this case. If three nodes is too much, consider a slightly bigger glyph, such as the hyphen, which is a prefix, not a binary operator: bracmat - You also can start Bracmat without arguments, in which case it will run in interactive mode. Now press the Enter key. You have just run the shortest valid Bracmat program. ==Brainf***== Empty program Note: this works as all non-instruction characters are considered comments. Alternatively, a zero-byte file also works. ==Brlcad== Pressing enter from the mged prompt, just returns another prompt, so I suppose that is the smallest possible program. However, before we can draw anything we at least need to open a database: opendb empty.g y==C== You'll notice that each example has an int return type, and returns 0. The meaning of the return value is system-dependent. argc contains the number of arguments. argv is an array containing those arguments as null-terminated strings. These memory for these strings are maintained by the runtime, and don't need to be manually freed. int main(int argc, char* argv[]) {

 return 0;

}With some compilers, argc and argv may omitted.

Works with: gcc version 4.0.3

int main ()

{

 return 0;

}

C#

class Program {

   static void Main()
   {
   }

}

C++

Works with: g++ version 4.0.3

int main ( int /*argc*/, char * * /*argv*/ ) { // Unused arguments should not be named // There are variations: // 1: main may explicitly return a value // (other non-void-returning C++ functions must do so, // but there's a special exception for main that falling off it // without an explicit return is equivalent to a "return 0;" at // the end of the main function) // 2: The arguments may be omitted entirely }==Clean== module Empty Start world = worldCompile the project with No Console or No Return Type to suppress printing of the value of the world. ==Clojure== An empty file is the simplest valid Clojure program. ==CoffeeScript==

D

void main() {}

Dart

main() { }

Delphi

See Pascal

E

The shortest possible program:

This is equivalent to: null

eC

or class EmptyApp : Application { void Main() { } }==Eiffel== A file called main.e: class MAIN

   create main
   feature main
       do
       end

end==Erlang== An empty module: -module(empty). An empty Erlang script file (escript): main(_) -> 1.

eSQL

CREATE COMPUTE MODULE ESQL_Compute CREATE FUNCTION Main() RETURNS BOOLEAN BEGIN RETURN TRUE; END; END MODULE;

Euphoria

==F#== F# has an interactive mode and a compiled mode. The interactive interpreter will accept an empty file so the shortest valid program is an empty zero-length file with the .fsx extension. An empty compiled program is: [] let main args = 0

Factor

If you want to deploy a stand-alone application, that doesn't suffice though. Here's another version. IN: rosetta.empty : main ( -- ) ; MAIN: main

Falcon

> Prints an empty line. >> Prints nothing.

FALSE

==Fantom== class Main {

 public static Void main () {}

}==Fish== Actually the shortest valid program is a space (not empty file!), which is an infinite loop, though. (It keeps looping around) An empty program is invalid; the interpreter will give an error. The shortest program that will actually finish is a ;, which will end the program immediately:

Forth

For a Forth script to be used from a shell, you usually want the last command to be BYE in order to exit the interpreter when finished. bye==Fortran== end==Frink== Empty programs are valid.

==Gecho== Empty programs are valid.

==Gema== An empty program will copy input stream to output stream unchanged.

Go

package main func main() { }

Groovy

==Haskell== Standard: Haskell 98 The simplest possible program is a single module using the implicit module header "module Main(main) where", and defining the action main to do nothing: main = return ()The simplest possible module other than Main is one which contains no definitions: module X where {}

haXe

class Program {

   static function main() {
   }

}Unlike most languages haXe doesn't have arguments in the main function because it targets different platforms (some which don't support program arguments, eg: Flash or Javascript). You need to use the specific libraries of the platform you are targeting to get those. ==HicEst== END ! looks better, but is not really needed==HQ9+== An empty file is a valid HQ9+ program that does nothing. ==Icon and Unicon== procedure main() # a null file will compile but generate a run-time error for missing main end

IDL

end

Intercal

PLEASE GIVE UP

J

It returns itself:

   -: ". 

1

Java

Works with: Java version 1.5+

public class EmptyApplet extends java.applet.Applet { @Override public void init() { } }

public class EmptyMainClass { public static void main(String... args) { } }The "..." basically means "as many of these as the programmer wants." Java will put multiple arguments into an array with the given name. This will work for any method where an array is an argument, but with a twist. A call can be made like this: method(arg0, arg1, arg2, arg3)All of the args will be put into an array in the order they were in the call.

Works with: Java version 1.0+

public class EmptyMainClass { public static void main(String[] args) { } }

public class EmptyApplet extends java.applet.Applet { public void init() { } }@Override - Indicates that a method declaration is intended to override a method declaration in a superclass. If a method is annotated with this annotation type but does not override a superclass method, compilers are required to generate an error message. It's present from JDK 5.0 (1.5.0) and up. Actually this is not strictly correct. The smallest possible correct program in Java is an empty source file. ==JavaScript== The empty file is a valid program.

KonsolScript

function main() {

}

Liberty BASIC

end==Lisp== Most Lisp dialects, including Common Lisp, will accept no text (no forms) as a valid program.

Logo

or end a standalone script with "bye" #! /usr/local/bin/logo

bye==LSE64== As with Forth, an empty file is the shortest program. To exit the interpreter at the end of a loaded file: bye ==Lua==

MATLAB

function [varargout] = emptyprogram(varargin) 

==MAXScript== An empty MAXScript file returns "OK" on execution ==Metafont== end

MMIX

LOC #100 Main TRAP 0,Halt,0 // main (argc, argv) {}

Modula-2

MODULE Main;

BEGIN END Main.

Modula-3

MODULE Main;

BEGIN END Main.==MUMPS== The empty file is a valid program.

Nemerle

Compiles with warnings: null Compiles without warnings (so, more correct): module Program {

   Main() : void
   {
   }

}==NetRexx== The following two samples both generate valid programs. This minimal example requires that the file be named to match the class: class emptyThis example will generate it's class based on the file name: method main(args = String[]) static==NewLISP== ;

Objeck

bundle Default { class Empty { function : Main(args : String[]) ~ Nil { } }

Objective-C

Works with: gcc version 4.0.1

int main(int argc, const char **argv) {

   return 0;

}The minimal empty Cocoa/OpenStep application, useful as life-support for many examples given at RosettaCode, is #import

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

 NSAutoreleasePool *pool;
 
 pool = [[NSAutoreleasePool alloc] init];
 NSApp = [NSApplication sharedApplication];
   
 [pool release];
 return 0;

}

OCaml

Works with: Ocaml version 3.09

Actually, the smallest possible correct program in OCaml is an empty source file. ==Octave== An empty text file can be a valid empty program, but since Octave has the concept of "function file" (a file containing a single function; the file is automatically loaded when a function with the same name of the file, save for the extension, is called, and the first function present in the file is used), the name of the empty file matters. E.g. calling an empty file as isempty.m makes unusable the builtin isemptyfunction. ==Oz== === REPL === The simplest program that can be evaluated in the REPL (Emacs mode) is the empty program.

=== Accepted by compiler === The simplest 'program' that can be compiled is a file which contains a single expression. unitSuch a 'program' cannot be executed, though. === Standalone === The simplest standalone program is a root functor that does not define anything. ("Functors" are first-class modules.) functor define

  skip

end

Pascal

program ProgramName;

begin end.The first line is not necessary in modern Pascal dialects. With today's most compilers, the empty program is just: begin end.

Perl

Works with: Perl version 5.8.8

1. !/usr/bin/perl

1;

1. !/usr/bin/perl

exit;

1. !/usr/bin/perl
2. A program without a body will work too
3. !/usr/bin/perlThe smallest possible program is an empty file (zero length). This requires you to specify the interpreter instead of relying on the shell's shebang magic, thus: perl empty.pl. The smallest possible Perl one-liner is perl -e0. ==Perl 6== The empty program is valid and does nothing but return a successful exit code. ==PHP== An empty text file is a correct PHP program that does nothing. ==PicoLisp== (de foo ())==PIR== The :main pragma indicates that a subroutine is the program's entry point. However, if a subroutine is the first (or only, which would also have the effect of making it the first) routine in the program, Parrot will use that. So we may comfortably omit it in this case. .sub empty_program .end

Pike

int main(){}

PL/I

s: proc options (main); end;

PL/SQL

BEGIN

   NULL;

END;==Pop11== Pop11 has two compilers, incremental and batch compiler. For the incremental compiler one can use just empty program text (empty file), or a file containing nothing but a comment, e.g. ;;; This is a valid Pop11 program that does absolutely nothing.The batch compiler generates an executable which starts at a given entry point, so one should provide an empty function. If one wants program that works the same both with incremental compiler and batch compiler the following may be useful: compile_mode :pop11 +strict; define entry_point(); enddefine;

1. _TERMIN_IF DEF POPC_COMPILING

entry_point();Here the batch compiler will stop reading source before call to entry_point while incremental compiler will execute the call, ensuring that in both cases execution will start from the function entry_point. ==PostScript== An empty file is a valid PostScript program that does nothing. Following good programming practice, however, and to ensure that a PostScript printer will interpret a file correctly, one should make the first 4 characters of the file be %!PSIf a particular version of the PS interpreter is needed, this would be included right there: %!PS-2.0 % ...or... %!PS-3.0 % etc==PowerShell== An empty text file is a correct Powershell script that does nothing. ==PSQL== EXECUTE BLOCK AS BEGIN END==ProDOS== This is an acceptable program: IGNORELINE But also you could include a delimiter character recognized by the compiler/interpreter:

==PureBasic== An empty file is a correct PureBasic program that does nothing.

==Python== An empty text file is a correct Python program that does nothing. ==R== An empty text file is a valid empty program ==Raven== An empty text file is an empty program. ==REBOL== The header section is mandatory if you want it to be recognized as a REBOL program. It doesn't have to be filled in though: REBOL []==Retro== An empty file is the smallest valid program.

To save an application doing nothing, you need to do a bit more work though: &bye is boot

REXX

===version 1=== An empty file is a valid empty program; however, for some REXX implementation the first two characters must be /*(i.e. the first line must be a comment) in order to recognize the file as a REXX script: /* empty */

version 2

/**/

version 3

REXX on MVS/TSO requires REXX to be in the first line:

/* REXX */

==Rhope==

Works with: Rhope version alpha 1

Main(0,0) |: :| ==Ruby== An empty file is a valid Ruby program. However, in order to make it runnable on *nix systems, a shebang line is necessary: #!/usr/bin/env ruby

Scala

object emptyProgram { def main(args: Array[String]) {} }

Seed7

$ include "seed7_05.s7i"; const proc: main is noop;

Smalltalk

[]==SNUSP== $# $ sets the instruction pointer (going right), and # halts the program (empty stack). ==SNOBOL4== A valid program requires an end label. The shortest (virtually empty) program is then: end==Standard ML== ;Actually, the smallest possible correct program in Standard ML is an empty source file. ==Suneido== function () { }==Tcl== Nothing is mandatory in Tcl, so an empty file named nothing.tclwould be a valid "empty program".

TUSCRIPT

$$ MODE TUSCRIPT

UNIX Shell

Works with: Bourne Shell

1. !/bin/sh

Works with: Bourne Again SHell

1. !/bin/bash==Unlambda== i (See how i plays so many roles in unlambda?) ==VBScript== An empty .vbs file is considered the smallest runnable code, but the following (a single apostrophe as comment marker) would also be acceptable (along with other non-executing instructions like option explicit.)

'==VHDL== Compiled and simulated by Modelsim: entity dummy is end; architecture empty of dummy is begin end;==Visual Basic .NET==

Works with: Visual Basic .NET version 2005

Module General

   Sub Main()
   End Sub

End Module

X86 Assembly

Works with: NASM version Linux

section .text global _start

_start: mov eax, 1 int 0x80 ret

Works with: MASM

.386 .model flat, stdcall option casemap:none

.code start: ret end start

XQuery

.The dot selects the current context node and returns it unchanged. ==XSLT==

Add other namespaces to the stylesheet attributes (like xmlns:fo="http://www.w3.org/1999/XSL/Format") if you use them. Since XSLT is XML, and transform is a synonym for stylesheet, the example above can be minified to:

This stylesheet echoes the text content of an XML file. The shortest stylesheet without any output would be

==xTalk==

Works with: HyperCard

on startup end startup ==Yorick== An empty file is valid and does nothing.

=Markup Languages= ==HTML== HTML 5, section 11.1.2.4 Optional tags, allows to omit html, head and body tags. The implicit body element can be empty, but the implicit head element must contain a title element, says section 4.2.1 The head element. There seems no rule against an empty title. Therefore, the shortest correct HTML document is:

The shortest correct XHTML document is: