Java was a huge boost, by eliminating the cognitive load of manual memory management.
Scala can be used as a "better Java" with less verbosity, but also adds a number of extremely useful features; Java has slowly added some of them into the language over the last 8 years.
JVM tooling IMO is fantastic, it is one of the largest open source communities, and there are many options if you don't like Gradle or Maven. Also, as I understand it, the dependency management systems found in languages like Python and Node are horrible in comparison to the JVM, where it is usually not a problem.
e.g. in Python/Ruby I had a REPL and used it a lot. Go doesn't really have a good REPL, so I tend to not use it so much. I probably pay some in productivity for that?
On the other hand, I type code like:
name:=fun("foo","bar");if name=="foo"{fmt.Println(name)}
And write and let gofmt sort it out. You can kind of do that in Ruby in theory (not sure if good formatters exist), but Python is more tricky (and I also think the auto-formatters for Python are bad and often make code worse).The flexibility of things like Active{Record,Model} in Rails are great, and hard to emulate with Go. People have tried, and it just doesn't fit with the language very well.
Go's simple "just compile to a statically linked binary" distribution model probably saves me time, especially for distributing it to other people.
Probably other differences I can't think of right now.
So between all of that, how do you split out the productivity of "types" vs. anything else?
That's also my problem with the research on this, because you just can't, not really. What you need to do is compare e.g. Python with Mypy vs. without. I don't think anyone has done that(?) And even then you run in to the problems with differences in tasks, differences in programmer experience and ability, etc. which matter because for a lot of these studies n tends to be small.