An exploration of why Python doesn't require a 'main' function

https://utcc.utoronto.ca/~cks/space/blog/python/WhyNoMainFunction

by zdw • 6 years ago

130 102 6 years ago

utcc.utoronto.ca

jimbob452• 6 years ago

Why not keep “main” as a reserved function word and just append the magic “if name == “__main__” behind the scenes if that function is seen? For a language focused on immediate usability, it’s a stupid first hurdle to have to clear to greet the world.

kbirkeland• 6 years ago

"Explicit is better than implicit" - PEP20

I wouldn't really say that it's a hurdle to greeting the world since you can just throw `print("Hello world")` at the top level.

gizmo686• 6 years ago

1) One of pythons design philosophies is "explicit is better than implicit".

2) This is not a hurdle to hello world.

    print("Hello World")

is a complete program that does exactly what you want. Needing to wrap it in a function would be an additional hurdle.

For complex programs; that is a hurdle well worth jumping. But for simple scripts (python is a scripting language), or teaching purposes, it is not always needed.

kzrdude• 6 years ago

Ad 1,

the current idiom uses dunder name, which is implicitly defined and looks special.

Making main special would be about the same level of a solution, yet more conventional

jimbob452• 6 years ago

I understand that what you have is a complete program but every new Pythonist is going to next read the documentation that says, “Having a main method is a really good idea” and go try to implement one. Sure, in 1% of cases, you’ll need the granular control over how main is called but since when do languages cater to the 1%?

simias• 6 years ago

I think the people replying "explicit is better than implicit" are cargo culting, there are quite a few areas where Python was more than happy to add a bit of magic to make the language smoother to use. Besides `if __name__ == "__main__"` is hardly explicit if you're not familiar with the idiom (what's `__name__` exactly? Is it the file name? The process name? When is and isn't it set to `__main__`?).

I can think of a real problem with your approach however: in languages with a main function you usually can't have top level statements, only declarations. So in C if you write at the top level `while (1) { printf("Hi\n"); }` you get a compilation error. Now as compilers get smarter you can get constexprs in some languages but it's still very specific and entirely static. I guess you could also mention global constructors, but that generally comes with severe caveats and should be used very carefully.

Python on the other hand treats top level code like anything else. That's why the `if __name__ == "__main__"` pattern even works in the first place. Having a real-looking main function would send the wrong message IMO, because it would make people that it's the real entry point of the program which it's not, in Python the entry point is the first line of the file being executed, end of story.

I do think that Python would benefit having a clearer and more explicitly named helper function or variable for this use case however, something like "if this_file_is_executed()" or something like that. At least this way you'd know what the code is doing instead of this awkward anti-pattern being used these days. But of course by now it's probably not worth changing.

andybak• 6 years ago

You only need the __main__ magic if you want a python file to be both a module and an executable script. This is a moderately advanced requirement. Beginners will tend to write scripts OR importable modules.

jpindar• 6 years ago

"if name == “__main__” isn't magic, it serves a purpose. Sometimes name == “__main__” and sometimes it doesn't, and I want to specify different behavior in different cases.

Here, name is the name of the module. When the module is run by itself, this is the same as __main__, in which case I want the things specified by the if to run right away. This could be calling a main function, but a lot of times it's just is some tests or examples.

When the module is imported into another file, it's name is not the same as __main__. In this case I usually only want things in it to do stuff when they are called by the other file.

This doesn't have anything to do with a function literally called "main" though.

  if __name__ == "__main__":
    main()

Is a common idiom, but there's no connection between the two uses of the word main.

ktpsns• 6 years ago

Here's a thing: Coming from a world of Perl, PHP, Ruby, Bash, BASIC, batch etc. scripts, a main function is not neccessary at all. The procedural code just starts from the first line.

With this in mind, it is weird to even ask for a main function. :-)

pantaloony• 6 years ago

My immediate reaction was “it does—but it’s in the interpreter so of course you don’t have to write it”.

