[freedomben]

This is absolutely true, but having spent a lot of time The Java ecosystem and then much time outside of it, I now think this is a bit of a curse. It has made the average Java developer actually structure their code and build practices around the IDE, rather than the other way around. If it wasn't for modern CI practices which force a headless build, I wouldn't be surprised if most Java projects wouldn't even build without the IDE to do the building for them. In several places I worked, Even That wasn't really usable outside of the CI environment because it was just taped together as an afterthought and bare minimum since all the developers just used IntelliJ to build locally anyway.

Even little things like variable naming, explicit types, and the like were commonly neglected because in the IDE you could just hover your mouse over the variable to see its type. Because that exists and is so commonly used, developers didn't even think about The impact it might have on someone not using the same IDE. This is just one of several practices that I continually ran into when trying to use vim. There are also plenty of readability issues, such as enormously long methods that the IDE collapses for most developers so they never see it and don't have to think about it, but once you aren't using that IDE anymore, you really see all the nastiness and warts.

So long story short, I agree with you about the tooling, but I think it is actually more of a curse than most people realize.

[winrid]

Your issue was going against the grain and using Vim. Everyone was using an IDE because they found the optimal workflow and just wanted to work.

It's like joining a team of roofers and using a hammer while everyone else is using nail guns... sorry, the right tools are faster.

Also FYI you don't need to use a mouse to get the types, moving a cursor over the variable is enough.

[wiseowise]

> Everyone was using an IDE because they found the optimal workflow and just wanted to work.

You overestimate mental capacity of average Java dev. Most of them are using whatever herd does without knowing why.

[usrusr]

Most of that could also be considered getting the best out of the tools at hand. Is it necessarily a good idea to always optimize for the highest common denominator? Even for a contributor that at the time of the decision is merely a hypothetical? That same attitude could be brought into a project by someone who refuses to use a build system and insists on everything being laid out for easy compilation by manually launching javac, or on writing makefiles instead of a pom.

I mean sure, there are projects out there where a healthy dose of tool-agnosticism should not be too much to ask for, but a generalized "they are doing it wrong" about people playing to the strengths of their toolkit is really not warranted. The opposite of structuring around what works well with their tooling is structuring around what works well with your tooling. You ask for exactly the thing you are refusing them. Yeah, IDE-only builds are a bad idea, but that's really a concept that has died a long time ago (even if there are probably a few cases around where it still has not stopped moving yet)

[atomicnumber3]

You're not wrong, but IME, if people are doing stuff like that, it's not something an IDE or lack thereof would solve anyway. Sometimes you just have to either train/mentor or (if unresponsive) fire people who write such primitively bad code.