IDEWTF

Photoshop, Premiere, Maya, AutoCAD, ProTools, Finale, Reason, InDesign. These are the state-of-the art tools for creators. They are all rich, powerful, versatile programs that strive to work at the artist’s level of thought.

And the people who write this amazing software get to use… Visual Studio? Eclipse? Emacs? At least I’ve heard IntelliJ IDEA is great, I’ve never used it. But when contrasting these to the tools above something seems missing. Like a library full of features that bring programs to the coder’s level of abstraction. Languages are attempting this now, but languages are written in text and IDEs are basically text editors with a few extra features. Photographers have clone (a tool that lets them erase sections of images replacing it with something that looks convincingly the background in that area), we have refactor-rename that doesn’t even respect alpha conversion (avoiding name conflicts with your new name).

Why do we even have to worry about alpha conversion? That’s like a composer worrying about MIDI patch numbers! We still denote identity with a string? Premiere wouldn’t have that — it would link directly to the clip in question. Who cares if you have named something else the same thing? My friends have no trouble distinguishing me from another Luke who walked in the room.

And files? We have libraries, namespaces, modules, classes, and functions to organize our code. Files are almost entirely orthogonal and not-almost entirely meaningless. Kudos to CodeBubbles for noticing and removing that tumor. But, that’s just a guy at a university, so naturally we won’t get to use that for real for quite some time.

What’s up with import statements? That’s just some junk that comes with representing programs as text. Eclipse has surpassed those… sortof… but we’re not all Java programmers. Why can’t I just type the class name and then pick the one I want from a list?

All the state-of-the-art creative programs have multiple views: more than one way to see your creation to get a better handle on it. Maya has isometric, wireframe, flat-shaded, full light…. We have the class hierarchy view. Oh boy. Why can’t I look at

    while (!queue.empty()) {
        Production p = queue.pop();
        predict(p);
        if (p.star.is_terminal) { scan(p); }
        complete(p);
    }

click a little [+] next to predict(p) and see it right there inline, with its argument replaced by p? Oh, that’s how that works, cool, [-]. Instead we go to its definition, where we see it next to the functions we happened to define near it, about which we care nothing. Then we substitute the arguments in our heads, fathom loop invariants and fail to see how they are violated, and spend the next 5 minutes wondering if p is mutated in this call chain.

How come I can still have syntax errors? How come it is ever possible to have a syntax error in a program? Shouldn’t the IDE at least be helping me to have a valid program all the time? Finale doesn’t let you write a measure with the wrong number of beats and then complain when you push play. It just fixes it for you — “oh look, you need a rest there.”

“My indentation’s wrong. Oops, rename missed that one. Oh right, need to import Data.List. Ugh, namespace pollution. Fine, looks like I need to copy and paste again because abstracting will be a pain. I hate how you can only have one class per file and how it discourages small classes. Shit, that mFoo/foo accessor pattern again… weren’t get/set supposed to do away with the need for accessors? Fuck, looks like this virtual method needs another parameter — give me fifteen minutes.”

Do we not hear ourselves?! Software developers, the masters that create the masters’ tools, are touching up Avatar with mspaint. Shouldn’t we be sculpting effortlessly a masterpiece with a beautiful dynamic interface while robots bring us platters of Mountain Dew? We’re wasting our time with spelling errors while the 3D artist in the back is putting finishing touches on his city.

W. T. F.

If you were entertained, Flattr this. Thanks :-)

