Entry point

Last updated
How the Main() might look in C# source code. Different parts are labeled for reference. Program-entry-point-demonstration-CSharp.png
How the Main() might look in C# source code. Different parts are labeled for reference.

In computer programming, an entry point is the place in a program where the execution of a program begins, and where the program has access to command line arguments. [1]

Contents

To start a program's execution, the loader or operating system passes control to its entry point. (During booting, the operating system itself is the program). This marks the transition from load time (and dynamic link time, if present) to run time.

For some operating systems and programming languages, the entry point is in a runtime library, a set of support functions for the language. The library code initializes the program and then passes control to the program proper. In other cases, the program may initialize the runtime library itself. [2]

In simple systems, execution begins at the first statement, which is common in interpreted languages, simple executable formats, and boot loaders. In other cases, the entry point is at some other known memory address which can be an absolute address or relative address (offset).

Alternatively, execution of a program can begin at a named point, either with a conventional name defined by the programming language or operating system or at a caller-specified name. In many C-family languages, this is a function called main; as a result, the entry point is often known as the main function. [3]

In JVM languages, such as Java, the entry point is a static method called main; in CLI languages such as C# the entry point is a static method named Main. [4]

Usage

Entry points apply both to source code and to executable files. However, in day-to-day software development, programmers specify the entry points only in source code, which makes them much better known. Entry points in executable files depend on the application binary interface (ABI) of the actual operating system, and are generated by the compiler or linker (if not fixed by the ABI). Other linked object files may also have entry points, which are used later by the linker when generating entry points of an executable file.

Entry points are capable of passing on command arguments, variables, or other information as a local variable used by the Main() method. This way, specific options may be set upon execution of the program, and then interpreted by the program. Many programs use this as an alternative way to configure different settings, or perform a set variety of actions using a single program.

Contemporary

In most of today's popular programming languages and operating systems, a computer program usually only has a single entry point.

In C, C++, D, Zig, Rust and Kotlin programs this is a function named main; in Java it is a static method named main (although the class must be specified at the invocation time), and in C# it is a static method named Main. [5] [6]

In many major operating systems, the standard executable format has a single entry point. In the Executable and Linkable Format (ELF), used in Unix and Unix-like systems such as Linux, the entry point is specified in the e_entry field of the ELF header. In the GNU Compiler Collection (gcc), the entry point used by the linker is the _start symbol. Similarly, in the Portable Executable format, used in Microsoft Windows, the entry point is specified by the AddressOfEntryPoint field, which is inherited from COFF. In COM files, the entry point is at the fixed offset of 0100h.

One exception to the single-entry-point paradigm is Android. Android applications do not have a single entry point  there is no special main function. Instead, they have essential components (activities and services) which the system can load and run as needed. [7]

An occasionally used technique is the fat binary, which consists of several executables for different targets packaged in a single file. Most commonly, this is implemented by a single overall entry point, which is compatible with all targets and branches to the target-specific entry point. Alternative techniques include storing separate executables in separate forks, each with its own entry point, which is then selected by the operating system.

Historical

Historically, and in some contemporary legacy systems, such as VMS and OS/400, computer programs have a multitude of entry points, each corresponding to the different functionalities of the program. The usual way to denote entry points, as used system-wide in VMS and in PL/I and MACRO programs, is to append them at the end of the name of the executable image, delimited by a dollar sign ($), e.g. directory.exe$make.

The Apple I computer also used this to some degree. For example, an alternative entry point in Apple I's BASIC would keep the BASIC program useful when the reset button was accidentally pushed.[ clarification needed ]

Exit point

In general, programs can exit at any time by returning to the operating system or crashing. Programs in interpreted languages return control to the interpreter, but programs in compiled languages must return to the operating system, otherwise the processor will simply continue executing beyond the end of the program, resulting in undefined behavior.

