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

<lang ada>procedure Empty is begin

  null; 

end;</lang>

ALGOL 68

Brief form

~

BOLD form

SKIP

AppleScript

An empty .scpt file is considered the smallest runnable code, but the following would also be acceptable. <lang applescript>return</lang>

AWK

Works with: AWK

Works with: gawk

Works with: awka

Works with: awkcc

The empty string (or file) is recognised as valid program that does nothing.

The program

   1

is 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

<lang qbasic>10 END</lang>

Befunge

@

The halt command @ is required because code wraps around. An empty file would be an infinite loop.

Brainf***

Empty program

Note: this works as all non-instruction characters are considered comments. Alternatively, a zero-byte file also works.

C

Works with: gcc version 4.0.3

<lang c>int main (int argc, char **argv) {

 // Note: The arguments may be omitted
 return 0;

}</lang>

C#

Works with: Visual C# version 2005

<lang csharp>static class Program {

   static void Main(string[] args)
   {
   }

}</lang>

C++

Works with: g++ version 4.0.3

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

}</lang>

Clean

module Empty

Start world = world

Compile the project with No Console or No Return Type to suppress printing of the value of the world.

D

Works with: DMD

Works with: GDC

<lang d> void main() {} </lang>

Delphi

See Pascal

E

The shortest possible program:

This is equivalent to:

null

eC

or

class EmptyApp : Application
{
   void Main()
   {

   }
}

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;

Forth

: main   ;

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

Haskell

Standard: Haskell 98

The simplest possible program is a single module using the implicit module header "<lang>module Main(main) where</lang>", and defining the action <lang>main</lang> 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.

IDL

end

J

It returns itself: <lang j> -: ". 1 </lang>

Java

Works with: Java version 1.5+

<lang java>public class EmptyApplet extends java.applet.Applet {

   @Override public void init() {
   }

}</lang>

<lang java>public class EmptyMainClass {

   public static void main(String... args) {
   }

}</lang>

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:

<lang java>method(arg0, arg1, arg2, arg3)</lang>

All of the args will be put into an array in the order they were in the call.

Works with: Java version 1.0+

<lang java>public class EmptyMainClass {

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

}</lang>

<lang java>public class EmptyApplet extends java.applet.Applet {

   public void init() {
   }

}</lang>

@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

Lisp

Most Lisp dialects, including Common Lisp, will accept no text (no forms) as a valid program. <lang lisp></lang>

LSE64

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

bye

MAXScript

An empty MAXScript file returns "OK" on execution

Metafont

<lang metafont>end</lang>

Modula-3

<lang modula3>MODULE Main;

BEGIN END Main.</lang>

Objective-C

Works with: gcc version 4.0.1

<lang objc>int main(int argc, const char **argv) {

   return 0;

}</lang>

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

<lang objc>#import <Cocoa/Cocoa.h>

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

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

}</lang>

OCaml

Works with: Ocaml version 3.09

<lang ocaml>;;</lang>

Actually, the smallest possible correct program in OCaml is an empty source file.

Pascal

<lang pascal>program ProgramName;

begin end.</lang>

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

Perl

Works with: Perl version 5.8.8

<lang perl>#!/usr/bin/perl 1;</lang>

<lang perl>#!/usr/bin/perl exit;</lang>

<lang perl>#!/usr/bin/perl

1. A program without a body will work too</lang>

<lang perl>#!/usr/bin/perl</lang>

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

PHP

An empty text file is a correct PHP program that does nothing.

PL/SQL

BEGIN
  NULL;
END;

Pop11

Pop11 has two compilers, incremental and batch compiler. For incremental compiler one can use just empty program text (empty file). 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;

#_TERMIN_IF DEF POPC_COMPILING
entry_point();

Here 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

In general, the first 4 characters of the file have to be

%!PS

If a particular version of the PS interpreter is needed, this would be included right there:

%!PS-2.0
% ...or...
%!PS-3.0
% etc

Python

An empty text file is a correct Python program that does nothing.

Raven

An empty text file is an empty program.

Rhope

Works with: Rhope version alpha 1

Main(0,0)
|: :|

Scheme

<lang scheme>()</lang>

In the same way as with Lisp, this is also the shortest Scheme program that prints its own source upon execution.

SNUSP

$#

$ sets the instruction pointer (going right), and # halts the program (empty stack).

Standard ML

<lang sml>;</lang>

Actually, the smallest possible correct program in Standard ML is an empty source file.

Tcl

Nothing is mandatory in Tcl, so an empty file named nothing.tcl would be a valid "empty program".

Toka

For interpreted code, nothing is required, although bye is necessary for an empty script to exit (rather than wait for the user to exit the listener). Hence:

bye

Or, for a directly runnable script:

#! /usr/bin/toka
bye

For compiled code, the simplest program is an empty quote:

 [ ]

Again, to exit the listener, you will still need user input if this is not followed with bye.

TI-83 BASIC

:

UNIX Shell

Works with: Bourne Shell

#!/bin/sh

Works with: Bourne Again SHell

#!/bin/bash

Unlambda

i

(See how i plays so many roles in unlambda?)

Visual Basic .NET

Works with: Visual Basic .NET version 2005

<lang vbnet>Module General

   Sub Main()
   End Sub

End Module</lang>

XSLT

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
</xsl:stylesheet>

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 <lang>transform</lang> is a synonym for <lang>stylesheet</lang>, the example above can be minified to:

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0"/>

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

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <template match="/" />
</transform>

xTalk

Works with: HyperCard

on startup
  
end startup

Markup Languages

Plain TeX

\bye

LaTeX

Works with: pdfeTeXk version 3.141592-1.30.4-2.2 (Web2C 7.5.5)

Works with: LaTeX2e version 2003/12/01

\documentclass{article}
\begin{document}
\end{document}