47 thoughts on “IDEWTF

  1. Somehow, I have the impression that the lack of a good IDE is caused by the fact that GUIs are difficult to program.

    From my own experiments, it appears to me that the most practical solution for the GUI problem in Haskell is to start with a black screen and draw a new GUI from scratch, e.g. without using any native widgets. Surprisingly, this is way easier than hunting for documentation of your widget library only to find out that the functionality you need is not implemented in the generality you need.

  2. When I do hobby development in the Open Source world, I always miss Resharper + Visual Studio. Resharper is flat-out simply the best piece of software I’ve ever used. It handles virtually every issue you mention, except the having to jump to the definition.

  3. I also loved Resharper and sorely miss it! It is a real shame that the Haskell world hasn’t got an IDE of the same calibre. Decent refactoring support for Haskell would be particularly interesting, as you could in theory leverage the existing literature on program transformation to go way above and beyond what traditional refactoring systems (and even HaRE) offer.

  4. You seem quite pissed these days. But many can understand that feeling.

    To me the programming ( and even hardware ) universe is suffering from itself, It’s a recurrent “problem”.

    You describe concepts that are considered natural and free in high end softwares that we, as programmers, encounters rarely, and the reason for that lies here. Designers of these softwares do not think in computer lingo or culture, they just devise great things that unleash the possible and make you free and responsible for your own results. It happens that those good ideas are orthogonal to the domain they apply. I discovered genericity in Maya long before following courses about ADA. Same goes for “MVC” , again maya can run headless, interacting via a repl .. and that’s for so,ething targetting the graphic industry. Modo has combinating tools that arent shy compared to things like parsec, the devs had to quit their previous company to be able to do those things that nobody valued at first.
    Almost all the highend 3D animation systems had DAG underneath, allowing for the users to think freely and have live results (stateless to the least) for higly complex objects. How many programmers have ever touched something like this ? How many of them ignore that compilers transform their statefull imperative programs into dataflow graphs of the same kind ?
    If my old P2 350 can display =rigid body simulation, particles , skinned skeletons all that together .. and in RT no less.. why can a simple program , piece of text can be as live and tangible ?

    To cut short, any domain closed over itself will stagnate, adding the fact that the software world generate loads of money, and appears to be engineering (even if I rarely meet people that would qualify for that title)

    It went to the point that teachers even dissed programs trying to emulate some good ideas of Maya, because it wasnt following the state of the art in UI design (namely MS Office or 3Dsmax) .. I had a blast.

    Reminds me of the amiga team having multitasking long before the ‘big’ ones. Thinking out of the box.

    I may be wrong, but this way of designing things seemed to be the norm in the lisp world. The SICP vids talk about wishful thinking oriented development.

    to be continued..

  5. This issue is largely orthogonal to Dana and techniques of writing provably-correct code, but it has a similar feel to me: why do we waste time writing test after test and chasing down errors when we could work under the assurance of formal methods?

    (In another sense this is nearly the opposite way of thinking, from a common-programmer user-friendliness standpoint!)

    My personal annoyance is that even though interpreters are more common these days, it has not lead to a truly interactive programming paradigm: the end-use code is still edited in a file. I would prefer to think of the interpreter as more primary, with files representing saved interactive sessions or programs exported from sessions.

  6. Luke: The product from Intentional Software allows you to view your code in multiple ways.

    Abram: The Smalltalk/Squeak guys have had interactive programming for decades. It’s also shown up in other places like Self and a Python GUI dev env whose name I forget.

    As other commenters have pointed out, there are various products and IDEs that have some nice features. Perhaps the real problem is that they don’t all work together with each other and with other languages.

  7. IMHO, a big showstopper for anything “better than text source code” is revision control.
    Text files can have revision control. Photoshop, Premiere, Maya, AutoCAD, ProTools, Finale, Reason, PageMaker don’t have more than undo/redo (afaik). No merging, cherrypicking, …

    Of course, you could make revision control on other dataformats. When the IDE would log all changes, you could even get better revision control than with text files (something like in darcs: every logged change is a patch. Log changes as high-level as possible instead of just the state before and after the change. For refactorings, for example, log the refactoring parameters)

  8. I personally think it’s because programming is fundamentally text. Vim makes text manipulation easy and plugins add some understand (which could be better of course). I’d love for an IDE to start with the idea of programmers don’t need to touch the mouse (but can choose to), and then also include strong understanding of the languages it supports.

    Unfortunately, some IDEs do the things you say (e.g. ignoring imports, searching for everything) but are slow and annoying as a result.

    Syntax errors should have suggested fixes, but just assuming stuff (like indentation) could have wildly different effects. If it doesn’t report the problem then it could result in a bug that the developer never has the chance to fix before it’s run.

  9. thanks! yes i sympathize with the author and everyone’s comments…

    i continue to think its going to require presenting each individual source code symbol or word as graph nodes in a dynamic graph visualizer, informed by an adaptive abstract syntax model… not rigid 2d matrices of characters anymore. basically to soften the boundaries between IDE constructs like ‘projects’, ‘files’, ‘functions’, etc

    the article mentions codebubbles http://www.cs.brown.edu/people/acb/codebubbles_site.htm which is nearer to what i’m imagining

    :)

  10. @okmijn, interesting observation about abstraction in other fields. I hadn’t considered that. That’ll have to sink in.

    @Abram, yes! I love the idea of Squeak, I just wish it were done better. Totally gross imperative UI framework, impossible to work in.

    @Sebastian, I wrote this article because I am currently devising a structural IDE (browser-based), as a way to understand why I was doing so. Anyway, your idea (“structural version control”) is my task tonight. Alike minds think great.

    @Joel, if you say “programs are fundamentally X”, I have to argue http://lukepalmer.wordpress.com/2010/09/24/programs-are-made-of-ideas/ . As for syntax errors, I wasn’t thinking so much autocorrect as stuructural editing, in which invalid syntax is never seen, even while working. For example, you can’t even enter an unmatched parenthesis, and if you delete one the other goes with it.

  11. @Luke – yeah, I’ll retract that statement about programming is text. Oops, seems dumb in hindsight.

    I’d be interested to see how a structural editor would work in an efficient way. Accidentally deleting blocks of code or methods could be annoying (e.g. pressing delete on the right of a ‘}’ and have the block disappear), but of course undo is but a keypress away so perhaps it’d be fine.

  12. @Joel: Yes… one issue I have with current dynamically-helping editors is that they don’t usually make sense while one is typing. IE, red squiggles all over the place until you get to the end-bracket… I’m not sure how to overcome that w/o resorting to menus/buttons/drag-and-drop to insert specific things (like loops, if-thens), which seems like a terrible idea for practical coding!

    @SeH: That seems too radical to me. :) Graphs are nice for displaying certain things, but sometimes it is just easier to say things than to draw them. (Math on blackboards uses some graphs, but a lot of symbols!)

    So, I agree with codebubbles hybrid approach more… though I must admit, I’m even tempted by Joel’s assertion that we should not ever *have* to touch the mouse during normal coding…. :)

  13. @Abram: You would rather like to have interactive shell at any point in the source, with neatly displayed context and context-dependent type-aware completion. Something like what proof assistants strive for. With either symbolic computation (simplification) or synthesized example values, to be able to experiment.

  14. But but but what about that last minute fix using vi on the production server :-p? If your code is not in a file, or if the file was auto generated by the IDE, can you still change your code without the IDE? But yes, I agree with you, we need a bit more innovation on the IDE front…

  15. Adobe PageMaker was discontinued in 2004[1]

    [1]http://en.wikipedia.org/wiki/Adobe_PageMaker

    You probably mean InDesign, its successor for desktop publishing layout application in the CS suite.

  16. You are absolutely right, good tools (especially IDE’s) are rare.
    But if only some developers made up their mind : sometimes great things need to be paid for … IntelliJ IDEA may be the first programm I actually bought, ever.
    Everything (almost no exceptions) you complain about is solved. Please buy it and enjoy your life again. Version 9 feels like paradise.
    Yes, it is expensive. But look at the prices of Photoshop, Premiere …

  17. I so disagree with the ‘text’ cult in computers. Text to me is just one way to denote a symbol embedded into a map, a machine, a context. Nobody wants to think in terms of char streams but at least in lexical entities. That’s again something visible in the lisp world, you’re acting on things that happens to be represented with letters, but that’s not what they are.

    By the way, have you seen Subtext ( I may have mentioned it here earlier ), IIRC it’s close to what you’d like, structural editor since inception, names are just labels nothing more. It’s live definition/test/experiment system, you add objects and try instanciations of functions over data on the fly to taylor the algorithm. It also provides orthogonal views for boolean expressions so tweaking a branch of the decision tree ‘refactors’ the whole expression.

    I hope you’ll enjoy http://www.subtextual.org/index.html

    ps: sorry for the long and hard to follow comments

  18. Indifferently designed IDEs are only the beginning. Our machines replicate the internal chatter of the mind. The web itself seems designed to prey on human weakness, to encourage wilfing through the Internet and short-term gratification, and to discourage learning and the development of self-control. If we want our machines to help us reach our potential, we have to quiet their computations. We have to teach our machines to meditate.

    I have made infinitesimal headway: I use a list of ad site domains aliased to localhost. A web server on my machine redirects the default page at localhost to my to-do list on http://rememberthemilk.com. In addition, I use OpenDNS to block distracting sites, and redirect block.opendns.com to localhost, which is then redirected to my to-do list.

    But this doesn’t address tools needed to develop know how. I have a persistent, nagging complaint about course management systems. In a recent New York Times article, spaced review is mentioned as an effective learning technique. But for me, the absence of spaced-repetition algorithms in course management software–Blackboard, Moodle, Sakai–has been a glaring omission. The unsupported need to copy and paste items from a web browser (or some other program or source) into a spaced-repetition plugin for memorization is an opportunity for software developers to incorporate powerful and proven memorization tools in course management systems (or browsers, which could be turned into learning systems), that literally shriek in desperation for their inclusion–if only one were emotionally sensitive to machines and the software that breathes life into them.

  19. Wow! Have you invented something better than written text for conveying complex ideas in enough detail already?
    Why did not you draw your post in photoshop or in AutoCAD?
    By the way, if you hate text so much – try to write your software on Isagraf.

  20. For photographers, designers, etc. it’s assumed they need a budget that may run into the thousands for licensing (and every year or two for upgrades and support of) PhotoShop, AutoCAD, whatever. Developers and their managers are much more hesitant to fork over money (usually out of profit motive, sometimes out of free-software principles) to buy someone *else’s* software and be locked into those tools.

  21. I’m sorry that you lack the patience to use text and in return demand that other programmers of your IDE’s don’t write the code to allowl you to write your shtuff in AutoCAD.

    Text based programming, to some degree will always be around.

    Q_Q

  22. So quit complaining and go write one. Oh, what’s that? It doesn’t work?

    Software is fundamentally more complex than images or sound. Many orders of magnitude more complex. There are reasons, and good ones, for most, if not all, of the issues you mention.

    Your friends may well have no difficulty telling which Luke you are, but your friends are cleverer than your average computer. Computers are basically mechanical idiots and they can’t tell from context which StringHandler class you meant. You can tell, when you are reading the code, which is why when you import a class you don’t have to explicitly qualify it – there’s enough information there to tell the computer which one you mean, and you can figure it out from the context.

    And why do we deal with files? Because I trust files. And, hey, you know what? Other people think so too, because AutoCAD, ProTools, Photoshop, the whole lot all use… files. And why text files? Because I can read a text file, even when I’m working on a computer that doesn’t have a license for your fancy-pants IDE.

    What’s up with import statements? The Java VM needs to know which classes to refer to when its loading the class. That import statement actually creates some extra bits and pieces in your class files, and without it the VM won’t know what to do. That import statement actually carries useful information.

    I guess you could have an IDE that expands function definitions inline… until that function refers to something in the function definition scope. Now, that static local variable in that expanded bit of code there, where is that visible and when will it be overwritten again? Not sure…

    How come you can still have syntax errors, when Finale will fill in missing notes with rests? Because writing code is not as simple as filling in the missing bits with blank spaces. Because a missing note in a piece of music doesn’t mean starting the performance over again, or break the instrument, or kill a third of the orchestra.

    To achieve your shiny dream, you’re going to need a new language that hides ALL of the complexity of making a computer do what you want. And, do you know what? No-one will use it. Or at least even less people than use Haskell. It will be limiting, slow, unable to talk to anything else and, essentially, for all practical purposes, useless.

  23. I’ve been watching people try and create a GUI programming environment that’s unconditionally better than a text editor for 30 years now, and failing, because software is abstracted at the software level itself. The very very best GUI tools are barely comparable in capability to the Version 6 UNIX shell or pre-structured BASIC. Abstractions in software are forever racing ahead of them.

    You might as well ask why mathematicians use mathematical notation and whiteboards instead of software agents that POP out into definitions. When you’re cutting brush, you need a machete… not a lawnmower.

    Once the software you’re extending has gelled to the point where you can package its abstractions up into the kinds of agents you’re talking about, it’s not programming any more, it’s “using an application”.

  24. HEY. Don’t knock MSPaint. I mean really, if you just go to YouTube and search for “MSPaint Mona Lisa”, you’ll see it’s a very versatile and professional program.

    Also, I am being 99% facetious. The video is still pretty cool though.

  25. Tom :…To achieve your shiny dream, you’re going to need a new language that hides ALL of the complexity of making a computer do what you want. And, do you know what? No-one will use it. Or at least even less people than use Haskell. It will be limiting, slow, unable to talk to anything else and, essentially, for all practical purposes, useless.

    For the last 15 yrs or so (on and off) I have developed database applications with Filemaker Pro. I mention this because this is the “shiny dream” and it has alot of benifits but some almost crippling drawbacks as well…. I can design and impliment a full solution much faster than most can code one but… it is limited, assumtions are made about how things should be done within the program, it tends to be slow and does not scale as well as other solutions. It is more than adaqute for some some things and for others I see no way around the problems stated here… sometimes you really need to define something and not rely on someone/something to assume things for you.

  26. Well, one nice things about VS2010 (and probably other IDEs I’m not currently using) is that you can write extensions that plug right in – so you could write an extension to inline the method calls with the replacement done. If I had any time I’d try it, because that seems like a great feature – but I have product to deliver, so it’ll have to wait until retirement.

  27. A few other reasons why your IDE may not be accepted:

    vendor – lock in: Source code in a standardized programming language can be compiled by lots of compilers (or interpreted by interpreters) and edited with any text editor.

    Will your IDE be portable to other systems as easyly as a compiler (which only needs ANSI C file IO)?

    Code – generation: Will it be possible to make programs that generate other programs for your IDE?

    Third party source analysis tools: Can they be plugged into your IDE? Will the represenatation of the program (your IDE’s file format) be stable across IDE versions?

    Will it be as easy as using search&replace, sed, your favorite scripting language or any other text editing tools to do bulk-editing? I don’t think you can avoid the need for this by implementing a perfect data model for your IDE. Because you can’t imagine all the things your users would want to do. They’re programmers after all, so they won’t accept a tool that needs more manual work than necessesary.

  28. What would you think the idea of authors writing by dragging character names into plots using a “Novel Development” tool? Does this even sound plausible to you? But that’s not far from your idea of abandoning text as the representation of programs.

  29. Without wasting words on arguing or offering fragments of a solution, I feel your pain. I hate the endless round of crap kicking my coding has become. Endlessly seeking a comprehensive toolkit that “just works”, so I can work at the speed of thought not wander around fixing trivial shit again and again. Even building plugins to automate it is pointless because of the half assed document models and apis are all at such low levels of abstraction. It’s a massive effort just to hack a simple macro to do anything remotely abstract. Let alone being able to transform a whole view in a single elegant operation.

  30. Well that certainly got everyone spun up. I enjoyed the article and most of the comments. Thanks to all.

  31. I have to admit that my first Editor on a PC was edlin. I graduated to EDIT, PE2, brief, etc. I’m now working almost entirely in Visual Studio 2008/2010 which I do think is the best IDE I’ve worked with so far on the MS platform. That said it is bulky and expensive. My biggest complaint is that Intellisense (sometimes an oxymoron) is not available across all MS prodiucts.

    I’m using Netbeans now for Java and now Scala (the next cool language). I’ve also had to do work with Poweshell and gravitate to IDE’s with autocomplete.

    Many of these IDE’s do have the ability to lookup the reference and display it as a tooltip but I do like the “+” idea.

    Even today I see many use plain text editor without any syntax highlighting.

    Today at work I had to edit and ASPX file quickly in an editor without any syntax highlighting or as VS 2010 does some “Editor Previewing” My biggest fault is usually typos or other simple mistakes. Today it was not closing a quote. It took an hour to figure it out. I did this my copying the code into Visual Studio that highlighted the problem immediately.

    The bottom line is that I am a big fan of “thick” IDE’s.

Comments are closed.