The IDE As a Bad Programming Language Enabler

theodp writes "When it comes to monolithic IDEs, Wille Faler has lost that loving feeling. In IDEs Are a Language Smell, Faler blogs about a Eureka! moment he had after years of using Eclipse for Java development. 'If the language is good enough,' Faler argues, 'an IDE is strictly not needed as long as you have good support for syntax highlighting and parens matching in the case of Clojure, or indentation in the case of Haskell.' So why do Java coders turn to Eclipse? 'Because [of] a combination of shortcomings in the Java compiler and Java's OO nature,' explains Faler, 'we end up with lots and lots of small files for every interface and class in our system. On any less than trivial Java system, development quickly turns into a game of code- and file-system navigation rather than programming and code editing. This nature of Java development requires IDEs to become navigation tools above all.' Yes, only an IDE could love AbstractSingletonProxyFactoryBean!"

Comments

Word

[genocism]

I prefer writing in a word processor why should software development in an IDE be any different. Refactoring, code, memory, and performance analysis... All good things. Ohh and that little thing called debugging.

Re:Word

[equex]

i code with a battery, a resistor and hit the cpu pins with it

Re:Word

[lattyware]

The article isn't saying IDEs are a bad thing, just that when an IDE is doing things that should be negated by the language (generate getters/setters anyone?) then it's a sign there is an issue.

Re:Word

[santax]

(obligatory) I run emacs on my mainframe, great OS and desktop-environment but I can't understand why Stallman didn't put a decent editor in it.

Re:Word

[gmhowell]

i code with a battery, a resistor and hit the cpu pins with it

Still haven't mastered butterflies, n00bz?

Re:Word

[daem0n1x]

Quite often I get the task of being the mentor of interns or newbies, many of them completely clueless. I also have given basic programming training for college students, usually C/C++ and Java.

I always tell them to code using a text editor with syntax highlighting and then compile using the command line (in Windows, but preferably Linux).

That way they can start building up knowledge about how the whole thing works from the ground up. If people start with a nice and cozy IDE they tend to think it's all magic going on. And then, when they need to solve any problem, they have no idea where the files are, their formats, their contents, etc.

After getting acquainted with the bloody guts of the whole thing, they can start using tools to make it easier and faster. Using a good IDE has nothing wrong about it, if you really know what's going on under the hood. Magical thinking is an enemy of good engineering.

Re:Word

[mwvdlee]

So basically his entire argument boils down to "My programming language is better than yours"?

Re:Word

[RobinH]

There was an interview in the latest issue of Make Magazine with one of the creators of the Arduino. He said he's been trying to teach fundamentals of electronics to students (ohm's law, etc.) and they just weren't getting it, and he realized that wasn't how he learned it. He'd just started building stuff with the tools available, and when something didn't work, he was motivated to dig deeper and figure out why. He helped create the Arduino to be an easy way to get a light blinking without really having to know everything about how it worked, and then as you wanted to do more, you had to figure it out. The Arduino seems to be very successful with this strategy. That seems to fly completely in the face of your theory.

Re:Word

[lattyware]

No, "Java has language flaws that force you to use an IDE to work around them." is the argument. Yes, some other languages do it right and make for an easy way to show the flaws, but that's not the point. The point is that Java could be a better language.

Re:Word

[Anonymous Coward]

i code with a battery, a resistor and hit the cpu pins with it

Still haven't mastered butterflies, n00bz?

What did you think where Sandy came from?

Re:Word

[WillKemp]

So basically his entire argument boils down to "My programming language is better than yours"?

Of course. My programming language is always better than yours. This is slashdot after all!

Re:Word

[lattyware]

Properties - you create your getter and setter as you would, but Java layers them onto the attribute so you don't have to actually use getblah/setblah everywhere. C# does it (as do many other languages, but as we are talking Java, C# is the obvious comparison to make).

Re:Word

[daem0n1x]

According to the Wikipedia page: "It is designed to introduce programming to artists and other newcomers unfamiliar with software development".

I train engineers, not artists.

Re:Word

[SerpentMage]

Oh this is fucking bullshit, there I said it! I have been coding since I have been 13 years old, which means I have been writing code for 30 years, and 20 years professionally. The idea that you don't need an IDE is a hair brained idea. How on earth are you supposed to keep track of the several thousand files? When I work on projects I like to keep the entire architecture and structure in my head. I use the intellisense system to find for me the proper class. I am not talking about documentation as that goes without saying. I am talking about using a naming convention so that you can easily find functionality. I personally hate code where I cannot understand what the functionality represents due to a bad naming convention.

If I have to keep track of every method name, and its parameters then I am definitely wasting time on stuff that does not need thinking about. I would be wasting time trying to get the right word, or type, or some little buttwipe problem. If you say, "oh but wait you should be able to keep track of the methods." I reply, "yeah please write some professional code!" Let's put it this way. How come JetBrains makes money from providing IDE's that do exactly what the article author is bad?

BTW as one other commentator said, "you could apply a google principle" and that I don't discount. That could be interesting.

Re:Word

[Anonymous Coward]

The point is that Java could be a better language.

That is not really something we question. The thing that is up for debate is if Java could be a worse language.

Re:Word

[sproketboy]

In Java since properties are explicit it's obvious for example that the following would be problematic.

for (int j = 0; j getCount(); j++) {
}

I'm calling a method which is more expensive but worse the method's result is not deterministic. What if this method is a part of a web service or using a database call? Again, it's obvious when code-reviewing that this should be written like:

int count = getCount();
for (int j = 0; j count; j++) {
}

Unfortunately C# would use:

for (int j = 0; j Count; j++) {
}

which is less obvious.

In fact there's so much bad code like this in C# that they had introduce the strange "yield" keyword to help alleviate the issues caused by this feature.

Properties at the language level was a bad idea.

Re:Word

[lattyware]

That is an issue that is solved by documentation and naming properties well, as far as I see it. As to yield being anything to do with this, I don't see it, a quick google seems to show that yield does a similar thing in C# to Python, which is generators - lazy computation of iterables - which is an awesome language feature I love.

Re:Word

[YttriumOxide]

I train engineers, not artists.

Depending on what you're aiming for, this might be your problem.

Turning out the necessary "code monkeys" to produce stuff to a spec written by someone better than them; sure... but if you want a software developer that produces something great, you need an artist.

