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

[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

[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

[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

[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

[neokushan]

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

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

[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

[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.

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.

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

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...

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%

[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%

[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

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.

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.)

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: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: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: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: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.