Usually, there is not a single exit point specified in a program. However, in other cases runtimes ensure that programs always terminate in a structured way via a single exit point, which is guaranteed unless the runtime itself crashes; this allows cleanup code to be run, such as atexit handlers. This can be done by either requiring that programs terminate by returning from the main function, by calling a specific exit function, or by the runtime catching exceptions or operating system signals.

Programming languages

In many programming languages, the main function is where a program starts its execution. It enables high-level organization of the program's functionality, and typically has access to the command arguments given to the program when it was executed.

The main function is generally the first programmer-written function that runs when a program starts, and is invoked directly from the system-specific initialization contained in the runtime environment (crt0 or equivalent). However, some languages can execute user-written functions before main runs, such as the constructors of C++ global objects.

In other languages, notably many interpreted languages, execution begins at the first statement in the program.

A non-exhaustive list of programming languages follows, describing their way of defining the main entry point:

APL

In APL, when a workspace is loaded, the contents of "quad LX" (latent expression) variable is interpreted as an APL expression and executed.

C and C++

In C and C++, the function prototype of the main function must be equivalent to one of the following:

intmain(void);intmain();intmain(intargc,char**argv);intmain(intargc,char*argv[]);intmain(intargc,char**argv,char**env);// more specifically in C// NOT according to the ISO C standard 5.1.2.2.1// BUT in embedded programming depending on the µC, this form is also usedvoidmain(void);