Re:Word

[wed128]

Java could be worse. It could be Ruby.

Re:Word

[i]

When I started coding I had to punch my programs in punchcards. A pity if You drop them and didn't have numbered them... :)

Then I advanced to filling in the code in forms to be delivered to the girls in the punching department. As they were young and sweet I often delivered the code forms myself. :)

After a Year we got these marvellous 3270 terminals where we could code in green on black - and could correct errors without Tipp-Ex (http://en.wikipedia.org/wiki/Tipp-Ex) !! I felt I was on the technical frontier!! :D

Re:Word

[YttriumOxide]

When did I exactly said I had a problem?

Personally, I'd say here:

Quite often I get the task of being the mentor of interns or newbies, many of them completely clueless.

And here:

If people start with a nice and cozy IDE they tend to think it's all magic going on. And then, when they need to solve any problem, they have no idea where the files are, their formats, their contents, etc.

In my opinion, if your students end up being like this due to usage of an IDE, the problem lies with you as a teacher, not the IDE.

Software Development is a rather "odd" thing in many ways. It's highly technical; painfully unforgiving in the rigidity of language syntax; and generally visually extremely unattractive (the code itself). However it's also something where you are creating something, from nothing, with your own unique style and way of doing things. That is almost the very definition of art.

When teaching, you need to remember both sides; otherwise you're - as I stated - churning out code monkeys and not software developers.

Re:Word

[WrecklessSandwich]

According to the Wikipedia page: "It is designed to introduce programming to artists and other newcomers unfamiliar with software development".

I train engineers, not artists.

It sounds like you don't deal with embedded systems much. What it does a great job of for engineers is to act as an API that abstracts away all of the stuff specific to the particular AVR chip involved. Things like setting up a timer interrupt without having to know the specific configuration registers inside and out. However, that's all still 100% accessible if you want/need it. The editor itself is most certainly not a full-fledged IDE either.

Re:Word

[neokushan]

Shocker of the day: Some software is good for some things but not others.

Re:Word

[elbobo]

I've been programming since I was 8, which makes 28 years of programming (probably more than half of that time professionally). I've only started using IDEs in the past few years, and only because they're pretty much not optional for a lot of platforms these days.

I think I was better off before IDEs. I don't write less bugs now, and I don't feel like my programming is qualitatively better because of the IDEs. I find my work environment is now far more cluttered, and I spend more time navigating my tools rather than navigating my code.

Perhaps you're mistaking "tab completion" for IDE? You don't need an IDE for tab completion. I've had that for over a decade in vim.

Re:Word

[javaxjb]

By lengthening the round trip time from coding to compiling you're decreasing the rate of repetition (and success). It would be better to get the fundamentals of the language down first and then work on scenarios where you might want to make patches on a remote console-based system. Then go through some exercises where the students patch bugs using a console-based editor and compile/build commands.

Re:Word

[crazyjj]

When I was in college there was a poster that hung in one of the professor's offices. It was a picture of a stern looking old fart glaring at the camera, with the caption "Programming: You're doing it all wrong." Every time one of these discussions comes up on /. I think about that poster. Everyone chimes in with why you have to use X language, why assembly is the ONLY way to program, why all IDE's are evil and you're a terrible programmer unless you use a text editor/VI/punch cards. Blah, blah, blah.

I am a nerd. But sometimes my fellow nerds REALLY get on my fucking nerves. Thank god I don't have to hang out with you lot at parties.

Re:Word

[crazyjj]

The point is that any computer language could be a better language.

FTFY

Re:Word

[BasilBrush]

I train engineers, not artists.

Ahem. There's a reason Knuth named his series of books "The Art of Computer Programming".

Re:Word

[pjt33]

... they had introduce the strange "yield" keyword to help alleviate the issues caused by this feature.

Or, from a different perspective, they reintroduced a concept (coroutines) that BCPL had but C dropped, forcing people to use obscure hacks. What that has to do with properties, I don't know.

Re:Word

[squiggleslash]

Perhaps I'm misunderstanding, but getters/setters isn't a programming language thing, it's a programming pattern thing. I'd expect an IDE to help with that. I can't see how a better language would deal with not having to put in a particular pattern.

Yes, a major problem with the whole JavaBeans concept is that it requires you code like that. And I'm equally sure Sun could have standardized on an entirely different implementation that would have been less verbose, but they didn't, and that has nothing to do with Java.

Re:Word

[Greyfox]

You organize your code into libraries along functional lines and manage them separately. If you have "several thousand" files, you farm each library out to a separate team. I've never run across a company where one person has been responsible for managing hundreds of files, much less thousands. I've been on projects with 40-50 individual files that have had teams of 4-6 people working on them. Start getting up into the hundreds, even if they're bloated java projects, and you'll start running into projects with 4-5 person teams managing individual libraries of functionality, and several such teams company-wide. Usually such teams will have architects and project leads who know how the entire thing fits together.

I've gotten to the point, in code bases where I've been on such teams, where I actually do know the functionality contained in each file of the code I'm responsible for, maybe 40-50 files at most. And I know most of the functions therein as well. It's not uncommon for me to get a bug report and know the name of the function the problem's in. Since I have the entire design in my head, I can push it around and have a pretty good idea of how things will fit. This is not hard, but it's easier to make excuses about how hard this is. Anyone claiming to have to deal with thousands of files in such a disorganized fashion is probably doing something horribly, horribly wrong.

Re:Word

[BonThomme]

you did that wrong

"Everyone else is doing it wrong."

Re:Word

[box4831]

"Everyone else but me is doing it wrong" should be the official /. motto.

I notice this is particularly true here on the topic on how to be a parent.

"You let your kid watch tv for 30 seconds unsupervised while you took a leak? What a terrible parent. I set my kids up on a OLPC to read various news sources and wikipedia within view of the bathroom so I can supervise them. I care about my children enough to raise them to be Educated, Well-Informed, Critical-Thinking (TM) adults. I feel sorry for your kids. I may give them a bigger tip when they pump my gas, but don't count on it."

Re:Word

[Beezlebub33]

I occassionally copy the code out of Eclipse, paste it in Emacs, do what I want to do, and then copy and paste it back into Eclipse.

I coded in emacs for a good 15-20 years. The usefulness of macros is so strong that it is really hard to part with. That said, Eclipse is my now main tool because it is integrated. Everything is right there, with a nice source code tree (showing me what things I've changed relative to svn), obvious what things are in the classpath, what maven is doing (built-in pom editor), checkstyle integration, autocompile, live debugging (i.e. change the code during debugging and it restarts the function you were in, sweet!), etc.
emacs is better for text editing. For most programming tasks, I'm only editing text for some of the time and Eclipse is much better for those non-text editing things.

Re:Word

[Half-pint HAL]

I'm calling a method which is more expensive but worse the method's result is not deterministic.

Hold on, the whole point of using getters and setters in OO is that (theoretically) all properties should be private. This is so you can completely re-engineer the internals without negatively affecting the program that owns the object instance.

Methods are not necessarily non-deterministic, and getters and setters should be entirely deterministic.

HAL.getHeightInInches() should give the same result as HAL.getHeightInMetres(), except using a different scale. The programmer shouldn't need to know whether the internal representation is metric or imperial.

OK, so in the real world, we need to be able to optimise code, but that's actually another weakness in the language. No, not because the compiler should optimise it, but because languages don't enforce optimisation as the final stage. If you're chosing between properties and methods at the outset, you're optimising too early, and you're making your optimisations part of the fundamental architecture of the system, which doesn't help maintainability.

An integrated development system (not "environment") that folded away optimisations until the last stage would be a wonder indeed.

Re:Word

[Chris Walker]

Well I've been programming for 40 years (since I was 14), and resisted IDE for a long time until I realized that I was being an idiot and embraced Eclipse. It's a tremendous productivity booster, I can't imagine not having the wonderful refactoring tools it offers, and I have no interest in navigating folder hierarchies. But it's a personal choice, use whatever you prefer and don't worry about what others are using.

Re:Word

[Bob9113]

I have been coding since I have been 13 years old, which means I have been writing code for 30 years, and 20 years professionally.

9, 33, and 18 here.

The idea that you don't need an IDE is a hair brained idea.

I have worked on large systems using IntelliJ IDEA and Eclipse, and have written Eclipse plugins. I currently use Emacs without any of the bells and whistles, just syntax highlighting and paren matching.

How on earth are you supposed to keep track of the several thousand files?

Well designed project components and rational directory structure.

I am talking about using a naming convention so that you can easily find functionality

Yeah, that's a good example of one of the things professionals do to keep large systems manageable. It is one of the habits that keeps your system in a place where an IDE is not required.

If I have to keep track of every method name, and its parameters then I am definitely wasting time on stuff that does not need thinking about.

You are making an implicit statement that with an IDE you don't have to do that, and without an IDE you do. The latter is not the case. When coding a class that calls other classes, you have the other classes or their documentation on screen (rotating through buffers if you are using several in rapid sequence), and they (or their documentation) is cleanly structured so you can find the calls that fit your context quickly.

It is definitely a different way of doing things than using the IDE to autocomplete, but it means you have the target code on screen. That makes it faster to verify fine points of the target functionality when you are not sure what it should be doing and gives an opportunity to catch bugs or mismatches in intent. It essentially inlines code review into the standard workflow, with the most often-used code getting reviewed most often.

I'm not saying it is objectively better for everyone and every context than using an IDE. It's a tradeoff, but it is a valid one with upside that is worthy of consideration.

If you say, "oh but wait you should be able to keep track of the methods." I reply, "yeah please write some professional code!"

Well, I don't think you should keep every method in your head, but to address the latter part of your statement: The system I'm working on at the moment is written in Java, Javascript, Python, Perl, SQL, and some shell scripting, has custom coded EC2 cluster management, does load testing at up to a million calls per second using our standard in-house ten slave cluster, has been run with one hundred of Amazon's largest nodes, and aggregates the results into a central database where they are accessed and charted as they happen.

The fact that you prefer to do it a different way and can write a dandy appeal to ridicule is hardly a compelling argument.

How come JetBrains makes money from providing IDE's that do exactly what the article author is bad?

Presumably because a lot of people like to use IDEs and are willing to pay for a good one. But that does not mean that is the only way to program. McDonald's makes a lot of money selling hamburgers, but plenty of people make their own and some people don't even eat meat. The mere fact that something sells well is no argument that it is a requirement for some task for which it can be used.

Re:Word

[Kjella]

And the ratio of artists to engineers is roughly the same as the ratio of people who've read it to those who have not.

Re:Word

[rabtech]

In Java since properties are explicit it's obvious for example that the following would be problematic.

This comment is a great example of supposed "wisdom" that really isn't wise at all.

The compiler/runtime in C# will optimize your example away if it can prove the property isn't calling a webservice or generating side-effects, which is true 99.9% of the time.

Secondly, there is nothing preventing you from doing the exact same thing in C# as you did in Java and good design would dictate that expensive values shouldn't be calculated in properties, they should be methods.

I'm much more interested in the fact that C# treats functions as first-class objects (plus delegates and events) so I don't have to write lots of useless boilerplate to do extremely simple operations. When I can actually get a Java developer to sit down and use LINQ in the real-world, they always come away amazed at how useful it is and how easily it eliminates several methods, nested for loops, etc by simply allowing you to express your intent.

Of course the Lisp guys are standing off to the side screaming "WE'VE BEEN SAYING THIS FOR YEARS!!!" but I would wager that the latest versions of C# have done more to introduce functional programming concepts to a wider variety of programmers than all the functional languages put together.

Re:Word

[jeremyp]

It could be C++

Who the fuck is Willie?

[thammoud]

/. Must have been hacked with this worthless article from a programmer that is still deciding between emacs and Eclipse.

Yo Willie, you can write shit code in any language, any IDE when you are a crappy programmer. IDEs help you better debug, code complete and refactor you crappy code.

Re:Who the fuck is Willie?

[91degrees]

Almost.

Just needs a good editor.

Not sure I agree with the conclusion...

[MadKeithV]

I understand the train of thought, but I feel the conclusion is wrong. The correct conclusion is that OO design following accepted "best" practices (the SOLID principles) makes for difficult-to-navigate code. That doesn't necessarily mean that I think OO design is bad, it just has some pretty major downsides when it comes to navigability if you don't have good support from your development environment.
I remember reading somewhere about a system that does away with the concept of "files" entirely, and the whole coding process is based around smart navigation - what's on your screen could be pulled from many different locations at once without you having to know where from - shame I can't recall where I read that exactly.

Re:Not sure I agree with the conclusion...

[lattyware]

I believe you are thinking of light table.

Re:Not sure I agree with the conclusion...

[bickerdyke]

I remember reading somewhere about a system that does away with the concept of "files" entirely, and the whole coding process is based around smart navigation - what's on your screen could be pulled from many different locations at once without you having to know where from - shame I can't recall where I read that exactly.

Smalltalk?

Did he already heard about integrated debugger ?

[Anonymous Coward]

He says that IDE usage is " 'Because of a combination of shortcomings in the Java compiler and Java's OO nature..."

I use an IDE because it has an visual debugger as I tend to develop aloways in debugging mode (see Hotspot dynamic class update and other JRebel features)...

But the guy must be a great fan of gdb, coredump, vi and edlin ;-)

We are not in 1970 anymore IMHO ...

Rgs,
TM

Re:But eclipse is terrible at navigation

[santax]

I wanted to ask you about non-trivial tasks that need 100+ projects, but then I noticed your signature. Congrats btw, being head developer of Apple Maps must earn really good!

Good luck with that

[Kergan]

only an IDE could love AbstractSingletonProxyFactoryBean.

Uh huh? Naturally, class names such as ASPFB and GDMF and RSAP are evidently more lovable. So much simpler to write...

Re:Good luck with that

[91degrees]

Why does the class name need to tell you it's abstract, a singleton and a Bean?

Re:Good luck with that

[Robert Zenz]

Uh huh? Naturally, class names such as ASPFB and GDMF and RSAP are evidently more lovable. So much simpler to write...

MyClass, MyConn and MyFunc come to mind...*shudders*

100%

[lattyware]

If you have ever written code in Python, you realise how much trivial stuff you have to do in Java which is hell without an IDE. I'm not saying IDEs are useless, they are great and can do awesome stuff for a developer, but Java has a serious problem where it's practically unusable without a massive IDE.

Re:100%

[digitalchinky]

I've been churning out Java, c++, c, and unfortunately PHP for more years than I can remember using only vi. With Java specifically, even on huge projects, I've yet to find an IDE that increases my productivity, just the opposite actually. What could be better than a dozen virtual desktops and an unlimited supply of teminals? :-) I like Java myself, never found it hell at all.