marcosdumay• 6 years ago

And you can perfectly well compile them and keep that same behavior.

C's entry point is in the runtime too, it's not your main function (but yeah, the optimizer will probably inline your main). At the end of the day, there's no real difference between compiled and interpreted languages, all the difference is on the toolset.

benbristow2• 6 years ago

Even with those languages, I find a main method is a good idea just for local-scoping of variables compared to the top level variables being 'global' by default.

munk-a2• 6 years ago

PHP is actually my favorite here - since the standard way people use it (behind a webserver) means that old-style PHP had as many entry points as it had files which could get really confusing really quickly.

Modern PHP usage will generally concede the point now and pipe all requests through internal routing executed off of a single script exposed to the webserver/whatever.

mypalmike• 6 years ago

Coming from the other direction, random code that executes outside of functions is sloppy. It's harder to reason about and is a regular source of confusion and bugs.

jeffreyrogers• 6 years ago

I always saw Python and similar languages (Perl, Ruby, PHP maybe) as attempts at replacements for complicated shell scripts, so it never seemed odd to me that there was no main function, since a shell script has no main either. It just starts executing at the top.

Edit: Just saw that ktpsns and I made pretty much the same comment. I'll add that when I learned C I found the idea of a main function so confusing at first. I wanted to know why it had to be called main and not whatever else I wanted it to be. On the plus side, it led to me exploring how compilers and linkers work, which made me understand hardware a lot better.

JKCalhoun2• 6 years ago

I was reminded of BASIC (also with no main()) and replied similarly.

benbristow2• 6 years ago

Interestingly C# is introducing top-level programs now.

https://devblogs.microsoft.com/dotnet/welcome-to-c-9-0/#top-...

CodesInChaos• 6 years ago

Looks pretty similar to csx scripts

nailer5• 6 years ago

Better yet, why not explore why other languages insist on having a function, or a class with methods, before being able to print hello world?

C# literally got the ability to System.out.writeLine("hello world") (probably wrong, I'm not a C# programmer) in 2020.

I suspect the answer is "we care about existing programmers more than people who are learning to program".

flohofwoe• 6 years ago

What's the point of teachin newcomers something they need to give up later anyway though? (once their programs get big enough to be split over several files)

auxym• 6 years ago

Nim compiles to C, can be split into multiple files/modules, and does not require a "main" function.

nailer5• 6 years ago

To not eat the elephant all at once.

pdpi• 6 years ago

Different languages have different goals. It's fine if not all languages have simplicity and beginner-friendliness as a core concern.

throwaway8943454• 6 years ago

The difference is simply that compiled languages distinguish between 'static' and 'dynamic'. Static things include types, constants, and static variables. In interpreted languages, these things are all dynamic constructs--defining a type is a runtime activity that actually involves executing some code that changes the internal state of the interpreter, and it can (and regularly does) happen intermixed between other computations.

Of course syntactically-speaking, compiled languages could allow users to interleave these static declarations amid instructions and make it the compiler's job to correctly sort out the static from the dynamic (and indeed many languages do this); however, this makes it trickier to write good parsers and it also makes it harder for humans to distinguish at-a-glance the static from the dynamic (and this distinction is important in programming).

I suspect the answer is "we care about existing programmers more than people who are learning to program".

Arguably if you care about people who are learning to program, you don't just punt on teaching them the distinction between static and dynamic. I think it would be better stated, "we care more about the long-term interests of novice programmers than we do about their short term frustrations".

nailer5• 6 years ago

You can call a function that takes a string type argument in a strictly typed language. This has very little to do with needing boilerplate.

pansa2• 6 years ago

One benefit of using a main function in Python is performance. If you’re doing significant computation at the top-level, it’ll probably run faster if moved into a function.

I believe this comes from the fact that local-variable lookup is faster than global-variable lookup - because the former is lookup-by-index and the latter is lookup-by-name.

The same is true in Julia: “Any code that is performance critical or being benchmarked should be inside a function.” [0]

