[ngrilly]

I agree with the author. Even in a "statically typed" language like Go, which has a simple type system, compared to languages like Scala or Haskell, the benefits of static typing are very real and enables a lot of extremely useful tools (code completion, refactoring, linting, whole program analysis, etc.).

[emidln]

Code completion, refactoring aids, linting, and whole program analysis also exist in dynamic languages. Take a look at emacs with anaconda-mode for python or cider for clojure. IntelliJ in the forms of Cursive and PyCharm (or the Python IDEA plugin) also support all of these. Even vim can do this stuff (python-mode, fireplace.vim). I don't Ruby very often, but I suspect these tools exist here too.

[jskulski]

def some_function(some_obj): ...

How does any IDE or editor know what some_function would be passed without a severe amount of inspection?

I might be wrong on my definitions, but almost by definition, there's just not enough information before runtime in dynamic systems to infer enough to do any real refactoring or smart completion.

I use PyCharm everyday, and I like it, but it's refactor menu is limited, can fail, and pales in comparison to my uses of java w/ IntelliJ or even a well hinted php app w/ PHPstorm.

[crashedsnow]

I agree. I haven't yet encountered an IDE that has any hope of doing anything more than being able to enumerate the defs in a module or the functions in an object. JavaScript is one of the worst because there is no canonical "include" semantic so you really have no idea what's going on. The corollary seems to be that many of these languages are fast to develop (and run) so excessive console.logs appears to be the "solution"

[lispm]

Many 'dynamically typed' languages are developed at runtime.

Check for example the typical Smalltalk or Lisp environment. The editor asks the runtime.

Since many of those languages are object-oriented, you'll know the class:

(defmethod hide ((w window)) ...)

Oh, w is a window...

[elbenshira]

In the article, I mention that linters for dynamic langs are crippled. Of course I use them when writing Ruby. But can any of these tools tell me:

  - When two equivalent anonymous functions can be extracted out?
  - When a library method already exists for an expression?
  - When you fail to match every possible result in a case statement?

[ZLeviathan]

Not true...