Re:100%

[lattyware]

You enjoy pumping out those getters/setters, writing that boilerplate main class rubbish, etc... then? These things simply are not needed, and can be avoided by giving the programmer the right language features.

Re:100%

[lattyware]

Typing bugs just don't really happen. I don't throw objects around my program like a madman into slots they don't fit. Seriously, even in large projects typing just doesn't really become a problem, and I don't know why everyone is so obsessed with it. Typing bugs are generally trivial, easily spotted bugs, that rarely (if ever) happen.

As to refactoring, I really don't see it makes refactoring any easier, if anything, it makes it harder as you can't swap things out as easily, and increases the size of your codebase meaning you have more to deal with.

Re:100%

[robmv]

I don't call programmers that like dynamic typing so much lazy, but something I noticed in the developers I have known is that a lot of them are the group of developers that are contracted to build something, deploy, and jump to a new contract. How many Ruby programmers have you know than talk garbage about legacy code? a lot, simple, they don't like to maintain old code, It isn't easy with dynamic typing. I grown up as a developer using a dynamic language (Smalltalk), with our own application (own business), I love Smalltalk but we switched to Java long time ago (now using Scala too), and it is not because of the language by itself, it is because long term maintenance is easy for us with static typing

Re:100%

[pjt33]

Pumping out getters and setters can also be avoided by writing object-oriented code. They're a code smell which warns of a lack of encapsulation.

