Why do we use main function in almost all the programming languages?

Question

Why do we need the main function and can't we execute the code without it? Can't we just execute our code outside the main function by making our own function?

Answer 1

Well, there needs to be somewhere your code starts executing(apart from the necessary initialisation and cleanup, which isn't readily visible to the programmer in the form of code).

Let's take reference to the C language, which influenced almost every other programming language. Documentation for main() in C states

Every C program coded to run in a hosted execution environment contains the definition (not the prototype) of a function named main, which is the designated start of the program.

The main function is called at program startup, after all objects with static storage duration are initialized. It is the designated entry point to a program that is executed in a hosted environment (that is, with an operating system).

Now if we are talking about assembly language, here is what an assembly code would look like

    org  0x100       

    mov  dx, msg       
    mov  ah, 9         
    int  0x21         

    mov  ah, 0x4c      
    int  0x21         

    msg  db 'Where is my main() here?', 0x0d, 0x0a, '$'

And now python

print("No main!")

As you can see, main() isn't mandated, it's rather a specification and a convention which has been followed all along for the languages that do mention it(likes of C, C++, Java), and well, it does serve a purpose. And yes, you can have a program that doesn't start from main(), at least in C to my knowledge(gcc via nostartfiles option).

Answer 2

This is a design decision in the C language. Besides making main a reserved name, this is quite harmless and you can always implement the main function as a mere call to your favorite function. Also note that main has a fixed prototype, that allows to interact with the OS.

Without this convention, you would need to tell the linker what is the entry point in the executable by some external method or a special C declaration.

Other languages have different conventions. For instance Pascal and FORTRAN demand a Program declaration. Python works like an implicit function at file level.

Answer 3

This is partly to do with the grammatical structure of the language. Consider Java for example:

• At the top level, each file is a compilation unit,
• A compilation unit contains type declarations (classes, interfaces or enums),
• A type declaration contains member declarations (fields, methods, constructors...),
• A method or constructor declaration contains statements.

Ultimately, statements are what get executed. The language's grammar is simpler by not having extra rules to allow statements at the top level, only declarations. The semantics of the language are also simpler when you consider programs whose declarations span multiple files, since there is no need to define what order statements at the top levels of different files should be executed in. The implementation is also potentially simpler because declarations don't need to be ordered.

Other languages such as Python allow statements at the top level because all declarations (e.g. def or class) are a kind of statement ─ in such languages, even import is a statement that is executed, so the order of execution of top-level statements in multiple files is determined by the order of import statements in the files which import them. This tends to be the case for more dynamic languages, which will load modules and resolve names to declarations at runtime, so that there is no need for the compiler to find all of the declarations before it compiles statements, because the compiler doesn't need to know the meanings of the names which occur in those statements.

Answer 4

An important philosophical point you might want to consider: Is there really a fundamental difference between declaring a place where the program starts, and simply having the program start at the top of a specific file? main, in all the languages that have such a thing, is really just a marker that says "start here." Some languages have a main marker, and some appear not to, but really, for those languages that don't seem to have a declared main, they still have a place to start — it's just implicitly chosen!

So another way to look at this thought experiment: In languages like C# and Pascal we might explicitly write main() to tell the program where to begin. But is that really truly different from the compiler invisibly inserting main() { at the start of the file and } at the end if we didn't write such a thing ourselves? Looked at this way, there's always a main() — but you just may not have written it yourself.

So that's the real difference:

• Some languages require you to say where the program begins. (C, C++, Pascal, Java, Rust.)
• Some languages allow you to say where the program begins, and they have a rule for where it begins if you don't explicitly state otherwise. (Modern C#.)
• Some languages only have a rule for where the program begins, and it always begins there. (JavaScript, Python, Ruby, Lisp.)

The program always starts somewhere. The only real question is whether your language lets you or forces you to choose that somewhere, or whether it chooses that somewhere by itself.

---

(Addendum, just for completeness: There's also another category in the bullet points above for declarative languages like SQL and Prolog, where there's really no main at all: The language implementation decides what order to run the pieces of your program in, and whether A is run before B is really up to the computer. Then there's arguably also a category for languages like HTML and CSS and SVG, where it's arguably still a "program," but how it even runs at all doesn't matter as long as the output is correct. There are lots of ways to describe a program, and lots of different ways to have or not have a main; one size does not even come remotely close to fitting all!)

Answer 5

An application or program has a start. That's the "main" function. Many languages do not call it "main", and in many it is implicit (e.g. the function defined by the script as a whole).

On the other hand, libraries are collection of functions (and code, data, resources, etc.), and do not have a starting point. You chose your own "starting point" every time you call it. (Some libraries have initialization, and some have state.)

Answer 6

Why do we need the main function and can't we execute the code without it?

It depends entirely on how the language is defined. Programming languages are man-made constructs anyway, so we can make them as we like. With that in mind, we don't "need" a main function, and we can well have a language that can read from outside any function.

Now, I'm not sure if you wanted discount them for some reason, but many interpreted "scripting" languages, like e.g. Perl, Python, and the various shell languages are good examples of languages where the tooling is happy with code in the top level, outside functions. But for non-trivial programs, it's often useful for us humans to structure the code using functions, including a main function (even if you have to call it explicitly.) Since larger programs will use functions anyway, and for smaller programs, it's only an extra few lines of boilerplate, it's not a big leap for a language designer to choose that all code must reside in functions. It might make the language syntax slightly more straightforward to define, too.

Answer 7

A lot of great answers have already been given, but I would like to name some additional aspects I find quite important as well: not having to define a main function as the entry point encourages less encapsulation and thus less clean, in general uglier (and sometimes also even unusable) code.

This is because high indentation levels are almost always regarded as something you should seek to avoid, and thus code that should have been separated among different classes, methods, functions or even modules is just sequentially written down in languages that support it. In addition, it prevents that callers need to execute arbitrary code at runtime when importing modules - there is a reason why idioms like if __name__ == "__main__" are always recommended, even in smaller projects, in languages like Python.