Not a lot of comments so far, but a few people are talking about stuff that is in the general vein of better tooling and code generation/automation through deep

Not a lot of comments so far, but a few people are talking about stuff that is in the general vein of better tooling and code generation/automation through deeper code understanding by our tooling. I think that this sentiment is interesting, because the way I see it, this can only happen if we continue the trend of transitioning to static typing. We can't really do much more for dynamic language tooling today than we are already doing unless we solve the halting problem. The very nature of the problem (of providing smarter tooling) requires us to be able to gather metadata about our code, without having to execute it. This means static information. We have invented all sorts of schemes circumvent this problem, like the plethora of documentation generation tools that exist. Of course, there is more to documentation than just information about the types of the arguments of functions and such, so documentation tools will always have their place. But I contend that a large part of the benefit a lot of the documentation provides for many languages is simply typing information. And I also believe that with well engineered type systems and API typings, the types themselves can provide enough information to use a lot of APIs without having to reach for external documentation. Or to paraphrase: in any code documentation generation tool for a dynamic language, there is a half-finished implementation of a badly formalized, insufficiently powerful static type system. Typescript's huge rise in popularity seems to suggest that a lot of people used mostly to dynamic languages really wanted static typing all this time but just didn't know. I think if we could combine some of the concepts of typescript with Haskell's type system, so that we can have both nominal and structural typing, we would have power to challenge the gods. If we are able to harness all the information in such a type system, we could provide very powerful tooling that will basically be able to write code for us, as long as the types are right (automatically filling typed holes). I am obviously a proponent of static typing, but I'd be interested in hearing if there's someone on the other side of the fence that has some ideas for how we can improve upon dynamic language productivity without solving the halting problem.