Hacker News Reader

Comment by agumonkey | Hacker News Reader

There's a slight bias here: static structures don't help discovering.

I actually spend way more time finding out what java objects can do than clojure. The only reason java programmers don't feel this is because someone wrote code to check/suggest what they just wrote. Try writing java without an IDE.

ps: and I'd add that simple set of immutable structures plus functional idioms filters a lot of ambiguity from programming too. The other day I had to read java sax attribute API. It was not obvious and a complete waste of time all that for a list of pairs.

View on HN

> Try writing java without an IDE.

Why?

The availability of powerful IDEs is one of the biggest selling points of Java, arguably topped only by portability and the large ecosystem of libraries. The fact is, if you're writing Java, you will almost certainly be using tools that help you write correct code more quickly.

And the nature of Java is what makes that possible. The IDE knows what your data means, and it knows if you're trying to do something that isn't allowed. That's the entire point of the article: Java forces you to declare what you're trying to do, the IDE holds your hand through that, and the compiler enforces it.

I think it's mostly a fallacy. Static OOP can only do so much, and it's just a cultural side effect that your editor comes preconfigured with JDT. It doesn't help your editor to know what Factory to use to instantiate some constructor, only the author and the doc. You'll still be reading suggested method docs. It's just that your IDE .. as you say it, holds your hand.

> There's a slight bias here: static structures don't help discovering

OTOH, they support tooling that can, used properly, though that tooling itself increases the surface and scope that needs to be learned and accessible in using the language. (And often is less helpful than it should be, because if it often takes more what is necessary for code to function to make discovery useful, but that involved the kind of documentation lots of people avoid.)

That's close to my understanding of things. Tooling is often a sales pitch and doesn't really help you.

And again, the point is not that dynamic => uncertainty it's that static != certainty. It's static + man hours that reduce some uncertainty.

ps: remember the stubs of code in the Eclipse/UML era... that was tooling too. We got to be a little more precise.

"Try writing java without an IDE."

But why would I ever want to?

It's not a why, it's a matter of fair comparison, when you have code analysis / completion in a repl you don't spend much time guessing.

If you get a Request object, how do you know what is in it ? the IDE is telling you, not the language.

But the IDE's ability to tell you depends on the language. IDE features for dynamic languages are worse because the static structure of the code is not available, so usually devolves into basic string matching. In the case of C#, the language and IDE support are developed together, and new features like async, linq etc are not considered done until the tooling (IDE, debugger etc.) supports them. It's unfair to dismiss the tooling for such languages when they were explicitly designed with them in mind.

string matching in clojure ? you never read about lisps I suppose.

I'm even pretty sure that until a decade ago, Emacs had a more grammatical understanding of source code than Visual Studio.

I've been working with clojure professionally for over 4 years. The default navigation in emacs is non-existent as far as I can tell and only works at all once you've loaded the source into the REPL. Even that only works for resolving top-level vars and doesn't work for local bindings. Admittedly I tend to use cursive so this may have changed recently. But that still doesn't help you understand the argument/return types of functions etc.

ok so it seems you've read about lisps :)

maybe I don't expect as much as you do then.. I always felt a lot happier in a repl than in an IDE but I have to admit too that I didn't use IDEs a lot recently. (my last bits were scala and java graph moocs under eclipse and I was as angry as I used to be previously).

Because "real programmers" only use vim/emacs and a bunch of UNIX text-based tools :p

Reply on news.ycombinator.com