A new Light Table experience

Now that we have an experience we plan to stick with more documentation and getting started content will be coming in the next few days. :)

EDIT: I didn't think about SVN, we do filter out Git, but this should just be customizable. Added an issue for it [1].

[1]: https://github.com/Kodowa/Light-Table-Playground/issues/266

http://www.kickstarter.com/projects/306316578/light-table

"What languages will it support?

The first two languages it will support are Javascript and Clojure, but the application will be written in such a way that adding new languages can happen through plugins."

To the creator: I love the idea and got enthusiastic after watching the video. Keep up with the hard work! This is a huge undertaking.

Edit* OK, so Ctrl+Space enters the command window. From there you can type "Key" and press enter to view the key bindings. I'm not sure why I had to go three layers deep into a google groups conversation to get that though.

Why not spending a bit of time releasing a simple tutorial, showcasing the differences with normal editors ?

Right now it's really too "metaphysic".

At the very least you should record screencasts of you using LT to build LT with you talking people through what you are doing.

I really want to give this a shot, but it needs to be easy to get started.

Besides your feature and bug backlog, I would map out the user journey (i.e. create an experience map) for LT to discover all the pain and frustration points people may have with using LT.

Support for compiled languages would be nice, although I realise this is difficult.

I'm going to have to join the people who simply don't understand how to use this. It doesn't help that it seems heavily biased towards Clojure and I have no interesting Clojure codebases to play around with.

We use tabs as a simple way of wrapping up a context. In the future they will include all sorts of neat things - and they aren't limited in any way. If we want, we can drop an infinite canvas into one, or a codex (a document made of many parts of different files). So yes, right now we wanted something beautiful and efficient to use while live coding, but as I said in my bit about 0.4.0, the really interesting semantic-oriented stuff (functions and the like) is what's next!

Not sure about the ctrl+shift+enter not working, I'll see if I can come up with a repro. Keys are delimited with -, so Ctrl-Shift-Enter

For (doc ..) take a look at the bottom console, click the little arrow which should be blue when there's new content in there. All prints go to that console.

Thanks for the report! :)

[1]: https://github.com/Kodowa/Light-Table-Playground/issues/281

    .*?(/).*?

If you don't want to treat slashes specially and want to allow "ab" to match "aqqqb" then I don't think you can do it without creating a giant regex. You can go for a modified longest common subsequence algorithm.

Edit: here's how you can do it:

    // gives one point for each letter matched
    // plus an extra point if the next letter is also a match
    let rec scorematch = function
        | true::true::r -> 2 + scorematch (true::r)
        | true::r -> 1 + scorematch r
        | false::r -> scorematch r
        | [] -> 0

    // find the match with best score
    let rec search xs ys =
        match (xs,ys) with
        | (x::xr, y::yr) -> 
            let matches = [false::search xr ys; false::search xs yr]
            let matches = if x=y then (true::search xr yr)::matches else matches
            matches |> List.maxBy scorematch
        | _,ys -> List.map (fun _ -> false) ys

    let underline xs ys = search (List.ofSeq xs) (List.ofSeq ys) 
                          |> List.map (fun b -> if b then "-" else " ") 
                          |> String.Concat

    for x in ["foobarbaz"; "foobaXrbaz"; "foobXaXrbaz"; "foobXaXrbazr"] do
        Console.WriteLine x
        Console.WriteLine (underline "bar" x)

    foobarbaz
       ---   

    foobaXrbaz
       -- -   

    foobXaXrbaz
       - - -   

    foobXaXrbazr
            -- -

Oh boy this one we're going to hear for a long time ain't we!?

   (ns foo.bar)

Unfortunately, even just (defn id [x] x) gets me "java.lang.RuntimeException: Unable to resolve symbol: defn".

Agreed. I closed the tab as soon as I saw that.

I don't think he ever actually says it is. Also, "... if your preference is for something else, you have complete freedom when writing your own skin."

But yeah, all the "vim" layers around are basically just the bindings, in normal and insert mode which just half of vim. If we can't change buffers with :b, :A or anything, it's just painful as a vim user. Same goes for what you listed.

I have great respect for the guys at code mirror, it's just that I view it as just a quick hack to add vim bindings that a real vim like solution. If LightTable advertises about being vim friendly, there should be an implementation that keeps the vim workflow, not just small bindings.

As a vim user, I'll just skip the "vim" mode if it's done like that (and sadly I'll stick to Vim even if I really crave for a modern "vim" with a decent scripting language).

Is there any plan to address that in the future ?

[1]: http://codemirror.net/

[1]: https://github.com/Kodowa/Light-Table-Playground/issues

Could you explain that?

<Error> <Code>AccessDenied</Code> <Message>Access Denied</Message> ...

Update: OK, it works now.