Re:100%

[mean revision]

Echo that emotion.

I worked on a web-app that was done in Groovy and Grails. First release was fast and fun, we got lots of functionality out quickly and it was a delight to work with. Fast forward a year to when we had to maintain the code. Every little thing took a lot more work than it should have. Reading code to discover interfaces, scanning backwards to see what types we were working with, dozens of open source files which we'd always have to check because Intellisense wouldn't help with simple function/variable naming. It was a nightmare.

In the end we scrapped it all and rewrote it in Scala. It's not quite as fun at first but it's quite nice and maintenance is a delight. That one experience totally soured me on dynamic languages for any serious applications.

I code in C#,

[gigaherz]

... and Visual Studio 2010 with ReSharper, and it's the most amazing thing ever... at least until the company decides to upgrade to 2012, which is ugly but it has a lot of new and really useful features.

I'm not going to rant since I know a lot of you would rather forget proprietary software exists, but the rest of the IDEs I have tried to use can't compare, and sometimes even get in your way.

Re:I code in C#,

[ItsIllak]

Totally agree - VS is a great IDE and one that really helps with code navigation, standards compliance and more. Gotta think the GP has no idea how to effectively use all of the features even the worst of modern IDEs bring. I suppose, if Eclipse is the best you've had, notepad++ looks promising but if you've used VS - there's no reason to use anything else.

Eclipse is better if you are a beginner

[bhaak1]

Syntax highlighting and parens matching doesn't really help the beginners. Instant feedback for programming errors is great, you immediately learn about the syntax on the go. Then the debugger is also a great tool (even though I think you should first think, then code, then think again and only as a last resort start the debugger).

These are not Eclipse-unique features, you can get such features with many setups but an easy to install IDE that satisfies your needs and is easily extendable with plugins that integrate seamlessly with your IDE (for example Findbugs).

It's almost like Emacs done right for Java. Well, as right as an IDE can be done.

I don't buy the argument that 1 class means 1 file is a problem (btw, this only applies to public classes anyway). If your project is large enough, you still get navigational problems even if you'd crammed 10000 lines into files (please, don't do this).

Re:Exaggeration quite much?

[mrbluze]

I find that an IDE is usually better than no IDE! The premise of the article is that Java is broken so it needs an IDE. This is like saying that flat screen displays are no good because they fail to represent three dimensional objects adequately. You could solve this by inventing a holographic display - good for you - but few people will shoot themselves in the foot and not use a flat screen display in the interim.

IDE pros & cons

[Anonymous Coward]

Pros:

* Syntax highlighting
* Brace matching
* Symbol autocomplete
* Error highlighting (XCode FTW)
* Go to Definition/Declaration
* Debug with all the above features in place

Cons:

* Some guy says they have a smell, but actually he doesn't like Java (so don't use Java)

