
Out in the Open: These Hackers Want to Give You Coding Superpowers - taigeair
http://www.wired.com/wiredenterprise/2014/01/light-table/
======
doktrin
Sorry for being "that guy" \- but this article reads like a sensationalist
press release, without actually releasing any (new) press.

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

------
forthiscomment
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?

~~~
judk
This one has pretty colors and Silicon Valley investors.

~~~
doktrin
I empathize with this sentiment.

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

------
pedalpete
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?

~~~
ijk
Did you start an Instarepl? That's where you get the most obvious realtime
feedback.

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

~~~
codyb
Agreed.

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.

------
pacala
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](http://en.wikipedia.org/wiki/Blind_men_and_an_elephant).

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

[0] [http://vimeo.com/36579366](http://vimeo.com/36579366)

~~~
pacala
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?".

------
vezzy-fnord
Light Table is a nifty concept, but it's hardly anything revolutionary like
this article portrays it.

Especially this:

 _The problem with coding, he says, is that you can’t see the results of your
work until after you’re done._

Which basically describes a REPL (although LT features a real-time one, still
not a new idea by any means).

------
300bps
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](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:

[http://www.lighttable.com/](http://www.lighttable.com/)

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

------
myzerox
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!

------
david_otoole
Light Table is bigger than Jesus now.

------
lectrick
The article is badly written. For example,

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

