What matters is looking at a file and being able to tell what was defined where and imported from there.

I don’t know, but my least favourite has to be Python with its from syntax.

e.g.,

# fine
import os.path

# what??
from os import path

Perl's system of use ModuleName LIST is pretty nifty.

The LIST may contain pretty much anything and it's passed to the module's import method (or one that the module has imported in turn from elsewhere). It can be interpreted or parsed freely by that routine.

Usually, it's expected to contain the names of variables and subroutines to be linked into (some might say "pollute") the current namespace, as well as special flags that can import multiple at once, but it can also be left empty with () and then everything in the module has to be referred to by prefix in a very similar way to how C++ does it.

But in theory, you could put an entirely different programming language into that LIST and have the module do magical things with it. If you thought the fact that C++'s template system being Turing complete was insane, this is basically that, but to the next order of magnitude.

There is a hidden detail that's worth mentioning about C and C++ style includes: Because compilation and linking are two separate steps, the definitions (included from header files) and the compiled object code that implements those definitions can be kept strictly separate such that you could have two different implementations of the same definitions that are switched in at linker time, for example as a way to provide mock implementations of a specific compilation unit for a unit test, by modifying which object file is passed to the linker.

In some languages this is harder to do as it would require some fiddling with the classpath (in Java for example) or designing with dependency injection in mind from the beginning (inversion of control).

I'm not saying it's a killer feature, but it's something worth noting nonetheless.

I suspect most developers have a "favorite language" and are just going to respond with "the import style my favorite language uses".

I think C# handles this pretty well. You include namespaces with whatever granularity you need, down to a single class (or interface or whatever) and can alias them.

using MyProject.Domian.Entities; //the whole module
using Routes = MyProject.Api.Contract.Routes.Http;  //an aliased single class

I bet Java had this too, C# us still mostly Java: Microsoft Edition.

I like Rust’s style. It’s simple and it does everything you need. As much as I love Elixir, which I write at my day job, it has alias, import, use, and require, which each import things different, and it can get a bit confusing.

Javascript with ES Modules and Rust are my favorites.

import { add, subtract } from './math.mjs';

Java is fine, Python feels backwards and i'm never sure why relative imports work or dont work.

Go's:

import "foo"    // foo.X
import b "bar" // b.X
import _ "baz" // X
// or, the same but less verbose:
import (
  "foo"
  b "bar"
  _ "baz"
)

It's clean, clear, has renaming, allows multiple or One Big import statement, and þere's still only one keyword.

I like being able to import multiple things from a given package/module on the same line. Aliasing is also very useful.