Light Table Blog

There was a massive amount of excitement around Light Table when it was first demoed. I remember one or more pretty amazing videos. I don't have link(s) on-hand. Project: http://lighttable.com/ HN search: https://hn.algolia.com/?dateRange=all&page=0&prefix=true&q… The top submission there is the place to start.

Haven't followed its development for a long while but Light Table might be what you're looking for: http://lighttable.com/

I was sold on the game video, then the article talks about SICP and LISP - nice! Sounds like great fun and possibly some real innovation here. I hope it's beta for a few years like Minecraft with a strong developer community around it. Reminds me of the lofty goals of http://lighttable.com and EVE http://www.chris-granger.com/2014/10/01/beyond-light-table/

You could install a Clojure environment and try an editor-repl-based tutorial like https://github.com/swannodette/lt-cljs-tutorial I highly recommend Lighttable ( http://www.lighttable.com/ ) as it's a very efficient repl/editor and it will get you up and running in no time (it will install/configure Clojure), but maybe you can find an approaching solution for vim?

I believe LightTable [0] ran with some of the concepts in the video, and I remember one of Chris Granger's videos having an almost identical bit about mapping time over space in a ball/block jumping game and very similar themes. Either way, it's definitely worth checking out. Sorry if I get any of the details wrong, I'm a bit out of step with Clojure. [0] An IDE that supports Clojure and Javascript right now, maybe Python soon? Bit behind on the news: http://www.lighttable.com/

On the other hand, the only usable Intellisense engines or debugger integrations I tried have been built for Emacs and not Vim. This is mostly because, by design, offloading tasks to other processes without blocking the gui-thread is easier to do in Emacs. Also Vim really needs good integration with other languages such as Python, because Vimscript is simply awful. There are problems with Emacs. First, Elisp is kind of an outdated and dirty Lisp dialect. It's kind of neat for extending Emacs, but it's also a poor Lisp dialect by modern standards. I would love an alternative to Emacs built on top of Scheme, with its awesome continuations support, or on top of Clojure. The other problem I'm seeing is that Emacs, as awesome as it may be, is also outdated in what it can do. Smalltalk set a high bar long ago in what IDEs can do and Smalltalk IDEs still haven't been surpassed in terms of experimental development that people tend to do in REPLs nowadays. Having something like a Smalltalk IDE, that uses realtime feedback and visuals to aid in learning, discovery or debugging, with the same philosophy of Emacs (e.g. open-source, totally customizable, turtles all the way down, transcending languages or operating-systems, etc...) would be priceless. This is why I have high hopes for Light Table [1], hopefully it will bear fruits as planned by its author. [1] http://lighttable.com

Warning: recent history lesson ahead. > One core idea embedded in all of Bret's work is that learning happens best when students are able to explore multiple representations of a idea or aspects of an environment simultaneously. The more quickly one representation changes in reaction to the other, the stronger the learning feedback loop, and the more quickly the student builds an accurate mental model of how the thing they're interacting with works. Bret Victor's work brings a lot of visibility to this field, but he was hardly the first one; e.g. [1]. And more to the point, I wasn't the first one either; I believe Christopher Hancock [2] was, but even that is controversial if we begin to talk about visual languages all the way from Sutherland's SketchPad, and Jonathan's work on subtext [6] was a big inspiration to my own. And even I was inspired by some piece of software called SlideShow [4]. > So, WRT your point, it's not about the fact that the documents are interactive, but that they're "reactive." The interactive bits are all related to each other, and when one part changes all the other parts change with it, in real-time. There's something in this immediacy that even the slightest delay destroys. 50 milliseconds is the max, ideally you want < 20 ms (see [1], keep in mind 15 ms is your standard frame delay). > But, well, he's taken it to a whole 'nother level. He's actively exploring this idea on multiple fronts, from reactive documents to reactive programming…

Warning: fanboy gushing ahead. Read at your own risk. Interactive web-based documents are not new, nor are the ideas that Bret Victor is exploring, but a synthesis as sophisticated and holistic as Bret's is. One core idea embedded in all of Bret's work is that learning happens best when students are able to explore multiple representations of a idea or aspects of an environment simultaneously. The more quickly one representation changes in reaction to the other, the stronger the learning feedback loop, and the more quickly the student builds an accurate mental model of how the thing they're interacting with works. So, WRT your point, it's not about the fact that the documents are interactive, but that they're "reactive." The interactive bits are all related to each other, and when one part changes all the other parts change with it, in real-time. There's something in this immediacy that even the slightest delay destroys. That's not a new idea; anyone who has read Mindstorms (1980) or grew up on LOGO has had at least an inkling of it. Lots of research ink as been spilled over this, and many "pedagogical" programming environments (Scratch, etc.) flirt with it. Even Bret would say that, I bet. But, well, he's taken it to a whole 'nother level. He's actively exploring this idea on multiple fronts, from reactive documents to reactive programming environments, and shitting gold all around town. Every time he publishes something it takes months for people to react,…

