Welcome to the world of Wired articles. They seem to have a formula of taking open source projects which are interesting in their own right and sensationalizing and overblowing them to ridiculous proportions.
I'm just not getting how this is all that different from something like Eclipse, which compiles code while you're writing it, displays error messages in real time, and allows you to gain a sense of what the code is doing (which method is called) by mousing over methods. Is this a way to make life that much easier or is it the same basic idea?
It's becoming increasingly difficult to contain my eye-rolling whenever yet another SV company announces their plans, intent or manifest destiny to "change the world".
> This one has pretty colors and Silicon Valley investors.
No This one places the idea at the center of the IDE.
The implementation is the concept, and the user interface is the program.
I'd like to see the eclipse feature that was mentioned, but I don't really like the baggage that comes with eclipse. Maybe I won't like baggage that comes with this, but that doesn't change the fact that this project really interesting.
Is it just me, or is LightTable still pretty far from their original promise?
I downloaded the app a few weeks ago, and I never saw anything that gave me realtime feedback on my coding. I admit, I was just playing around with putting in the odd function and variable, but it didn't give me anything submlime text doesn't currently.
As far as the spending ' hours or days working on code before they can make sure it actually works', isn't this solved with TDD?
I loved how it displayed code in functions in separate tiles, instead of all concatenated together in a long file. And it shows the code for the other functions being called, in their own tiles.
The video in the linked article is a good short explanation of how the tool works. You can skip the hype in the article.
I think this concept could represent a significant advance in IDEs. I don't care if it's a new idea or not, it's a gorgeous implementation of the concept.
Following the flow of information is what I do all day every day at my new position. If I could have something like this which would allow me to quickly watch how information was flowing from one end of the spectrum to the other without having to follow the method definitions that'd be great.
I wonder how well it will work with complex multilingual web applications?
Either way, very cool. I hope I keep hearing about it. It looks really great.
The amount of negativity in this thread is amazing. I've watched the video and I'm positively impressed. The demo is building the insight why is my code / unit test computing a certain value with instant feedback and full information of the whole call chain. It's far from perfect, but it's miles better than writing a unit test, having it fail, scratching your head, adding some log statements / breakpoints, re-running the code, doing a little tweak, oops, still broken, lather, rinse, repeat. REPL is poking at the problem through a tiny keyhole and Light Table is opening the door and shining the light on the full behavior of the code. No more playing http://en.wikipedia.org/wiki/Blind_men_and_an_elephant.
I agree. It's impressive to me the people who are claiming that something like unit testing can compare to these kinds of tools, without seeing the general direction these tools are headed in. Unit tests are helpful, no doubt. But compare the following:
- Spend several minutes writing a small test suite for the functionality you're writing. Write that functionality until you think it's correct. Compile, run. See a "Pass!" or "Fail! (reasons: ...)" in your console or IDE, fix it until it's working. Feedback loop is measured in minutes, seconds at best.
Vs.:
- Write the functionality. As you're writing, you see the data flow through your program in real-time, immediately identifying bugs. Any unit tests you may have are _even more useful_ because you can inspect your program at any level, without having to debug or step through your program. No need to re-compile and re-run, no need to even Alt-Tab. Feedback loop is measured in milliseconds.
Light table isn't quite there yet, but it's a strong step in the right direction. Unit tests help, but they don't obviate the need for better tools.
To give a bit of context on the direction these tools are trying to move in, Light Table was heavily inspired by the work of Bret Victor, who bases his work on the idea that, quote, "Creators need immediate feedback to what they're creating." If you haven't seen his _Inventing on Principle_ talk [0], you should. It's one of the most eye-opening talks on software and design I've ever seen.
Precisely. Software it's all about shortening the length of the feedback cycle. Chorus: "How is email / web / google different than pigeons / library / index of an encyclopedia book?".
I can't speak for anyone else, but this article didn't add anything that hasn't already been over-hashed on HN already. LightTable has been on and off the front page fairly consistently for the last year, if not longer.
All this article did was make a series of sensationalist (borderline absurd) claims, allude to some new feature or product, and linked to a LT demo video (the content of which is also not new, afaik).
Thus, my personal negativity is not so much a reaction to Light Table itself - but rather the shockingly low journalistic standards of Wired.
FWIW :
My personal experience with Light Table wasn't particularly memorable. I've played around with it on at least a few occasions, but have never really found a true place for it in my workflow (for more than one particular reason - be it developing over layers of virtualization, clunky customization, bugs, etc.).
I'm giving it another shot now, because I can't resist shiny new toys.
I largely agree with you... but then I wonder "how does this deal with recursion, or even repetition", and it turns out it doesn't: it could, I see how it could and it even seems obvious how it could, but because it seems to be trapped in the paradigm of a text editor it simply doesn't handle these cases well, which means that for anything other than simple code you lose this superpower: even at the end of the demo, you see the usage of map means the list-item rendering kept getting its values overwritten by later calls. Frankly, I think this tool is trying to poorly emulate a REPL combined with a debugger in the context of a text editor: you need to see the state of not just the first or last list-item call, but all of the list-item calls. This is then probably why people are somewhat unexcited: while more work, adding a log statement to list-item and getting a trace of the full dynamic execution is actually more valuable and provides better introspection than adding a call to the function in the source code on the left (which is frankly unnatural in the text editor context anyway) and then seeing values displayed inline with the static code on the right. So, maybe they will change their direction in a later release, but this just isn't doing it for me yet.
I am pretty sure I've heard of Light Table here a few times. It's hard to be sure though since Microsoft's LightSwitch (see http://msdn.microsoft.com/en-us/vstudio/ff796201.aspx) which is almost identically named and has almost the identical purpose. That is, making programming easier for everyone including non-programmers.
I was about to forward this to a friend of mine who has several ideas for web startups but lacks all technical skills and is therefore waiting for the time "any day now" that non-programmers will be able to generate programs as fast, cheap and maintainable as programmers. But then I saw the website and realized he would have no idea what the heck it is from their elevator pitch:
Light Table is a new interactive IDE that lets you modify running programs and embed anything from websites to games. It provides the real time feedback we need to not only answer questions about our code, but to understand how our programs really work
That has to be about the least useful description of what it does I can think of.
Yes! Hope guys like Chris & Rob at LT (and/or Bret Victor) will succeed in reinventing programming - making it more tangible and visual. Programming doesn't need to be that tedious!
> The problem with coding, he says, is that you can’t see the results of your work until after you’re done. In that sense, programming is unlike almost every other craft. “When a chef adds an ingredient, he can smell it, he can taste it,” Granger says. “When an artist makes a stroke on a canvas, he can see it. But programming isn’t that way.”
The rest of us would say we just run our unit tests in a couple of seconds and call it a day. At least, if you didn't watch the video.
The video shows a potentially useful tool (on Clojure no less). It's more about watching the propagation of values through code, than it is about "feedback" per se.
