[hermanhermitage]

One viewpoint is such noise doesn't scale - both for tooling or human consumption.

Java and C# are both heading into a territory where it is getting less reasonable for a human to write them without tooling support - is this what people really want? If we have such sophisticated tooling why bother dropping to low level text? Wouldn't it make more sense to manipulate and compose more expressive objects than text?

The end game is you obsolete the languages and they become targets of more expressive languages.

It highlights a potential design flaw in the composition model of the language and/or the libraries.

Should for example C/C++ include the generated assembler in pragmas to guide compilation? Always? Visible to the programmer?

[jrockway]

I disagree. It's the concise model that can't scale without tool support. Imagine you import foo.∗, bar.∗, and baz.∗. How does someone reading the code know where the Quux class comes from? They can't, without checking all of the namespaces that were imported. But if you just "import foo.bar.baz.Quux", then you know exactly where Quux comes from.

This whole thread sounds like a lot of non-java-programmers complaining about Java.

(Note: incorrect * used above because HN's parser sucks.)

[hermanhermitage]

I'm not too fussed with the namespaces - I dont think you will find anyone arguing against that.

What is at issue is the over specialization of class or framework components because of language limitations.

A language that leads to degenerate boilerplate or mounds of endless repetition (but in user land code and libraries/frameworks) can be viewed as having a serious abstraction problem.

Do you really think java will be looked at in 100 years as the pinacle of language evolution or some horrible dead end? Like cobol or basic?

[jrockway]

This library looks bad because it is bad.

(I just wrote a long rant about this, but on my internal blog, so I'll summarize here. They have 12 classes implementing immutable lists. A class for an empty list. A class for a list with one element. A class for a list with two elements. That continues to 10 (!!!!) elements. Then there's a class for lists greater than size 10. This pattern is repeated for all the other types. That's going to be messy in any language. Google seems to survive with 0-, 1-, and n-element classes.)

[arcdrag]

Do you think that 100 years from now, anyone other than programming language researchers will have heard of any programming language used today?

[DanBC]

Do you think 40 years ago people would have thought that people would still be using C (and derivatives)?

[hermanhermitage]

Yes a very interesting point. You could even replace C in that sentence with Algol and it rings fairly true.

In C it always feels like the pillars were speed of implementation and speed of execution on low cost hardware and without sophisticated compilation technology.

Ignoring syntactic issues there are only a few things I wish it had as part of the specification (when viewing it as a (if used in a certain manner) portable minimum viable language where assembly language meets high level languages):

1. A better implementation of Landin's J operator than setjmp 2. Compile, Link, and Load time reflection 3. Portable dynamic code generation (at runtime) operators (to allow late binding and JIT style optimization).

Java can be also viewed as a reworking of Algol but this time with design pillars centred on working in a VM, modularity for large code bases and simplification principles.

It always feels to me like the simplification was intended to reduce complexity (originally: signed ints, no function pointers, no lambda, no manually managed memory objects) but unfortunately this has just pushed huge complexity into code bases. Whilst I can accept this in C (minimum viable human readable and writable portable code), for some reason because Java sits on a huge stack of runtime code and tooling I dont like it. What Java did really bring to the mainstream is the whole VM thing (although some of us will remember BCPL or UCSD p-code), but I think the VM brings too much Java-ism into it and a smaller and better VM lies within.

[bradleyjg]

The very best chess teams consist of a computers and a humans cooperating with each. The computer insures perfect tactically play while the human concentrates on overall strategy.

Why should programming be any different? The very best IDEs in the hands of a skilled programmer should produce code better than a similarly skilled programmer who insists on using a dumb text editor. If the resulting code can only effectively be modified by a similar computer/human team - well that's a small price to pay.

[jrockway]

I made a vow to myself to never reply to a comment that used both "tactics" and "strategy" in the same sentence, but here goes...

Why should programming be any different? The very best IDEs in the hands of a skilled programmer should produce code better than a similarly skilled programmer who insists on using a dumb text editor. If the resulting code can only effectively be modified by a similar computer/human team - well that's a small price to pay.

That's true, but show me an IDE that lets someone write better code than someone without the IDE. The reality is that IDEs provide very superficial features that help beginners be more productive, but don't help experienced programmers much. (The most cited feature, symbol completion with docstrings, is available in pretty much every text editor. It's nice confirmation that your mental model matches the tags table, but hardly essential.)

All I can say is: Java got a lot easier for me when I stopped trying to make Eclipse useful. It turns out that Eclipse doesn't really do anything except sleep(5) after every keystroke.

[eliasmacpherson]

The speed and manner in which the full version of Visual Studio allows you to debug container objects and jump JIT to the code currently executing to look at the call stack and inspect variable values, is not superficial. As a text editor, code writing tool, sure it's not much better than a standard editor. As an IDE with a debugger it allows an experienced developer to debug faster and write better code more quickly. Even experienced developers have to debug their code, and it is time consuming even for them.

Eclipse is not Visual Studio though I've heard good things about IntelliJ IDEA.

[edwinnathaniel]

Visual Studio is not Eclipse either.

IntelliJ is on par with Eclipse. Period. Let us put a stop into that topic.

[arcdrag]

The refactoring tools in IntelliJ make it possible to catch a lot of things that would be very difficult to do with emacs of vim. For example, I know a certain utility method exists in several different classes, so I want to extract that method and utilize it throughout my project. The IDE will search the project for any block of code that meets this pattern and will ask you if you want to replace it with this new utility class instead. For smaller projects (<25k LOC) this isn't a big deal, as any major dev will have seen every line of code. For very large projects, I can't imagine going back.

Also, if you're basing your IDE experience solely on Eclipse and Netbeans, give IntelliJ a try. Both Eclipse and Netbeans pretty much seem unusable after you use IntelliJ for a while.

[jrockway]

I don't think "very large" means what you think it means :) I work on a codebase that recently passed commit number 30,000,000. I don't know how many lines of code that ends up being, but it's a lot :)

Basically, my experience with IDEs at Google is that none of them can handle our repository. Even managing the transitive closure of a single project, Eclipse randomly freezes while typing. I don't know anyone that uses Eclipse anymore. Most of my team uses IntelliJ, but even then, the codebase is just too big for it. People type something like com.google.commons.collect.L and see no results (when the right answer is "Lists"). I haven't debugged this, since I don't have any interest in using IntelliJ, but the number of times a day I'm brought to someone's desk to "watch this", I don't think it would work for me. I'd rather have consistent limitations than random failures. Emacs won't iterate over every Java file in Google's repository to complete "Lists" as above, but if I've used it in another file, it will.

The good news is, we have an internal code indexing system that provides an RPC API for many of the IDE features, including completion and duplicate code detection. (But most of the Java chores that people love their IDEs for are handled in other ways at Google. I don't think I've ever written a getter or setter, for example, because every class I've written has been immutable with private internal state. When your objects aren't dumping grounds for other objects, you don't need to get or set anything! :)

Like I've said in other comments, I would never do Java outside of Google. But since I'm here, I have nice tools available to me and using Emacs for Java is no problem at all.

[bradleyjg]

The great-grand parent's original point was that a language that needs tools to be written effectively is a flawed language. If I diverted that into a meaningless argument about what type of tools are best, then I apologize.

I stand by my original point though. I wouldn't want to write in any programming language without tooling and the availability of sophisticated tooling (of many different styles) for a given language is a strength not a weakness.

[kiba]

The very best chess teams consist of a computers and a humans cooperating with each. The computer insures perfect tactically play while the human concentrates on overall strategy.

Except, we're using computers to help assist us with a terrible codebase that is unnecessary complex and verbose.

Why should programming be any different? The very best IDEs in the hands of a skilled programmer should produce code better than a similarly skilled programmer who insists on using a dumb text editor. If the resulting code can only effectively be modified by a similar computer/human team - well that's a small price to pay.

Vim and emacs not "dumb text editors". They are very powerful tools in the hand of a skilled programmer.

[irahul]

> The very best IDEs in the hands of a skilled programmer should produce code better than a similarly skilled programmer who insists on using a dumb text editor.

The very best IDEs produce code at the skill level of dumbest programmers - generating getter-setter, or importing, or wrapping something in try-catch...From the top of my head, I can't think of a single instance where the code produced by IDE can be considered semi-intelligent, let alone at par with code produced by skilled programmer.

And code produced by a skilled programmer using a dumb text editor? A skilled programmer using notepad, eclipse and vim produces different code in all 3?

[FuzzyDunlop]

When I think about this, I think it's actually correct that an IDE produces fairly unintelligent code.

The smarter and more intelligent it gets, the harder it is for the less skilled programmer to edit it.

The skilled programmer can still improve the unintelligent code.

[unimpressive]

>The skilled programmer can still improve the unintelligent code.

In my experience, fixing a crap piece of code (Usually called refactoring.) takes longer than just writing a correct implementation from scratch. In most cases.