[0] https://docs.julialang.org/en/v1/manual/performance-tips/ind...

xtreak29• 6 years ago

There were some optimisations done in https://bugs.python.org/issue26219

Cactus2018• 6 years ago

What a great patch history. Love this:

> Would it be OK if we add this to 3.7beta2?
It's up to the release manager, but personally it feels like you're pushing too hard. Since you've done that frequently in the past I think we should help you by declining your request. 3.8 is right around the corner (on a Python release timescale) and this will give people a nice incentive to upgrade. Subsequent betas exist to stabilize the release, not to put in more new stuff.

montalbano• 6 years ago

The same is true in Julia but for slightly different reasons. It's not just quicker variable lookup in Julia, but the fact that it will be JIT compiled. (Unlike CPython.)

wwright2• 6 years ago

Not just because it's a lookup-by-name, but because globals are mutable everywhere, the interpreter has to assume that some other code has mutated the variable and has to re-fetch it in many cases.

el_programmador2• 6 years ago

Another benefit is re-usability. If you want your program to be callable as module or script from elsewhere without going through the tedious shell functions, "def main()" is the only way to go.

qw• 6 years ago

Would that be different than checking the __name__?

  if __name__ = "__main__":
      mainMethod()

tgb• 6 years ago

But the downside is that I like to use ipython and %run the file and if it's not in a function, I can then inspect all the intermediate variables and not just the result. Every time I do put it in a function, I regret it for this reason.

Of course I could just use a real debugger...

iandioch• 6 years ago

This is true. A related post about discovering this, and some links to more info: https://news.ycombinator.com/item?id=18681745

zelphirkalt• 6 years ago

And still I do write a main procedure in Python usually, which is called from that if __name__ == "__main__" thing. It is convenient to leave the top level asap and begin as quickly as possible to use procedures/function, getting out of the area, where one can accidentally change global variables, without noticing (in procedures you would have to write global as a keyword and would hopefully then notice you are doing something possibly dangerous).

quietbritishjim• 6 years ago

Absolutely. But on the other hand, it's still very useful that Python does work like this: it's nice to be able to directly do things at the top level (e.g. setting up "constants" with a little computation, conditionally importing modules or importing fallbacks, etc.). As the article says, it's also an extremely clean way of defining what gets run in what order during startup.

tcbasche• 6 years ago

Pycharm also puts a handy play button on it too, which is literally the only reason I do it. (sheer laziness)

JKCalhoun2• 6 years ago

Many languages start running your program by calling a function of yours that must have a specific name. In C (and many C derived languages), this is just called main(); ... Python famously doesn't require any such function...

Nor did BASIC.

I think the better question is, why does C (and C derived languages) require a main function?

Santosh83• 6 years ago

IIRC it is the C runtime that calls main(). In C all executable code must necessarily be inside functions, so inevitably there had to be one 'special' function that was called first.

pdehaan2• 6 years ago

At a guess, it makes the language simpler. The main function is just that -- a function. It uses tools the language already has to deal with arguments and exit codes.

Arguably it also keeps things like libraries simpler. For example, what would it mean for me to have top-level expressions in a dynamic shared library? Does it execute as soon as I dlopen() it? Does it create an implicit "init" function that I need to call?

heavenlyblue2• 6 years ago

Um, DLLs have it.

I used it to inject my own code in foreign executables.

analog31• 6 years ago

Maybe it goes back to assembly language. If you look at a block of assembly or machine language code, it's not immediately obvious where the entry point is. You could guess that it's at address 0, but I don't think that's the case for all machines.

I think more important than having a main() function is to clearly delineate the entry point. And in Python, the entry point is the first line of the program.

Now I've noticed, at least within the Arduino environment, that it uses setup() and loop() as entry points, but code is executed before these functions are called, if for instance a global variable definition invokes a class constructor. I don't know if that's how "regular" C works, but it creates ambiguity as to what runs first.

There are other languages where it seems hard to guess where the actual entry point is located unless you know where to look.