I know it's not quite the same, and maybe it's just the demo video doing it, but this reminds me of the Light Table IDE http://lighttable.com/

Having never used the authoring tool, can you point me towards something to model it after? I think a Bret Victor, "Inventing on Principal" style editor would be perfect, combined with some sort of scratch like Python IDE where each element is defined in terms of its reactive behaviors with other elements on a timeline. I didn't say easy, I said not too difficult. Order of magnitude difference. :) https://youtu.be/PUv66718DII?t=634 With some http://lighttable.com/

For those like me who have never heard of it, I think OP is referring to this: http://lighttable.com

Light Table, which I presume to be defunct, comes to mind. (http://lighttable.com/#features) But if you're willing to do without the "as you edit" requirement, then what you're left with is a plain old breakpoint debugger. Certainly, there are many IDEs that have those builtin.

For a second I thought this was about Light Table [0] and got excited. What ever did happen to that project? [0] http://lighttable.com/

Sounds like Light Table http://lighttable.com/ Unfortunately it looks like it's no longer under development.

This is beautiful. Well done. >Are there any other text editors that have interpolated variable references? The closest I can think of are Frescobaldi's snippets[1], vim's `!read`, or spreadsheets. Maybe light table [2]? I haven't seen anything exactly like what you've made [1] https://www.frescobaldi.org/uguide#help_snippet_edit_help [2] http://lighttable.com/

I also remember a post on HN about Chris Granger's Lightable IDE? http://lighttable.com/ https://www.chris-granger.com/lighttable/ Although as ground breaking, it does not seemt to have 'taken off' as much as it should?

This is cool, could definitely be useful for working with complex data structures. Does anyone know if there's a Light Table-like (http://lighttable.com/) plugin for VS Code?

http://lighttable.com/ might be interesting for you if you've not seen it before... It's looking at some of those concepts. (I've not used it personally, but heard good things)

I believe this project is now defunct, but the ideas remain http://lighttable.com/

Not to be confused with LightTable[1], an editor with Clojure live coding support. [1] http://lighttable.com/

Like Light Table? In the 80s, it would be unimaginable that you could re-compile and run code with every keystroke, or watch the values of variables updating in real time. The demo (http://lighttable.com/#see) would be inconceivable.

Wish it credited Light Table as inspiration (http://lighttable.com/) :/ Even the term "instarepl" is taken from LT's creator, Chris Granger. Of course LT's inspiration is Smalltalk's IDE.

Eve [1] is one project I know of that has been trying to tackle this very difficult problem. The project is led by Chris Granger, whom you might know from his work on the Light Table IDE [2]. They released a video last year that showcased some iterations of their prototypes and I found them to be very innovative and promising: https://www.youtube.com/watch?v=VZQoAKJPbh8 [1] http://www.witheve.com/ [2] http://lighttable.com/

It is very interesting to see some comparisons you did. You mentioned Oberon[1], which has an explicit reference to Doug Engelbart. Seeing some TempleOS highlights reminds me a lot of those ideas, including LightTable[2]. [1]: http://ignorethecode.net/blog/2009/04/22/oberon/ [2]: http://lighttable.com/

I'm a beginner and Clojure is on my list to try out, so this tutorial comes in handy. However I was looking to use LightTable - is this still a good choice? http://lighttable.com/

The video on the front page of http://lighttable.com was made in April. Most of the changes since then have just been bug fixes so its pretty representative of the current state. Now that we've removed the bottlenecks on outside contributors the pace is picking up again.

Instead of cloning LightTable repo, just go to the main page [1] and download an archive. [1]: http://lighttable.com/

So they copied this idea for the IDE? http://www.lighttable.com

brackets is open source http://brackets.io/ about this, I use brackets, a lot of it does look like brackets maybe with some ideas taken from light table http://www.lighttable.com/ There's a thread on discuss.atom.io about what distinguishes the two http://discuss.atom.io/t/what-distinguishes-atom-io-from-brackets-io/5… I guess I don't feel atom does enough different from brackets that I can justify switching editor at this point, but if anyone has more to add than was found there I'm interested to hear.

I personally think path 1 is absolutely where editors should be going. Upvote from me. NeoVim is a step in the right direction, but not far enough. The future is a more Light Table like environment (http://www.lighttable.com/). But Light Table (as visionary as I think its UI is) is written (and extended, AFAIK) in ClojureScript, a LISP-like language that nobody knows. It it was written and could be extended in JavaScript instead, and configured to the extent that I could write VIM-like modal editor support for it, I might finally be able to give up VIM after 20 years for something better.