Main function looks like entry point for application programmers (the application's entry point or main entry point). System programming reveals more information about the program, and specifies the entry point elsewhere (in initialization procedure, or in reset interrupt vector for standalone programs).

The parameters argc, argument count, and argv, argument vector, [8] respectively give the number and values of the program's command-line arguments. The names of argc and argv may be any valid identifier in C, but it is common convention to use these names. In C++, the names are to be taken literally, and the "void" in the parameter list is to be omitted, if strict conformance is desired. [9] Other platform-dependent formats are also allowed by the C and C++ standards, except that in C++ the return type must always be int; [10] for example, Unix (though not POSIX.1) and Windows have a third argument giving the program's environment, otherwise accessible through getenv in stdlib.h :

intmain(intargc,char**argv,char**envp);

Darwin-based operating systems, such as macOS, have a fourth parameter containing arbitrary OS-supplied information, such as the path to the executing binary: [11]

intmain(intargc,char**argv,char**envp,char**apple);

The value returned from the main function becomes the exit status of the process, though the C standard only ascribes specific meaning to two values: EXIT_SUCCESS (traditionally 0) and EXIT_FAILURE. The meaning of other possible return values is implementation-defined. In case a return value is not defined by the programmer, an implicit return 0; at the end of the main() function is inserted by the compiler; this behavior is required by the C++ standard.

It is guaranteed that argc is non-negative and that argv[argc] is a null pointer. By convention, the command-line arguments specified by argc and argv include the name of the program as the first element if argc is greater than 0; if a user types a command of "rm file", the shell will initialise the rm process with argc = 2 and argv = {"rm", "file", NULL}. As argv[0] is the name that processes appear under in ps , top etc., some programs, such as daemons or those running within an interpreter or virtual machine (where argv[0] would be the name of the host executable), may choose to alter their argv to give a more descriptive argv[0], usually by means of the exec system call.

The main() function is special; normally every C and C++ program must define it exactly once.

If declared, main() must be declared as if it has external linkage; it cannot be declared static or inline.

In C++, main() must be in the global namespace (i.e. ::main), cannot be overloaded, and cannot be a member function, although the name is not otherwise reserved, and may be used for member functions, classes, enumerations, or non-member functions in other namespaces. In C++ (unlike C) main() cannot be called recursively and cannot have its address taken.

C#

When executing a program written in C#, the CLR searches for a static method marked with the .entrypoint IL directive, which takes either no arguments, or a single argument of type string[], and has a return type of void or int, and executes it. [12]

staticvoidMain();staticvoidMain(string[]args);staticintMain();staticintMain(string[]args);

Command-line arguments are passed in args, similar to how it is done in Java. For versions of Main() returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

Since C#7.1 there are four more possible signatures of the entry point, which allow asynchronous execution in the Main() Method. [13]

staticasyncTaskMain()staticasyncTask<int>Main()staticasyncTaskMain(string[])staticasyncTask<int>Main(string[])

The Task and Task<int> types are the asynchronous equivalents of void and int. async is required to allow the use of asynchrony (the await keyword) inside the method.

Clean

Clean is a functional programming language based on graph rewriting. The initial node is named Start and is of type *World -> *World if it changes the world or some fixed type if the program only prints the result after reducing Start.

Start::*World->*WorldStartworld=startIO...

Or even simpler

Start::StringStart="Hello, world!"

One tells the compiler which option to use to generate the executable file.

Common Lisp

ANSI Common Lisp does not define a main function; instead, the code is read and evaluated from top to bottom in a source file. However, the following code will emulate a main function.

(defunhello-main()(formatt"Hello World!~%"))(hello-main)

D

In D, the function prototype of the main function looks like one of the following:

voidmain();voidmain(string[]args);intmain();intmain(string[]args);

Command-line arguments are passed in args, similar to how it is done in C# or Java. For versions of main() returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

Dart

Dart is a general-purpose programming language that is often used for building web and mobile applications. Like many other programming languages, Dart has an entry point that serves as the starting point for a Dart program. The entry point is the first function that is executed when a program runs. In Dart, the entry point is typically a function named main . When a Dart program is run, the Dart runtime looks for a function named main and executes it. Any Dart code that is intended to be executed when the program starts should be included in the main function. Here is an example of a simple main function in Dart:

voidmain(){print("Hello, world!");}

In this example, the main function simply prints the text Hello, world! to the console when the program is run. This code will be executed automatically when the Dart program is run.

It is important to note that while the main function is the default entry point for a Dart program, it is possible to specify a different entry point if needed. This can be done using the @pragma("vm:entry-point") annotation in Dart. However, in most cases, the main function is the entry point that should be used for Dart programs.

FORTRAN

FORTRAN does not have a main subroutine or function. Instead a PROGRAM statement as the first line can be used to specify that a program unit is a main program, as shown below. The PROGRAM statement cannot be used for recursive calls. [14]

PROGRAM HELLOPRINT*,"Cint!"END PROGRAM HELLO

Some versions of Fortran, such as those on the IBM System/360 and successor mainframes, do not support the PROGRAM statement. Many compilers from other software manufacturers will allow a fortran program to be compiled without a PROGRAM statement. In these cases, whatever module that has any non-comment statement where no SUBROUTINE, FUNCTION or BLOCK DATA statement occurs, is considered to be the Main program.

GNAT

Using GNAT, the programmer is not required to write a function named main; a source file containing a single subprogram can be compiled to an executable. The binder will however create a package ada_main, which will contain and export a C-style main function.

Go

In Go programming language, program execution starts with the main function of the package main

packagemainimport"fmt"funcmain(){fmt.Println("Hello, World!")}

There is no way to access arguments or a return code outside of the standard library in Go. These can be accessed via os.Args and os.Exit respectively, both of which are included in the "os" package.

Haskell

A Haskell program must contain a name main bound to a value of type IO t, for some type t; [15] which is usually IO (). IO is a monad, which organizes side-effects in terms of purely functional code. [16] The main value represents the side-effects-ful computation done by the program. The result of the computation represented by main is discarded; that is why main usually has type IO (), which indicates that the type of the result of the computation is (), the unit type, which contains no information.

main::IO()main=putStrLn"Hello, World!"

Command line arguments are not given to main; they must be fetched using another IO action, such as System.Environment.getArgs .

Java

Java programs start executing at the main method of a class, [17] [18] [19] [20] which has one of the following method headings:

publicstaticvoidmain(String[]args)publicstaticvoidmain(String...args)publicstaticvoidmain(Stringargs[])voidmain()

Command-line arguments are passed in args. As in C and C++, the name "main()" is special. Java's main methods do not return a value directly, but one can be passed by using the System.exit() method.

Unlike C, the name of the program is not included in args, because it is the name of the class that contains the main method, so it is already known. Also unlike C, the number of arguments need not be included, since arrays in Java have a field that keeps track of how many elements there are.

The main function must be included within a class. This is because in Java everything has to be contained within a class. For instance, a hello world program in Java may look like:

publicclassHelloWorld{publicstaticvoidmain(String[]args){System.out.println("Hello, world!");}}

To run this program, one must call java HelloWorld in the directory where the compiled class file HelloWorld.class) exists. Alternatively, executable JAR files use a manifest file to specify the entry point in a manner that is filesystem-independent from the user's perspective.