mark-r• 6 years ago

Regular C will start someplace in the runtime library, which will do things like global initialization. Once that's complete the library will call main().

The OS determines the exact place in the code where execution starts. In DOS I think it was address 0x100. A more modern OS probably uses an executable file format that allows you to specify the starting address.

ritter2a• 6 years ago

You don't get quite this level of ambiguity with standard C, since it does not provide objects (in the object-oriented sense) with constructors, in contrast to C++ that is used in the Arduino environment (in C++, initialization order of global objects is indeed unspecified, inviting subtle bugs to occur).

However, many common C compilers provide methods to declare functions to run at initialization time, e.g. gcc's `constructor` attribute, opening this rabbit hole also for C programmers.

cof• 6 years ago

Parts of the C runtime library need initialization and this initialization is done before main is called. Interpreters do this before you have a chance to run any user supplied code.

adrianmonk• 6 years ago

Yeah, this was a funny thing for me to read because my first language was BASIC. When I encountered C, it was the surprising and unique one because it required all code to be inside a function body.

I suppose one of the advantages is that it makes separate compilation easier. Take several .c files, compile each one separately into a .o file, and what happens when you try to link them together? Where should you start executing?

Defining a function with a well-known name is a simple, easy solution to that.

Python doesn't need to solve this problem because you give it a file to start interpreting, and that file is the entry point. You either pass the file name as an argument or you use #! and that determines it.

cesarb• 6 years ago

I think the better question is, why does C (and C derived languages) require a main function?

That's not the true question. The true question would be, "why does C (and C derived languages) require that all executable statements be within a function?" Requiring a main function is just a natural consequence of that.

crazygringo• 6 years ago

Agreed.

So... why does it?

cpeterso• 6 years ago

To complicate things, C++ has a main() function but also runs constructors and destructors of global objects before and after main().

bitwize• 6 years ago

Nor do most Lisp variants, nor Pascal (anything in the PROGRAM block is run as main). I guess to make the parser implementation simpler?

Skunkleton6• 6 years ago

The actual entrypoint to your program is defined in the elf header of whatever binary you execute (doesnt matter if it is C or not). Usually this entrypoint points to a function in libc, which after some setup calls the user's main function.

... why does C (and C derived languages) require a main function?

It doesn't actually. You just need an entrypoint defined for the loader. In practice most people don't want to go around libc, or fiddle with internals. This is much less true in embedded development, where main functions are sometimes missing.

Why doesn't C have global code? Probably because it would require abstracting further away from the generated assembly. If there is code that is not inside a function, how can it be called? Remember that the entry point to all programs is a function.

semi-extrinsic3• 6 years ago

Fortran, which predates C by a decade, does not require a main function either.

The following is a completely valid .f90 file that will compile and run:

  program p   
  do i=1,10   
    print *, "Hello World ", i   
  end do   
  end program

kazinator• 6 years ago

C needs a main function because all matters of initialization and module dependencies are left to the programmer.

C has no concept of a module A depending on a module B.

If C had top-level executable statements, there would be no defined order to them. Proof: C++ has a way of executing top-level code via file-scope definitions of class objects that have constructors and destructors. The order of these is not defined by the language; it depends on how the object files are linked and such.

Niklaus Wirth's Modula-2 language has syntax for this. Every module has an anonymous block of code that is executed at program initialization time. Modules declare dependencies on each other, which cannot be cyclic. If A uses B, then B's initialization code runs before that of A.

There is a single root module on which nothing else depends, and that module's initialization code runs last. In that initialization code, you can do the application startup; it serves as main.

I think some other languages in this broad family are that way also, like Ada.

Embedded systems written in free-standing dialects of C still choose to start with a function, though not necessarily main. For instance, Linux starts with a function called start_linux. That's not the first code in vmlinux that executes; there is assembly code above that, typically in a module called entry.S which will branch to start_linux.

