[carsongross]

Neither static typing (nor any of the other stuff mentioned) is enough to ensure correctness. Never has been, never will be.

However, static typing is enough for some sweet, sweet hit-dot-wtf-can-i-do-completion-refactoring-like-a-boss tooling goodness.

[fogus]

    (any of the other stuff mentioned) .. ensure correctness

The post says that.

Dot-completion in your IDE is not enough either, nor is it something particularly unique to static languages.

[carsongross]

Reliable dot completion without some batshit insane state-dependent VM-as-a-dev-env-or-constantly-running-tests system is... well, let's just say made much easier with static typing.

I really could give a shit about what people think is "enough" (IMO, keeping stuff simple, as in simplicity of implementation, as in worse-is-better, is the only answer) I just want to hit dot and have a pretty good idea what I'm allowed to do. And static typing, in practice, appears to help there.

But hey, man, I'm not advocating you use it.

[ubernostrum]

Reliable dot-completion for dynamic languages exists, right now, and is not batshit insane or dependent on VMs or any such thing.

[fogus]

    But hey, man, I'm not advocating you use it.

I'd be crazy to give up dot completion. I like it as much as the next guy. ;-)

[jshen]

Pry for ruby gives me great dot completion and isn't batshit insane. Most diehard dynamic typists live in their repl. When I use java with IntelliJ I miss my repl. I do gain some things from the IDE, but I feel hamstrung compared to my repl.

[carsongross]

Ah, fk man, another REPL?

I don't want a repl for editing. I want to write code in a friggen editor and have dot completion work.

I also want a repl for trying stuff out and debugging/light weight testing, but that's a different use case for me.

[spacemanaki]

> I don't want a repl for editing. I want to write code in a friggen editor and have dot completion work.

I don't either, which is why I use Emacs with something like SLIME or at least inferior-lisp. But I'm sure you've tried this already, and it's not for everyone of course.

I find autocompletion and Intellisense-like features useful, but not really useful enough to make me pick a language based on them. I don't type terribly quickly either, but that doesn't worry me as most of my time is spent debugging and not typing.

Of course static typing does help catch some bugs before you get to debug them, but I think talking about autocomplete and dot-completion is kind of a distraction.

[banister]

Pry knows its place, it doesn't pretend its a nice environment for writing real code - instead when you want to edit a method definition you type "edit-method my_method"[1] and pry will open the source file of that method in an editor and take you to the exact line where the method is found.

[1] https://github.com/pry/pry/wiki/Editor-integration

[jshen]

https://github.com/pry/pry/wiki/Editor-integration

[ehsanu1]

But that doesn't give you autocomplete within the editor, it seems like it just opens up the editor and evals the file after exiting the editor.

[carsongross]

I'll give pry a try, but I've tried a lot of dynamic IDE environments and none have come close to IJ w/ statically typed langs.

[jshen]

Minus the part about t only working well for java and having to write your code in java ;)

I also use rubymine for ruby development and it gives me a lot of the IntelliJ stuff, but it doesn't always work. I.e cmd-b to jump to the method definition.

[roryokane]

> The post says that.

I think the grandparent knew that, and was just repeating what you said to contrast it with his following statement about what static typing is good for.

And dot-completion is not completely unique to static languages, but I would say it is “particularly unique” – it is more common for static languages. And that’s not just coincidence – it is generally easier to write a tool like dot-completion for a static language than a dynamic language, because dot-completion involves static analysis of the code.

[derefr]

> dot-completion involves static analysis of the code.

Dot-completion involves having a living model of the program loaded in memory. You can do this with any language--static languages just partition the program model such that you get a certain phase of interpretation (compilation) past which you have a completed model of all of the code, without yet having seen any of the data.

On the other hand, you can easily dot-complete method calls in a dynamic language's REPL--because there, at runtime, is when and where a dynamic language forms a complete model of the program it can use to do such things.

Now, the real question is why we're still programming dynamic languages in text-editors instead of treating them as congealments of transactionally-replayable interactive REPL transcripts. (Are there any modern examples of programming in this style, anyway? I can only think of ancient ones: Emacs Lisp, Squeak Smalltalk, and the "immediate-command-line" of some Telnet-based simulated-world MOOs.)

[prodigal_erik]

When you create a method which takes an argument in a dynamic language, there's no declaration of the type of that argument or which methods it will be known to support. So how does dot-completion work for any target other than "this"? The REPL isn't doing whole-program dataflow analysis to infer the only type(s) which could possibly be passed, is it?

[jules]

FYI, PyTools for Visual Studio does dataflow analysis for intellisense.

[carsongross]

I code in both ruby (with a repl in the IDE) and java (with a traditional statically typed IDE). There are times I wish I had a repl in java (I typically use debugging in a test to fake it) but I'd give my left cortex for reliable code completion in ruby.

There's no reason we can't have both. It just takes a reasonable terse statically typed language like C# or, dare I say... gosu.

[jshen]

Have you tried pry for ruby?