I could write code without an IDE, but I wouldn't want to maintain someone else's code without one, and I regularly port (alone) MLOC codebases.

Re:IDE pros & cons

[cozziewozzie]

This whole discussion is fucking bizarre. It turns out that there are many people out there who think that if you are not running a 1435 TB monstrosity of an IDE, your only alternative is ed. Just use an editor from this century, FFS. Emacs, vim, Kate, Notepad+, anything modern and targeted at programmers.

Personally, I use vim:

Code completion? Check
Syntax highlighting? Check
Brace matching? Check
Search and replace w/ regexp? Check
Language-specific auto indentation, retabbing, reindent, etc. Check
Multiple files open in tabs, with easy switching? Check
Language-specific auto commenting? Check
Filesystem navigation? Check
Code folding? Check
Scriptable? Check

I do understand that full-blown IDEs offer some additional functionality: integrated build system, CVS integration, debugger integration, stepping through errors, etc. I don't find these useful personally, but I understand that other people do, and that's OK. Vim and Emacs can also do most of those, but if you are so dependent on all this, then a large IDE is probably something you'll be more comfortable with, and that's OK.

On the other hand, vim has its own advantages -- it doesn't tie you to itself (you use standard tools like CMake and Mercurial/git), it's lightweight (somebody in here suggested increasing the memory available to the VM to 2 GB so Eclipse runs faster WTF?!?!?!?!?), it's fast, and it is unbeatable at keyboard shortcuts. Yes, many IDEs offer configurable keyboard navigation, but it's an afterthought, none of it is as efficient with keyboard as vim. I don't like using mouse for editing.

So in the end, it's up to you to decide. Personally, I'm an editor+shell guy, and I honestly don't feel that I'm missing out on anything. Each to his own.

Attention seeker

[Anonymous Coward]

What we have here is another attention seeker trying to appear enlightened by saying something "counter-intuitive" or "against the grain". It's a bit like those people that go out of their way to let you know that they don't think Dark Side of the Moon was the best Pink Floyd album, because their opinions are so diverse and more informed than all the "sheeple".

IDEs are a smell? What? No mate, you smell. IDEs drastically improve productivity. Yes, part of that is code navigation - mature libraries and frameworks such as the STL, Java, and .NET are HUGE - not because they are poorly designed (though that may also be true; correlation != causation), but because the sheer number of features makes library and framework searching essential. No human could possibly use these libraries as efficiently without code completion or prompting, except for the parts they use most frequently. IDEs make the libraries and frameworks discoverable.

That's not even to mention all the OTHER benefits IDEs bring - integrated debugging, refactoring, static analysis, test coverage analysis, code style management, build chain management, source control integration....

Yeah, yeah, I bet this guy is 1337, uses ONLY notepad / ed, hand writes his make files, and is the most badass coder on the entire planet. The problem is - nobody cares. Everyone else is more concerned with getting the job done efficiently. IDEs are simply essential in the large code bases I work with every day, and that would be true whether I were dealing with a million lines of Java or a million lines of Haskell / Python / Whatever this guy thinks a "good language" is.

Re:Attention seeker

[dkf]

IDEs are great, but you have to admit that Java forces you to use one.

The problem is the language's social convention (for want of a better term) that long package names, class names and method names are used. Auto-completion and support for managing the imports are the features that make a Java IDE win out over an editor like Emacs (which I used to use for Java programming). Other languages use much terser conventions and make it easier to code with a normal editor with no ill-effects (though some go a bit far) so I'm sure that the problem is the very long names; frankly, typing that much stuff out by hand every time gets old very fast indeed.

The other things that IDEs tend to offer are less useful to me because of the type of code I usually write. (Security-sensitive server code that integrates a bunch of other people's code is a PITA to test and debug anyway, and I try to avoid confusing naming in the first place so refactorings aren't a problem anyway.)

IDEs are very useful,and it's not language's fault

[coder111]

Well that's bullshit. The biggest problem with development these days is not the language itself, but the 100s of 3rd party mostly-open-source libraries that you have to use. Or else go reinventing the wheel which is worse.

And IDE helps you see the reference for these libraries much easier, using autocomplete and automated documentation lookup. On top of that, navigating your own code is much much easier. Add debuggers and profilers, granted, somewhat less useful in server-side environment but still useful. Semi-automated refactoring though is great, and eclipse does that quite well.

I've done my share of development using nothing more than a text editor. But I prefer to use IDE when I can- they make me much more productive. Of course I still make sure code can be built & deployed using plain command line tools- for Java Maven is great.

--Coder

I like Eclipse except for one flaw

[GoodNewsJimDotCom]

Eclipse starts to get annoying type lag around 30k lines of code in a single file, as you get bigger and bigger upwards to 100k or more, it can take several seconds between characters you type. Now some people say you shouldn't have a single file with over 100k lines of code, but some of us like using old school procedural with just a sprinkling of OO.

Re:I like Eclipse except for one flaw

[slim]

Now some people say you shouldn't have a single file with over 100k lines of code, but some of us like using old school procedural with just a sprinkling of OO.

Please don't put 100k lines of code in one file, even if you're writing non-OO C.

Re:I like Eclipse except for one flaw

[Xest]

"Now some people say you shouldn't have a single file with over 100k lines of code, but some of us like using old school procedural with just a sprinkling of OO."

100k lines of code in a single file has nothing to do with being "old school" and everything to do with abysmal code structure.

And IDE is just like any other tool . . .

[PolygamousRanchKid]

It's just as good as the artisan who uses it. You can use a hammer to drive in a nail . . . or to smash a vase. It depends on how you use it.

An IDE won't make a good programmer write bad code. And it won't make a bad programmer write good code. Unfortunately, a lot of manager types assume that if they buy some expensive tools, their programmers will automatically program gold from straw.

A text editor that does the job IS an IDE

[Alkonaut]

