[ecopoesis]

I would love to see a language that considers tooling a first class problem. Most (all?) languages barely consider complex projects with 100s of dependencies and large multi-step builds. Java shouldn't have to wait for Maven and Gradle to come along, and Python shouldn't be shackled to piss-poor systems like pip.

This is something Rails gets very right. Bundler and Rake make Rails one of the nicest development environments there is.

But we can and should do better. Why is DLL-hell still a thing? Imports should specify versions, defaulting to a default if none is specified. Languages barely even consider versions today, they are almost always hacked on via magic text strings in filenames.

Why do tools like Dependabot and Renovate need to parse a million dependency formats to figure out versions? The language runtime or build system should produce that as a first class output.

Deployment and documentation are other places most languages ignore and delegate to a variety of crappy external tools.

Build Server Protocol is a good step in the right direction, but it barely scratches the surface. It would be great to see a language that prioritizes the parts of the developer experience that aren't writing code.

[plafl]

>But we can and should do better. Why is DLL-hell still a thing? Imports should specify versions, defaulting to a default if none is specified. Languages barely even consider versions today, they are almost always hacked on via magic text strings in filenames.

So suppose you fix the version number when you import the library. You then need to copy paste the version number to other imports in your code base? Or maybe you mean each import may have different versions? which is all right until you need to pass some data between two versions of the same library. This wouldn't be so difficult if semantic versioning or another equivalent was respected, but we know it's a lie. This wouldn't be a problem at all if there were some kind of contracts in place when using modules/package/whatever instead of a silly number based on convention but how to specify the contracts is not that easy, and it's similar to say having static typing. I think improving versioning it's doable but it's very hard.

I'm all about improving tooling, I have been obsessing for a few months about the sad state of program documentation and navigation. Why is the computer doing nothing while I think so hard while I'm programming? Why there is so little money in this space?

[samsquire]

I spend everyday thinking of what my computer could be doing.

Most of the time the CPU is waiting for IO - memory, network, SSD, disk and not doing any work.

You might like my idea called GUI Thunking.

https://github.com/samsquire/gui-thunks

[solomatov]

Go and Rust with go and cargo commands correspondingly have great tooling in this respect. As long as you use one language, everything is very convenient.

[chakkepolja]

I think new languages with sufficient popularity (go, typescript, rust, dart) do it pretty well.

Old languages also have gained good tooling, but IMO the problem is that they are not as well documented as in-built systems of newer languages.

[urthor]

Smalltalk.