Slashdot Mirror
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!"
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.
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.
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?
The source I'm working on has a lot of members of different classes with the same names.
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...
0x or or snor perron?!
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.
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.