Most bizarre conclusion I have ever seen. Of course you can have highlighting and other editing tricks (autocomplete, etc.) in a text editor. But once you add things like unit test integration, deployment, and most importantly an interactive debugger where you can step through your code, you have a proper development environment. Running tests can be done at a shell prompt, but debugging not so much. And if your text editor ticks all these boxes, including interactive debugging (I'm sure emacs can for example), then your text editor IS A FREAKING IDE ALREADY. I'd like to make the inverse conclusion of TFA: since we have proper IDE:s we can now allow the code in modern languages to be structured an way we want. A good IDE should never have you worrying about files, just code.

Re:Did he already heard about integrated debugger

[Alkonaut]

I would argue the opposite. If you execute code it will invariably do things you didn't expect, regardless of language. You either debug or guess. I saw no argument as to why guessing is preferable to interactive debugging? I agree that "null" is a language smell, but there are concepts like code contracts that lets you have non-null enforced etc. There are a million other things you can debug regardless of language.

Re:But eclipse is terrible at navigation

[Anonymous Coward]

Eclipse failed because projects have to be small.

Curious. My Eclipse project is the Linux Kernel. Works fine.

Tip for young players: Eclipse runs on the JVM, the important bit is the last two letters "VM" - "Virtual Machine". The out of the box configuration gives Eclipse ~128MB of memory.... how many VMs do you run with that much memory? Change the default values to something sane (ie 2GB) and suddenly Eclipse is fast, responsive and useful. Remember VM = Virtual Machine.

Re:Did he already heard about integrated debugger

[mwvdlee]

In most languages you don't need a debugger for stuff like null pointers; perfectly fine exceptions are thrown and reported telling you exactly what you did wrong. When is the last time you ever used a debugger to track down such a bug? You use debuggers to analyse why some algorithm isn't worked as it's supposed to; for finding flaws in human thinking.

What is he on..

[Rexdude]

TL;DR - Let's all ditch IDEs and go back to Notepad/vi/emacs/edlin.

Code generation in Eclipse is a breeze, it easily creates framework classes where you can plug in your code. Directly jump to classes, view javadoc when you mouseover any element, jump between occurrences of text within a file, seamlessly integrate with the version control system of your choice - it has everything to properly work with a modern software project that can have hundreds or thousands of classes and files.
And the same goes for Netbeans or Visual Studio or any other IDE of choice.

Finally, tell me how many real world projects use Haskell, Clojure or Scala as compared to ones using Java/C/C++/Python/Ruby/PHP/Perl. I don't exactly see dozens of job openings for the former on various job boards. You work with what you've got, unless you're an ivory tower academic who's only concerned with the design of a language as opposed to its real world usage.

Re:What is he on..

[Anonymous Coward]

The author of the blog post is actually running a software company that sells solutions in Scala, Closure and Haskell (just check the web page www.recursivity.com).
Yes, there are very few real world projects in such languages but that's confusing common practices with best practices.

Re:What is he on..

[hcs_$reboot]

Don't underestimate the snobbish aura that immediately emanates from you when you say you're a Haskell programmer.

Re:But eclipse is terrible at navigation

[hcs_$reboot]

being head developer of Apple Maps must earn really good!

Well, he's just been fired. So now he has enough time to spend on slashdot, lucky him. And welcome!

Re:Did he already heard about integrated debugger

[lattyware]

Then why can you catch an exception? Exceptions are the perfect tool for this kind of job - you might not be able to open that file, what will you do if you can't? Catch that exception and deal with it. It means you get the feedback at the right point.

Re:Did he already heard about integrated debugger

[dkf]

I would argue needing a debugger is also a sign of language flaws. Debuggers help you find issues with your code while it runs.

The biggest code smell is the lack of an ability to attach a REPL to a running program so you can poke around in it, define new things at runtime and experiment with them until they work, and then translate that back into "fixed" code in a source file. But that's not really the way you do things in Java (and a few other languages as well).

Re:Refactoring can be done by any decent editor

[91degrees]

You mean like "%s/old name/new name/g" that the vi editor has had since the 80s? Perhaps you should try using a programmers editor. You might be surprised at just how little extra an IDE gives you.

I don't know. Does vi automatically deduce the scope of the variable and change references to it globally without affecting identically named variables in other classes or variables that the changed name is a substring of?

"2 or more xterms and "grep". I find that combination far more efficient than some bloatware IDE

The source I'm working on has a lot of members of different classes with the same names.

Re:Did he already heard about integrated debugger

[darkat]

In general, if you need a debugger while developing your code then you may not know what you are doing. Maybe you are developing very special stuff, otherwise the intensive use of a debugger means either lack of experience and/or skill..

Re:But eclipse is terrible at navigation

[thammoud]

Really want to meet the moron that modded you insightful.

Re:Why I like Eclipse

[ledow]

I use Eclipse for C99-development. It's wonderful and, most importantly, free.

I use everything from SVN-integration and version control, to the diff-generation / compare, to multiple projects (with common projects auto-included and updated when necessary), with multiple compile-paths (Debug, Release, other architectures, other compilers etc.), refactoring, debugging, hell it even integrates with the Android development kits if you set it up right.

Years ago I was introduced to Eclipse when I sought an alternative for my university Java course (which was pathetic even back then and used some horrendous IDE). Since then, my entire development environment for several projects has just sat in the same Eclipse folder and suffered everything from computer moves to Eclipse upgrades to compiler upgrades (e.g. through several Cygwin and MinGW upgrades and conversions) to even OS-changes (currently using the same basic setup for both Windows and Linux) without problems.

An IDE is there to make life easy. Sure, it would be wonderful if no programming language required multiple files but it would also be wonderful for every setup program in the world to consist of a single file, every application to be a single file, and none of them be obscured archives that contain multiple internal files. But, in real life, C has been around a lot longer and nobody's really found a solution for using and working with multiple files.

In fact, .h files are ENTIRELY a traditional fabrication - there's nothing in them that you can't append to a .c / .cpp file and still have things work. We *deliberately* duplicate unnecessary prototypes for functions we've written for a COMPLETELY administrative purpose. There's nothing in the standards about REQUIRING things to have multiple files. And yet every single non-trivial program that exists separates things out and the IDE has to cope with that to make it manageable.

And the other features of the IDE are there to help, not because the underlying code is unreadable (the IDE can't perform miracles and make gibberish into perfect prose) but because humans work better when they build tools to aid how they work (colour-coding, cross-references etc.).

The IDE is the computer-human interface. It has to deal more with the human than it does the language, and the human has to do a huge range of idiosyncratic things that have NOTHING to do with the language construct whatsoever. Playing with the IDE trying to solve that is really just trying to break the way people work, not solve an inherent language problem.

Aren't All Big Projects Harder To Manage?

[assertation]

I'm not an ubergeek, so maybe my view isn't as good as the guy who wrote this article, but aren't all large projects, regardless of language, harder to manage?

I've worked maintenance on projects done in an old procedural style. I can't believe anyone in 2012 would think that OO is not an improvement and actually makes managing a project harder.

Re:Did he already heard about integrated debugger

[lattyware]

Ugh, as always happens I poorly phrase the first sentence of my post and everyone jumps on it. I wasn't saying debuggers are bad, or at least wasn't trying to - just that in Java, the standard library has a tendency to return null when something goes wrong rather than throw an exception, which means you don't get told about the cause of the issue, just when it shows up later as a null pointer exception. This can lead to using the debugger a lot or looking through the code to track it down. I hope that clarifies my point.

Agreed!

[zmooc]

I (professional Java coder since 1998) absolutely agree. Java is hardly human-writable, even if it were only for the import statements. Without the existence of some very good IDEs Java might very well not have been as popular as it is today. But it is.

Is this a problem? Apparently not in practice. Would I rather have a more dense, less IDE-dependent language? Yes. Are such alternatives available and do they come with an enormous ecosystem of supporting libraries? Nope...

Clojure and Scala aren't that much better

[hibiki_r]

While I am not fond of Java's inability to define functions with a proper syntax, it's not as if the alternatives are noticeably better as far as not needing navigation. In the end, it all comes down to program complexity. A developer still has to know the code he needs to use, and for any program of reasonable complexity, you need to either remember it or use an IDE to easily access it. And given the ungodly number of libraries we use today, this happens even when you are coding in Javascript.

If anything, the fact that Java is statically typed makes it easier on IDEs to tell you all the details of available classes. IDE support for Scala will still have you remembering signatures that Java wouldn't have to. And we all know the fun of Javascript, where most IDEs will not be able to guess what properties a object has, because the only way to know is to run the app.

Don't get me wrong, I sure wish for at least Groovy-like function support, unlike, say, the horrible things people do to try to write functionally in Java (welcome Guava abuse!), but the only way some of those languages make you not 'need' and IDE is because IDEs can barely understand the languages. I'd not call that a good thing.

Re:But eclipse is terrible at navigation

[Anonymous Coward]

Why Eclipse and NetBeans and all that crap? Because refactoring and autocomplete.

Re:But eclipse is terrible at navigation

[kiddygrinder]

i hope none of your decisions matter to anyone

Eureka!

[Kookus]

I think the eureka moment should be when you realize that any language can fall into the trap that you describe. There's reasons for the complexity. Whether they are for compilation/parsing performance, or for some type of design pattern to elegantly solve a problem.

I've got a buddy down the hall who grew up ASP and VB. He uses notepad for development, and complains about not having pointers in Java. Syntax highlighting/completion aside, it takes him forever to write even some of the most basic classes. It's a constant game of finding something to copy and paste. What clicks off in my head is that when you're copying and pasting so much, someone probably already wrote a library for what you were trying to do. Hence additional files, includes, whatever it is... it's more of that whole lots and lots of small files that are mentioned as a downer in the op.

If you're complaining about OO patterns, that's not language specific. Heck, even SAP has an OO equivalent.OO is a byproduct of merging human conceptualization and computer language. It becomes more "natural", arguably, for a developer to understand. Is that a problem of the language? No. I can write just as much spaghetti code as OO in Java, well, pretty much any language for that matter.

Now for your humorous AbstractSingletonProxyFactoryBean. If you're writing a webpage with some fancy graphics on the front and not much user interaction, then you'll probably come across this class and think wtf would anyone ever use it?
If you come from the data processing world with many systems working on the same data, you pretty much don't live without it.

This is equivalent to growing up in Mexico, never even hearing of the word snow, and then see someone walk by with a pair of snowshoes in hand. Do you point and laugh first, or do you try to understand why they have snowshoes?

Snowshoes are obviously everything that is wrong with footwear.

Oh, but Java is human READABLE

[coder111]

Have you tried reading perl code? Or mediocre to bad C/C++? It's impossible to decypher most of the time.

I consider Java to be the easiest language to READ code in and to understand it. Most of the time it's possible to quickly decypher even crap code written by newbies. I'll live with having to write slightly more verbose code or slightly more boilerplate code just for this reason. Or with having to use an IDE to do that for me.

--Coder

Total nonsense

[DrXym]

Even the best language in the world would benefit from the facilities that an IDE brings - syntax hilighting, code completion, refactoring, integrated source control, incremental builds, error hilighting, integrated bug / task management, wizards, formatting, build / clean / deploy, multiple projects, interactive debugging, etc. etc. etc.

You'd have to be a masochist to choose a basic syntax hilighting editor over an IDE without an extremely good reason. I realise there are a lot of good reasons but a language so perfect that an IDE is unnecessary is not one of them.

Re:Did he already heard about integrated debugger

[dkf]

The place where something finally called a method on a null is not necessary place where the bug is. The question is why that variable has a null value at that moment. You will not find it in the stack trace.

If your logic is so complicated that you can't tell where a variable should have been assigned, your code is already an unmanageable mess. Add preconditions on the arguments to your methods and enforce them by throwing an informative exception if they are not satisfied; that helps hugely. If it doesn't, it's time to also do postconditions and invariants. If you don't understand what those preconditions and postconditions should be, that's a much more important problem than where your code is throwing a NullPointerException...

Re:But eclipse is terrible at navigation

[Waffle Iron]

Change the default values to something sane (ie 2GB) and suddenly Eclipse is fast, responsive and useful.

Maybe they should rename Eclipse to be called "tgacs". This would bring consistency with how emacs was originally named for being "Eight megs and constantly swapping".

Re:But eclipse is terrible at navigation

[nitehawk214]

Curious. My Eclipse project is the Linux Kernel. Works fine.

I hope, none of your code is included and enabled on any of my systems.

Commas, will be misplaced.

That is extremely stupid

[neminem]

I can't imagine living without an IDE. Having the ability to actually debug my code in-place from the same place I'm editing it, increases coding productivity like crazy, and I can't even imagine anyone seriously trying to argue otherwise. I do agree that it's commonly thought that you should put each class in its own file, and that that's just silly, that it's a lot more readable when multiple classes that are tightly related are put in the same file so you can see them all at once and see the tightly-relatedness. I'm not sure that really has anything to do with having an IDE or not, though.

On the other hand, Eclipse certainly does have a massive smell of its own. He says "if you suffer from tool frustration, it's not necessary your tools that are poor, it may be that your language sucks, or you're not using it correctly", but no, if you're talking about Java, where the only real IDE is Eclipse... it's because your tool sucks.

IDEs aren't pure benefit

[dbrueck]

Modern IDEs can be great, but using them does come at a cost, so I think people end up using them in situations where there is a net benefit (and the opposite is true - people don't use them where there is a net cost to using an IDE). Personally, using a full-fledge IDE often leaves me with a feeling of it getting in the way, but I tolerate it because with some languages or platforms the IDE is still a net win.

This is nothing but an anecdote, but we have several non-trivial projects (100kLOC+ each) in C/C++, C#, ObjC, Java, and Python worked on by about 10 people (so not huge by any means, but not so trivial as to be meaningless) and:

    * Everybody uses an IDE for the ObjC, C#, and Java projects
    * About half use an IDE for the C/C++ projects (rest use vim)
    * Nobody uses an IDE for the Python projects (most use vim)

What's interesting to me is that as far as I know everyone has /tried/ not using an IDE for Java/ObjC/C#, and everyone has tried using an IDE for Python, and there has never been any sort of mandate to go one way or another, and so the present situation is the result of everyone sort of landing where it feels most natural and where they are the most productive, and that we have the same results regardless of proficiency in a particular language (i.e. the C# experts and C# noobs end up with the same development environment, as do the Python experts and the Python noobs). The same also appears to be true regardless of language affinity - lovers and haters of Java use the same environment, lovers and haters of Python do as well, etc.

I do wonder if there is some sort of correlation between environment and the language. I know this is pretty subjective, but for me languages like Python feel like they rarely get in your way, and so it's interesting that when people in our company use Python, they gravitate towards development environments that are similarly lightweight. And conversely, for me a language like Java tends to feel like it gets in the way a lot (as in, you have to do lots of things that are satisfying the demands of the language that aren't directly tied to the problem you're trying to solve), and an IDE is indispensable because the IDE helps shoulder some of that burden.

Not obvious at all it is problematic

[SuperKendall]

for (int j = 0; j < getCount(); j++) {

And what if in the loop something had been altered to extend the results of getCount()? Bad coding I would say, but you are discounting that possibility with your fix...

In reality though, a good compiler will optimize that away if it's really just generated an accessor method for that call. In reality there is no problem with coding against accessors for modern languages because the compiler will fix performance problems like that.

McCarthy

[Anonymous Coward]

That stern looking old fart is John McCarthy. He probably did more for computing that all of us put together.

Re:But eclipse is terrible at navigation

[H0p313ss]

Eclipse failed because projects have to be small.

Curious. My Eclipse project is the Linux Kernel. Works fine.

Tip for young players: Eclipse runs on the JVM, the important bit is the last two letters "VM" - "Virtual Machine". The out of the box configuration gives Eclipse ~128MB of memory.... how many VMs do you run with that much memory? Change the default values to something sane (ie 2GB) and suddenly Eclipse is fast, responsive and useful. Remember VM = Virtual Machine.

Word up. At IBM 100 projects is a small workspace.

Re:Did he already heard about integrated debugger

[H0p313ss]

In most languages you don't need a debugger for stuff like null pointers; perfectly fine exceptions are thrown and reported telling you exactly what you did wrong. When is the last time you ever used a debugger to track down such a bug? You use debuggers to analyse why some algorithm isn't worked as it's supposed to; for finding flaws in human thinking.

I'm thinking you've never worked on a multi-threaded application with millions of lines of code. With a debugger, set an exception breakpoint and you can usually see exactly why something bad happened with almost no time wasted on "analysis". If I can reproduce a problem in a debugger I can usually fic it about 10x faster and more reliably than if all I have is a stack trace.

Re:But eclipse is terrible at navigation

[dotancohen]

Maybe they should rename Eclipse to be called "tgacs".

Have you never used Ctags? Works great with that other bit of software that has the letters VM in it: VIM.

Re:But eclipse is terrible at navigation

[kelemvor4]

Mine is "Beatify Code." That feature is the reason I bought slick. I don't use it as my main editor, though.. I paste code in, beatify, copy and paste back out in most cases.

Re:But eclipse is terrible at navigation

[Pseudonym]

I would far sooner write Java using Eclipse, and I would far sooner write C++, Perl or Haskell using gvim.

Admittedly this could just be my limited experience, but Java seems pretty hard to write effectively if you don't have a refactoring editor. You could spin it as a shortcoming of the language, or you could spin it as a symbiosis between the language and the IDE. Which way you choose to interpret it largely depends on what barrow you're pushing.

Re:But eclipse is terrible at navigation

[UnknownSoldier]

> Java seems pretty hard to write effectively if you don't have a refactoring editor.
That is exactly the problem! Any language that depends on having a good IDE is badly designed IMHO.

Part of the problem is that the "standard" libraries are "invisible" APIs. You don't know them until you either
  a) memorize the function names along with the parameters, or
  b) rely on a tool to do it for you: either book-form, or electronic form.

  You can see this quite easily in C++ with all the bloat of the STL. While it is a beautifully designed API you still need a "reference" page in order to use it until you become familiar with it. In the pre-C++ days the problem wasn't as exasperated since all it was relatively easily to look up a function. With namespaces you can easily have many false positives due to lack of a _unique_ function name; you effectively only have a relative name.

Re:But eclipse is terrible at navigation

[Pseudonym]

That is exactly the problem! Any language that depends on having a good IDE is badly designed IMHO.

Alternatively, the IDE is properly thought of as part of the language.