What do you guys think of Light Table?



  • Light Table

    Frankly, looking at the video and reading the description, I don't really see anything he's doing anything that Visual Studio doesn't already do.



  • @blakeyrat said:

    Light Table

    Frankly, looking at the video and reading the description, I don't really see anything he's doing anything that Visual Studio doesn't already do.

    Everyone want to build the next best ide. Personally I think this person is having time on his hands. If you are single, no kid and lot of time on hands, you should get immersion in this project of LIght Table as quickly as you can. I write code to make money to watch movie. So I don't have time. My priority is to watch every single movie that is released in cinema world. That goal may or may not come to fruition, but I will try. This person's goal is to make Light Table. Hope that also comes to fruition.

    Gangs of Wasseypur - I and II <-- Latest recommended movie by Nagesh. Everyone should enjoy.




  • I can't compare it with recent versions of VS, but it seems like there are a few nice evolutionary advances and some bigger leaps. I suspect we'd all agree that more powerful searching is good in any context. Breaking the unit of editing down to the function level seems like it could be useful, though again, that doesn't seem very revolutionary.

    The "new debugging paradigm" strikes me as a neat thing, but possibly a solution in search of a problem. As long as you're working on relatively simple stuff, I can see it being useful, but I have doubts about how well it scales to larger debugging problems with more functions, more data, recursion, etc. I'm not aware of anything else (and VS certainly didn't do this last time I used it) that debugged like this. Maybe it's not too much different than getting a tooltip with the variable value, at which point, I guess it's not much different, but it seems like the persistence of the displayed values might make a significant difference.

    What I find odd is that the video shows python and lisp, but his web page says that it's going to support Javascript (ok, a good javascript IDE sounds interesting and in demand) and Clojure (WTF?) first. He talks about future plug-ins, and I think the difficulty to add other languages will be key to its ultimate success.

    Also, quoted for irony, without further comment, "I'm a VIM guy myself..."



  • @boomzilla said:

    The "new debugging paradigm" strikes me as a neat thing, but possibly a solution in search of a problem.

    VS had/has that. I believe it was called "edit and continue" mode, where you can edit the code and it would continue execution as if your edit was always there. Problem is, it doesn't play nice with CPU features like DEP-- so it's basically impossible to do in compiled languages without putting an emulator in the IDE. And if it's running in an emulator, suddenly you're not debugging the actual program. (I think technically the feature still exists in VS, but since it only works in a couple languages and only on 32-bit CPUs, they don't talk about it.)

    As long as he sticks to interpreted languages, I guess he can make it work.



  • @boomzilla said:

    Also, quoted for irony, without further comment, "I'm a VIM guy myself..."
     

    Oh, that means the UI will be unlearnable.



  • @blakeyrat said:

    @boomzilla said:
    The "new debugging paradigm" strikes me as a neat thing, but possibly a solution in search of a problem.

    VS had/has that. I believe it was called "edit and continue" mode, where you can edit the code and it would continue execution as if your edit was always there. Problem is, it doesn't play nice with CPU features like DEP-- so it's basically impossible to do in compiled languages without putting an emulator in the IDE. And if it's running in an emulator, suddenly you're not debugging the actual program. (I think technically the feature still exists in VS, but since it only works in a couple languages and only on 32-bit CPUs, they don't talk about it.)

    Hmm...I guess I was focusing more on the way it inserted the values into the code in the display. I assumed that it was simply rerunning the snippets from the beginning, not doing any sort of hot code replacement. I do this with Java / Eclipse all the time. It's certainly a handy thing to do. You can't do this in .net languages (or only on 32-bits)?

    @blakeyrat said:

    As long as he sticks to interpreted languages, I guess he can make it work.

    I think the DEP issue could be worked around. The harder thing is probably getting the bits from the compiler that need to change and deploying those correctly. In an interpreted or JIT'd language it should be a lot simpler than a true compiled-to-native-code language. I suppose that also depends on the language and the debugger, and how the IDE integrates it all.



  • @boomzilla said:

    Hmm...I guess I was focusing more on the way it inserted the values into the code in the display.

    Well any decent debugger will already do that for you.

    @boomzilla said:

    I assumed that it was simply rerunning the snippets from the beginning, not doing any sort of hot code replacement. I do this with Java / Eclipse all the time. It's certainly a handy thing to do. You can't do this in .net languages (or only on 32-bits)?

    Depends on what the "this" you're referring to is. If you mean "editing the code, then hitting 'restart program' in the toolbar" then yes, VS can already do this. If you mean "run the program, then edit line 49, then resume to see what effect your change had" then VS can only do that in the environments that support "edit and continue".

    Although it occurs to me that you could do a mini-"edit and continue" at the function level without too much difficulty. Doing it program-wide is where you'd hit problems.

    @boomzilla said:

    I think the DEP issue could be worked around.

    Not in a decent OS with real security. Unless you go the emulator route I already mentioned.

    @boomzilla said:

    In an interpreted or JIT'd language it should be a lot simpler than a true compiled-to-native-code language.

    Yeah I already said-- oh yeah you're Boomzilla. Carry on.



  • @blakeyrat said:

    @boomzilla said:
    Hmm...I guess I was focusing more on the way it inserted the values into the code in the display.

    Well any decent debugger will already do that for you.

    Really? Which ones? I'm not disagreeing with you, but I've never seen it outside of his demo. I tried some google searches to look at debugging screen shots and couldn't find any (hardly conclusive, of course). I've only ever seen the values displayed in a separate area or as tool tips. Or maybe there are no decent debuggers.

    @blakeyrat said:

    @boomzilla said:
    I think the DEP issue could be worked around.

    Not in a decent OS with real security. Unless you go the emulator route I already mentioned.

    Ah, so you weren't talking about Windows, then. Though I'm curious as to what you consider "real security" to mean here. But maybe something that includes this sort of technique is included in what you considered to be emulated. Either way, MS appears to have figured it out (again, maybe the way it does it fits well enough inside your "emulated" vagueness).

    @blakeyrat said:

    @boomzilla said:
    In an interpreted or JIT'd language it should be a lot simpler than a true compiled-to-native-code language.

    Yeah I already said-- oh yeah you're Boomzilla. Carry on.

    What, did you have too many civilized posts in a row? Had to throw something in there? I guess we're not allowed to agree with you now? Though really, my statement was a bit different than yours, or at least more detailed.



  • As long as:

    1. It has enough intellisense to show me the methods when I ask for them, not automatically, and loads it in a background thread that has lower priority than the user-interface one so doesn't interfere with what I type.

    2. It doesn't type stuff for me other than helping me with indenting or move anything I type other than a closing brace to be vertically under the opening one.

     



  • InstaREPL is not something Visual Studio already does. And it's pretty awesome. I've been using Light Table for a few weeks- it needs better lein integration, it's still buggy as hell, but it's one of the nicer IDEs I've worked with. Cutting out the visual cruft of menu bars and toolbars is alone worth the price of admission.



  • @Remy Porter said:

    InstaREPL is not something Visual Studio already does.

    Wanna bother explaining what the holy shit that is?



  • @Remy Porter said:

    InstaREPL is not something Visual Studio already does. And it's pretty awesome. I've been using Light Table for a few weeks- it needs better lein integration, it's still buggy as hell, but it's one of the nicer IDEs I've worked with. Cutting out the visual cruft of menu bars and toolbars is alone worth the price of admission.

    No Cornify.js in your post?

    @blakeyrat said:

    Wanna bother explaining what the holy shit that is?

    I think he means instant-replace. Whatever that means. I hope it's not Xcode's "I'm going to instant-replace what you type with the correct version if you typo so when you look at it you see the right version and don't know you originally typoed, but when you close the line I'm going to un-instant-replace back to the wrong version and now you're code's all messed up" type of instant-replace.



  • Anything that replaces what I type with what it wanted me to type is a WTF.

     



  • @Cbuttius said:

    Anything that replaces what I type with what it wanted me to type is a WTF FTFY.

    FTFY



  • Maybe IABT here, but REPL is a Read-Eval-Print Loop.

    In languages like Lisp / Scheme, you don't really have a "standalone" program. You have the language runtime environment, and functions defined in it. The interpreter/compiler is always available.

    This "just mark some bit of code and you can run it, ALTERING the program state" stuff in this Light Table would work quite like access to the "interpreter commandline", aka REPL, in a Lisp-style environment.



    See also: http://flownet.com/gat/jpl-lisp.html:

    The Remote Agent software, running on a custom port of Harlequin Common Lisp, flew aboard Deep Space 1 (DS1), the first mission of NASA's New Millennium program. Remote Agent controlled DS1 for two days in May of 1999. During that time we were able to debug and fix a race condition that had not shown up during ground testing. (Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem. The story of the Remote Agent bug is an interesting one in and of itself.)


    And for reference, I find the IDE from the OP to be quite bizarre.


  • @Nagesh said:

    My priority is to watch every single movie that is released in cinema world.
    That goal may or may not come to fruition, but I will try.
     

    So.. how's that going?


Log in to reply
 

Looks like your connection to What the Daily WTF? was lost, please wait while we try to reconnect.