This is very easy for embedded developers to deal with. There is no special run-time support for special global initialization blocks: it's just a function call named by a symbol that you can use as a branch target in the assembly code.

Even in Lisps, though there is no concept of a main function in dialects like Common Lisp, you have to specify a startup function when you save an executable image. This is because an image is not simply a collection of top-level forms that are to be evaluated, unlike a Lisp source file. It is not obvious what has to be executed when the image is restarted. Without the ability to specify a startup function, a possible choice might be this: that when the image is re-started, the save-image function (whatever it is called in the implementation) will appear to return a second time, perhaps with a value indicating "I'm now returning again due to the image being re-animated".

A compiled C program, at a very basic level, is analogous to a Lisp image.

A Lisp system loads some .fasl files, and then saves an image, specifying a startup function.

Similarly, in a C toolchain, the linker loads .o files and saves an image, recording in that image an entry point where to begin executing.

As a rule of thumb, if it's image-based, then it probably needs a startup function, unless there is an equivalent language feature for handling startup.

That applies to the booting of operating system images also. Consider:

MS-DOS has "autoexec".

Unixes run /sbin/init.

U-Boot has the bootcmd variable.

All of these are like a main startup function.

lispm• 6 years ago

you have to specify a startup function when you save an executable image.

Specifying a startup function when saving an image is usually optional in Lisp.

Also the capability to save an image is optional: Lisp systems without saving images: ECL, mocl, ABCL, ...

riazrizvi• 6 years ago

The main function, in C/CPP programs, satisfies an operating standard in Unix and Windows systems for a defined program instruction entry point. With CPython, main is written into the python executable's source. Python scripts are not C/CPP-source executables so they don't need a main, they don't need this constraint, so what sense is there in imposing it?

im3w1l• 6 years ago

No, this isn't so. And besides, the main function isn't even the first thing in your program to run. The standard library does some setting up first. For instance populating argc and argv.

You may enjoy reading this: http://www.muppetlabs.com/~breadbox/software/tiny/teensy.htm... It explains a lot of how linux loads programs. It's a bit dated though: everything is 32 bit.

sszz• 6 years ago

There is definitely a main function in the CPython source code.

nurettin• 6 years ago

The code to parse and populate commandline arguments comes from the linker, and is part of the generated binary, not the standard library. Here's a much better explanation https://embeddedartistry.com/blog/2019/04/08/a-general-overv...

klyrs2• 6 years ago

There's a big benefit to Python's convention

  if __name__ == "__main__":
      ...

especially in contrast with c and other languages that shoehorn you into defining a main function. Namely, you can put a "main" into a module, and import that into another module without causing trouble.

I use this a lot during a development cycle (not so much in prod). Say I'm trying to replace a function foo with a new implementation foo_new in a large package. I write some rudimentary tests and benchmarks in "main" which compare the two methods (including a late-import of the top-level package), and directly execute that file until I'm satisfied. At that point, I'll switch (foo, foo_new) -> (foo_old, foo) and start running unit tests. Once those unit tests pass, I remove "main" (usually, promoting some fragments of it to new unit tests) and foo_old.

uryga• 6 years ago

especially in contrast with c and other languages that shoehorn you into defining a main function

i don't think that's a problem in languages with namespaces/modules -- a module might define a main(), it just wouldn't be used when it's imported. (unless you're in C, then you'd get a name clash)

klyrs2• 6 years ago

That's a great point... with a small caveat that some people abuse namespaces badly and clashes may still occur.

wwright2• 6 years ago

You actually can define `main` in a library, as long as you handle the symbols right.

irrational• 6 years ago

Why do some languages require a main function? I started out with JavaScript decades ago, and of course JS doesn't require a main function. When I started learning Java I thought the requirement that there must be a main function was just bizarre. I still feel that way, it just feels wrong.

kibwen• 6 years ago

