LightTable detailed critique: Concept vs Reality

I disagree, at least when it comes to Clojure.

The size of the functions in the demonstration is about average for Clojure. The author of the critique suggests that the examples are "contrived", but speaking as a Clojure programmer, I didn't get that impression at all.

Hidden state change might cause problems for tracing the values of variables, and I wonder how well Light Table would work for Javascript. However, since Clojure is a functional language, there's very little hidden state to worry about.

Most of the critique seems to be either "This isn't new" or "This wouldn't work in Java". But just because something isn't new doesn't mean it isn't beneficial to do it, or that existing UIs could not be improved. The Light Table demonstration of inline docs seems more responsive and more immediate than the equivalent functionality I've seen in Eclipse.

Secondly, even though Light Table is supposed to be language agnostic, it doesn't really seem designed for languages like Java. The dynamic code traces demonstrated would work very well for Clojure, but I can certainly imagine production Java code being too complected for it to be useful. But that's fine; just because it isn't suited for Java doesn't mean I can't take advantage of it in Clojure.

I am an Eclipse power user myself but alas Eclipse is not an effective option if I need to drop into a remote server and cut some code. (Yes, I use VIM for these occasions.) And let's be perfectly frank: developers who get their start on IDEs are typically (not all, don't be offended) relatively clueless on the command line. IntelliSense gives these what unix commands have long given the developers who got their start on _nix, vim/emacs, and find, grep, awk, sed, etc. [their] way through their workflow.

My personal take on LightTable is purely aesthetic; I think it is gorgeous. Eclipse (and even IDEA) are really too noisy and just feel heavy. Psychological aspect of programming is very important. To wit, IDEs encourage complexity and bloat and fat function/methods. On the other side of the cultural divide, the tools really encourage (but don't force) you to be concise. Naturally, the language being used also has a significant say on what is idiomatic code.

I think it is perfectly fair to say that the LightTable concept may not scale to cover the entire spectrum of developers, but given a matrix of workflow, language, and development environment, it probably hits a sweet spot for a not so insignificant segment of coders out there.

As a longtime Smalltalker and contributor to a Smalltalk development tool, I think it is possible, though the odds are long, based on what the LightTable guy doesn't know.

More importantly, I'm an IDE and editor nut. Most of the start of my career was on Visual Studio, then SlickEdit, and since then I've tried out many IDEs and editors. I now mostly use Vim, while sometimes dropping into SublimeText.

I think Eclipse is an amazing tool, and couldn't imagine programming Java without it.

Eclipse has its roots in Visual Age for Java, which for many years was one of the best Java IDEs, and was originally written in Smalltalk. Smalltalkers often have a long view of progress in development environments, because they've witnessed lots of dumbing down of their ideas, which start out woefully inadequate then end up feature complete but hopelessly bloated.

The author of the article talks about finding functions, but offers as a comparison finding classes. This indicates a bias due to an incomplete understanding of how things work in other languages. In Smalltalk, I'm searching for functions all the time. Many times, I only look for a class because it has a certain function.

This hits on another difference: Java is much, much, much more likely to be used in the real world over Clojure. The set of people who use Clojure are very likely to be in the set of people who write small functions, both because they're more "cutting edge" in terms of TDD, because they're only writing "toy" or "hobby" projects, or because they're just better programmers (e.g. Paul Graham's article on Python programmers tending to be better).

Having said that, please don't be offended - I'm speaking in generalities here. If you specifically have evidence that real world systems written in Clojure still look this tidy, that just makes me want to learn Clojure all the more.

Btw, I completely agree that making an amazing IDE for only one language is still a great goal, even though I would personally find it hard to work with a different IDE for Clojure and for my other code.