In FMSLogo, the procedures when loaded do not execute. To make them execute, it is necessary to use this code:

to procname  ...                 ; Startup commands (such as print [Welcome]) end
make "startup [procname]

The variable startup is used for the startup list of actions, but the convention is that this calls a procedure that runs the actions. That procedure may be of any name.

OCaml

OCaml has no main function. Programs are evaluated from top to bottom.

Command-line arguments are available in an array named Sys.argv and the exit status is 0 by default.

Example:

print_endline"Hello World"

Pascal

In Pascal, the main procedure is the only unnamed block in the program. Because Pascal programs define procedures and functions in a more rigorous bottom-up order than C, C++ or Java programs, the main procedure is usually the last block in the program. Pascal does not have a special meaning for the name "main" or any similar name.

programHello(Output);beginwriteln('Hello, world!');end.

Command-line arguments are counted in ParamCount and accessible as strings by ParamStr(n), with n between 0 and ParamCount.

Versions of Pascal that support units or modules may also contain an unnamed block in each, which is used to initialize the module. These blocks are executed before the main program entry point is called.

Perl

In Perl, there is no main function. Statements are executed from top to bottom, although statements in a BEGIN block are executed before normal statements.

Command-line arguments are available in the special array @ARGV. Unlike C, @ARGV does not contain the name of the program, which is $0.

PHP

PHP does not have a "main" function. Starting from the first line of a PHP script, any code not encapsulated by a function header is executed as soon as it is seen.

Pike

In Pike syntax is similar to that of C and C++. The execution begins at main. The "argc" variable keeps the number of arguments passed to the program. The "argv" variable holds the value associated with the arguments passed to the program.

Example:

intmain(intargc,array(string)argv)

Python

Python programs are evaluated top-to-bottom, as is usual in scripting languages: the entry point is the start of the source code. Since definitions must precede use, programs are typically structured with definitions at the top and the code to execute at the bottom (unindented), similar to code for a one-pass compiler, such as in Pascal.

Alternatively, a program can be structured with an explicit main function containing the code to be executed when a program is executed directly, but which can also be invoked by importing the program as a module and calling the function. This can be done by the following idiom, which relies on the internal variable __name__ being set to __main__ when a program is executed, but not when it is imported as a module (in which case it is instead set to the module name); there are many variants of this structure: [21] [22] [23]

importsysdefmain(argv):n=int(argv[1])print(n+1)if__name__=='__main__':sys.exit(main(sys.argv))

In this idiom, the call to the named entry point main is explicit, and the interaction with the operating system (receiving the arguments, calling system exit) are done explicitly by library calls, which are ultimately handled by the Python runtime. This contrast with C, where these are done implicitly by the runtime, based on convention.

QB64

The QB64 language has no main function, the code that is not within a function, or subroutine is executed first, from top to bottom:

print"Hello World! a =";a=getInteger(1.8d):printa
functiongetInteger(nasdouble)getInteger=int(n)endfunction

Command line arguments (if any) can be read using the COMMAND$ function:

dimsharedcommandlineasstringcommandline=COMMAND$
'Several space-separated command line arguments can be read using COMMAND$(n)commandline1=COMMAND$(2)

Ruby

In Ruby, there is no distinct main function. Instead, code written outside of any class .. end or module .. end scope is executed in the context of a special "main" object. This object can be accessed using self:

irb(main):001:0> self=> main

It has the following properties:

irb(main):002:0> self.class=> Objectirb(main):003:0> self.class.ancestors=> [Object, Kernel, BasicObject]

Methods defined outside of a class or module scope are defined as private methods of the "main" object. Since the class of "main" is Object, such methods become private methods of almost every object:

irb(main):004:0> deffooirb(main):005:1> 42irb(main):006:1> end=> nilirb(main):007:0> foo=> 42irb(main):008:0> [].fooNoMethodError: private method `foo' called for []:Array from (irb):8 from /usr/bin/irb:12:in `<main>'irb(main):009:0> false.fooNoMethodError: private method `foo' called for false:FalseClass from (irb):9 from /usr/bin/irb:12:in `<main>'

The number and values of command-line arguments can be determined using the ARGV constant array:

$ irb/dev/ttyfoobar  tty(main):001:0> ARGVARGV=> ["foo", "bar"]tty(main):002:0> ARGV.sizeARGV.size=> 2

The first element of ARGV, ARGV[0], contains the first command-line argument, not the name of program executed, as in C. The name of program is available using $0 or $PROGRAM_NAME. [24]

Similar to Python, one could use:

if__FILE__==$PROGRAM_NAME# Put "main" code hereend

to execute some code only if its file was specified in the ruby invocation.

Rust

In Rust, the entry point of a program is a function named main. Typically, this function is situated in a file called main.rs or lib.rs.

// In `main.rs`fnmain(){println!("Hello, World!");}

Additionally, as of Rust 1.26.0, the main function may return a Result: [25]

fnmain()-> Result<(),std::io::Error>{println!("Hello, World!");Ok(())// Return a type `Result` of value `Ok` with the content `()`, i.e. an empty tuple.}

Swift

When run in an Xcode Playground, [26] Swift behaves like a scripting language, executing statements from top to bottom; top-level code is allowed.

// HelloWorld.playgroundlethello="hello"letworld="world"lethelloWorld=hello+" "+worldprint(helloWorld)// hello world

Cocoa- and Cocoa Touch-based applications written in Swift are usually initialized with the @NSApplicationMain and @UIApplicationMain attributes, respectively. Those attributes are equivalent in their purpose to the main.m file in Objective-C projects: they implicitly declare the main function that calls UIApplicationMain(_:_:_:_:) [27] which creates an instance of UIApplication. [28] The following code is the default way to initialize a Cocoa Touch-based iOS app and declare its application delegate.

// AppDelegate.swiftimportUIKit@UIApplicationMainclassAppDelegate:UIResponder,UIApplicationDelegate{varwindow:UIWindow?funcapplication(_application:UIApplication,didFinishLaunchingWithOptionslaunchOptions:[UIApplication.LaunchOptionsKey:Any]?)->Bool{returntrue}}

Visual Basic

In Visual Basic, when a project contains no forms, the startup object may be the Main() procedure. The Command$ function can be optionally used to access the argument portion of the command line used to launch the program:

SubMain()Debug.Print"Hello World!"MsgBox"Arguments if any are: "&Command$EndSub

Xojo

In Xojo, there are two different project types, each with a different main entry point. Desktop (GUI) applications start with the App.Open event of the project's Application object. Console applications start with the App.Run event of the project's ConsoleApplication object. In both instances, the main function is automatically generated, and cannot be removed from the project.

See also

Related Research Articles

<span class="mw-page-title-main">Quine (computing)</span> Self-replicating program

A quine is a computer program that takes no input and produces a copy of its own source code as its only output. The standard terms for these programs in the computability theory and computer science literature are "self-replicating programs", "self-reproducing programs", and "self-copying programs".

Common Intermediate Language (CIL), formerly called Microsoft Intermediate Language (MSIL) or Intermediate Language (IL), is the intermediate language binary instruction set defined within the Common Language Infrastructure (CLI) specification. CIL instructions are executed by a CIL-compatible runtime environment such as the Common Language Runtime. Languages which target the CLI compile to CIL. CIL is object-oriented, stack-based bytecode. Runtimes typically just-in-time compile CIL instructions into native code.

In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. It is a kind of lazy evaluation that refers specifically to the instantiation of objects or other resources.

In mathematics and computer science, a higher-order function (HOF) is a function that does at least one of the following:

<span class="mw-page-title-main">C syntax</span> Set of rules defining correctly structured programs

The syntax of the C programming language is the set of rules governing writing of software in C. It is designed to allow for programs that are extremely terse, have a close relationship with the resulting object code, and yet provide relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development.

In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In some languages, particularly C++, function objects are often called functors.

In class-based, object-oriented programming, a constructor is a special type of function called to create an object. It prepares the new object for use, often accepting arguments that the constructor uses to set required member variables.

<span class="mw-page-title-main">Java syntax</span> Set of rules defining correctly structured program

The syntax of Java is the set of rules defining how a Java program is written and interpreted.

In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.

In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.

In software engineering, a fluent interface is an object-oriented API whose design relies extensively on method chaining. Its goal is to increase code legibility by creating a domain-specific language (DSL). The term was coined in 2005 by Eric Evans and Martin Fowler.

Java Native Access (JNA) is a community-developed library that provides Java programs easy access to native shared libraries without using the Java Native Interface (JNI). JNA's design aims to provide native access in a natural way with a minimum of effort. Unlike JNI, no boilerplate or generated glue code is required.

In computer programming, variadic templates are templates that take a variable number of arguments.

Wt is an open-source widget-centric web framework for the C++ programming language. It has an API resembling that of Qt framework, also using a widget-tree and an event-driven signal/slot system.

Getopt is a C library function used to parse command-line options of the Unix/POSIX style. It is a part of the POSIX specification, and is universal to Unix-like systems. It is also the name of a Unix program for parsing command line arguments in shell scripts.

Different command-line argument parsing methods are used by different programming languages to parse command-line arguments.

OpenHMPP - programming standard for heterogeneous computing. Based on a set of compiler directives, standard is a programming model designed to handle hardware accelerators without the complexity associated with GPU programming. This approach based on directives has been implemented because they enable a loose relationship between an application code and the use of a hardware accelerator (HWA).

Nemerle is a general-purpose, high-level, statically typed programming language designed for platforms using the Common Language Infrastructure (.NET/Mono). It offers functional, object-oriented, aspect-oriented, reflective and imperative features. It has a simple C#-like syntax and a powerful metaprogramming system.

Charm is a computer programming language devised in the early 1990s with similarities to the RTL/2, Pascal and C languages in addition to containing some unique features of its own. The Charm language is defined by a context-free grammar amenable to being processed by recursive descent parser as described in seminal books on compiler design.

In software engineering, the module pattern is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language with incomplete direct support for the concept.

References

  1. "In Computing, what is an Entry Point? (with picture)". wiseGEEK. Archived from the original on 2020-08-05. Retrieved 2020-01-22.
  2. Decker, Karsten M.; Rehmann, René M. (1994). Programming Environments for Massively Parallel Distributed Systems: Working Conference of the Ifip Wg 10.3, April 25-29, 1994. Springer Science & Business Media. ISBN   978-3-7643-5090-1.
  3. "Main Method in C#". GeeksforGeeks. 2018-11-30. Archived from the original on 2020-07-31. Retrieved 2020-01-22.
  4. Wagner, Bill (2017-08-01). "Main() / Entry Points (C# Programming Guide) - Microsoft Developer Network". docs.microsoft.com. Archived from the original on 2020-11-11. Retrieved 2018-12-03.
  5. "The main() function". ibm.com. IBM. Archived from the original on 2017-09-10. Retrieved 2014-05-08.
  6. "Main() and Command-Line Arguments (C# Programming Guide)". Msdn.microsoft.com. Archived from the original on 2014-06-09. Retrieved 2014-05-08.
  7. "Application Fundamentals". Android Development. linuxtopia.org. Archived from the original on 2013-12-31. Retrieved 2014-02-19.
  8. argv: the vector term in this variable's name is used in traditional sense to refer to strings.
  9. "Parameter types and names of main". Archived from the original on 2012-11-10. Retrieved 2016-07-28.
  10. Section 3.6.1.2, Standard C++ 2011 edition.
  11. "The char *apple Argument Vector". Archived from the original on 2015-12-22. Retrieved 2014-05-12.
  12. "Console Applications in .NET, or Teaching a New Dog Old Tricks". Msdn.microsoft.com. 2003-06-12. Archived from the original on 2008-02-04. Retrieved 2013-08-19.
  13. "The official repo for the design of the C# programming language: Dotnet/Csharplang". GitHub . 2019-08-26.
  14. XL FORTRAN for AIX. Language Reference. Third Edition, 1994. IBM
  15. "The Haskell 98 Report: Modules". Haskell.org. Archived from the original on 2013-08-19. Retrieved 2013-08-19.
  16. Some Haskell Misconceptions: Idiomatic Code, Purity, Laziness, and IO Archived 2010-07-27 at the Wayback Machine — on Haskell's monadic IO>
  17. "The Java Language Environment". Oracle. Archived from the original on 2019-04-20. Retrieved 2020-03-14. Within the HelloWorld class, we declare a single method called main() which in turn contains a single method invocation to display the string "Hello world!" on the standard output. The statement that prints "Hello world!" does so by invoking the println method of the out object. The out object is a class variable in the System class that performs output operations on files.
  18. Schildt, Herbert (2019). Java : a beginner's guide. New York: McGraw-Hill Education. p. 46. ISBN   978-1-260-44022-5. OCLC   1061561931. //A JAVA program begins with a call to main ().
  19. "Hello, World! - Free Interactive Java Tutorial". Learn Java. Retrieved 2020-03-14. In Java, every line of code that can actually run needs to be inside a class. "public class Main {}" declares a class named Main, which is public, that means that any other class can access it.
  20. "Hello, World! - Free Interactive Java Tutorial". Learn Java. Retrieved 2020-03-14. "public static void main(String[] args) {} " is the entry point of our Java program. the main method has to have this exact signature in order to be able to run our program.
  21. Guido van Rossum (May 15, 2003). "Python main() functions". Archived from the original on July 11, 2015. Retrieved June 29, 2015, comments
  22. Code Like a Pythonista: Idiomatic Python Archived 2014-05-27 at the Wayback Machine —on Python scripts used as modules
  23. Ned Batchelder (6 June 2003). "Python main() functions". Archived from the original on 20 September 2015. Retrieved 29 June 2015.
  24. Programming Ruby: The Pragmatic Programmer's Guide, Ruby and Its World Archived 2013-08-31 at the Wayback Machine — on Ruby ARGV
  25. "Releases.md". GitHub Rust. Archived from the original on 2015-05-15. Retrieved 15 February 2019.
  26. Not to be confused with Swift Playgrounds Archived 2022-07-08 at the Wayback Machine , an Apple-developed iPad app for learning the Swift programming language.
  27. "UIApplicationMain(_:_:_:_:) — UIKit". Apple Developer Documentation. Archived from the original on 2019-01-12. Retrieved 2019-01-12.
  28. "UIApplication — UIKit". Apple Developer Documentation. Archived from the original on 2019-01-13. Retrieved 2019-01-12.