You've seen in Java how the main function has the `args` parameter as input, an approach which originally comes from C. In C code, main is actually not the first code that gets run during the program; a compiler-provided shim function called "start" sets up the environment, which includes creating the `args` array, and then calls main and passes args in as a parameter to main. The start function needs something to call, and args needs to come from somewhere; having an explicit main function with an args parameter isn't the only way to achieve this, but it's not a bad way by any means.

wruza• 6 years ago

Because languages that compile to a platform binary must obey rules of a system linker and a corresponding stdlib. Javascript is an active host for an entire js program, but C compiler is not. C source files turn into object files (.o/.obj and then .so/.dll for libraries) that have a particular format and may be linked with object files and libraries from other languages. A system linker then decides where the entry point is by looking in every object file for a _start symbol, which is usually implemented by clib, and it basically does:

  void _start(void) {
    extern int main(...);
    init_clib();
    exit(main(...));
  }

The exact procedure heavily depends on a build target. Also, C compiler cli tool (e.g. gcc) is usually a frontend for a compiler and a linker, among other tools, which may add to the confusion.

Object files are collections of symbols, either external, or defined in that file. Every non-extern symbol is a region (addr, len) with either data or code. There is no unnamed/main symbols by design. In theory, C could abstract that and allow code at column zero, but there is no rationale for that.

ballenf• 6 years ago

If javascript had one (or if Node had one), wouldn't top-level await be unnecessary?

staycoolboy• 6 years ago

This article really complicates a simple concept: EVERY program needs a main(). Period. Whether it is called "main()" or ".ORG", or it is just an address given to a linker map, or simply a hex address in a BIOS boot sequence. There is no avoiding it: one instruction must come first.

Python, Perl, Ruby, Bash and every other scripted interpreted language IMPLICITLY wraps "main" around your program based on the context, otherwise it wouldn't know where to start.

I find this article obfuscating a simple point.

EDIT: When I say .ORG, I'm referring to the standard assembly language designation for "execute this instruction first", and not ICANN. ;)

munk-a2• 6 years ago

Yup - and even the most obfuscated language's main (PHP) has a single entry point - that entry point is just in apache[1] which figures out which of your bazillion PHP files to execute.

This article is bordering on nitpicking.

1. Or whatever other webserver - and actually you can directly invoke PHP via CLI, but I'm ignoring those for the most common way people tend to use it.

heavenlyblue2• 6 years ago

This does seem like one of those deeply bikeshedded philosophical arguments.

joshlk• 6 years ago

Yes the argument is trivial. But it illuminates design choices of each language which is interesting

kissgyorgy• 6 years ago

Once I worked with a library, which when imported, started printing with a printer to paper. So yes, your Python program absolutely needs a main function and please no side effects at import time!

KMag• 6 years ago

Have you considered submitting the ballad of this unintentional malware to TheDailyWTF?

tdeck2• 6 years ago

I don't see how these two are the same. No side effects at import time? Sure. But a program isn't meant to be imported, it's meant to be run, so there's no real expectation that a program should be importable without side effects.

shoo• 6 years ago

they're not the same, but they're both symptoms of the same underlying python behaviour: when you run a python file or import a python file, the interpreter immediately starts executing statements from the top of the file down.

leoh• 6 years ago

Bit snarky, but all I got from this post is "because it doesn't." Many languages don't require a main function. In fact, the earliest languages like LISP (and even punchcards!) don't require it, let alone many other languages like BASIC, awk, etc. The presence of a main function in later languages is, in a way, the outlier.

tdeck2• 6 years ago

FORTRAN does not require one either, as you can see in this example:

http://www.99-bottles-of-beer.net/language-fortran-77-264.ht...

z3t4• 6 years ago

In JavaScript only functions declared with function first will be hoisted, so I create my own main function and call it at the end of the file.

sudomakeup• 6 years ago

Well, the python interpreter has a main function.

This whole topic is like comparing apples to oranges. The python interpreter(which IS compiled and has a main function) defines the rules of whats required in python. And it can reasonable assume that the entry point is the beginning of the .py file its running.

An exploration of why Python doesn't require a 'main' function

Related Stories