Catch up on stories from the past week (and beyond) at the Slashdot story archive


Forgot your password?

The IDE As a Bad Programming Language Enabler 586

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!"
This discussion has been archived. No new comments can be posted.

The IDE As a Bad Programming Language Enabler

Comments Filter:
  • by MadKeithV ( 102058 ) on Tuesday October 30, 2012 @05:28AM (#41815467)
    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.
  • by Anonymous Coward on Tuesday October 30, 2012 @06:10AM (#41815673)

    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.

  • by 91degrees ( 207121 ) on Tuesday October 30, 2012 @07:00AM (#41815865) Journal

    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:Word (Score:4, Interesting)

    by daem0n1x ( 748565 ) on Tuesday October 30, 2012 @07:12AM (#41815949)

    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.

  • Agreed! (Score:5, Interesting)

    by zmooc ( 33175 ) <.ten.coomz. .ta. .coomz.> on Tuesday October 30, 2012 @07:45AM (#41816141) Homepage

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

  • Re:Word (Score:5, Interesting)

    by sproketboy ( 608031 ) on Tuesday October 30, 2012 @07:45AM (#41816143)

    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.

  • Eureka! (Score:4, Interesting)

    by Kookus ( 653170 ) on Tuesday October 30, 2012 @08:06AM (#41816251) Journal

    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.

  • Re:Word (Score:4, Interesting)

    by YttriumOxide ( 837412 ) <yttriumox&gmail,com> on Tuesday October 30, 2012 @08:10AM (#41816277) Homepage Journal

    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 (Score:4, Interesting)

    by i ( 8254 ) on Tuesday October 30, 2012 @08:26AM (#41816375)

    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 ( !! I felt I was on the technical frontier!! :D

  • by TheSkepticalOptimist ( 898384 ) on Tuesday October 30, 2012 @09:21AM (#41816867)

    The reason why you break a large "complex" system into small interface files is exactly for EASE of continued development.

    This guy wants to write one large file that contains all of his classes and interface (or lack there-of) and therefore only needs a text editor. This guy is not worth his salt as a developer.

    You can't build large systems this way. Monolithic FILES (opposed to an IDE) are full of old, unusable code and prone to significant defects when worked on by a team of people.

    Also I tire of the idea that I am not a real programmer because I use an IDE which auto-completes and has syntax highlighting. I build apps, I don't spend hours making one line of code execute as efficiently as possible. There is a point of diminished returns where the amount of time you toil over every line of code does not translate into faster more efficient code, so I work at the high level building large complex systems with relative ease, efficiency, and with adequate performance that is acceptable to the clients I work for. Also I finish a project on time rather the going 6 months over.

    I am sure this guy is just lamenting the fact that Eclipse isn't the greatest IDE out there, but the idea that you don't need an IDE for the reason that it creates lots of small files that this guy considered "complex" proves he is a moron and should be ignored.

    BTW a good IDE allows you to quickly and easily navigate lots of those pesky SOLID code files. If you don't know SOLID, look it up.

  • by dbrueck ( 1872018 ) on Tuesday October 30, 2012 @10:46AM (#41817941)

    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.

  • Re:100% (Score:5, Interesting)

    by mean revision ( 2542028 ) on Tuesday October 30, 2012 @11:29AM (#41818455)

    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.

A consultant is a person who borrows your watch, tells you what time it is, pockets the watch, and sends you a bill for it.