Like to import via smuggli- OH we’re talking about coding? Uhh Java does it pretty well and we’re learning C# rn so gonna have to learn how to import that soon

Python’s work great.

Short, clear and flexible.

Zig and Rust are good. Java is painful.

But the best for me is Clojure:

(require [my.module :refer [func1 func2]]
               [Some.lib :as lib])

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 suspect most developers have a “favorite language” and are just going to respond with “the import style my favorite language uses”.

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

In order or preference, out of the ones I’m familiar with:

1. Java. Very simple. Diff friendly. Import names match the filesystem.
2. Rust. Also good - you can do it diff friendly though nobody does. Slightly confusing distinction between module hierarchy and filesystem.
3. Python. Pretty bad. Conflates third party packages with local files, almost nobody actually understands relative imports, even more confusing distinction between module hierarchy and filesystem. Module imports can have side effects. Unnecessarily different syntax between import... and from .... import....
4. C/C++. Obviously this is the worst.

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.

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.

Elm:

-- Import under the name "List"
import List

-- Import aliased under the name "JD"
import Json.Decode as JD

-- Import Html, and put the Html type into the unqualified namespace
import Html exposing (Html)

-- Import Http, and put everything from it in the unqualified namespace
import Http exposing (..)

Kotlins import system feels a lot like Java’s, but improved, since it allows aliasing of conflicting names.

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

I’m not educated enough to have an opinion that goes beyond what I like to type. I find C style to be the nicest.

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.

I’m most used to c style and as a result I like it because it’s simple and uncomplicated. I recently started learning rust and quite like their way of doing it, although there’s also mod and I haven’t quite figured out when to use which. I just do what rust analyser tells me :)