Lighttable's datastructure based configuration makes it so nice.

Thanks Chris & Co. keep up the awesome!

How does autocompletion work for Lisp-like languages? I'm wondering if the verb-subject ordering makes it more difficult to build effective autocompletion.

In languages with a syntax like C, code phrases benefiting from autocompletion focus on a particular thing in subject-verb-object order:

  obj.method(param);

  obj.<cursor>

When writing code, I usually know what object I'm working on (autocompleting the variable name is useful but not crucial, since it's usually on preceding lines). What I want to know, and the area in which autocompletion helps me most, is finding out what methods are relevant to that specific object (e.g. defined by the object).

When I'm writing quick prototype code, I use an approach that's almost like single static assignment:

  A a = new A();
  B b = a.foo();
  C c = b.bar();

How do you effectively autocomplete in a Lisp language?

  (<cursor>

  (<cursor> obj ...)

I have not used autocompletion in Lisp-based languages. How do IDEs or REPLs solve this problem? It seems like a similar problem will affect pure-style functional programming languages like Haskell. Static typing is not the criterion, since Python has effective REPL autocompletion.

Does the lack of a natural opportunity to present relevant autocompletion information inhibit the development of advanced editors for these languages?

  (let [entry (.getEntry my-map)
        key   (.getK|

Completion for functions etc is obviously easier although in the case of protocols the problem is similar - you'll get all the protocol methods suggested since they're just fancy functions, but you won't get proper context-sensitive completion unless you've put the object implementing the protocol after the symbol you're completing - the most you can hope for is some sort of error message later that what you've entered doesn't look consistent.

Edit: one thing I forgot to mention is that in the completion list for methods we show the full signature as well as the list of all classes that have a method with that signature, which helps a lot in choosing the right method.

    (fo<cursor>

    (foo
    (foo-bar
    (foo-bar-baz

  new <cursor>

You at least need a base to get started.. in lisp, it's not uncommon to have functions defined as (character-move), so (character-<tab>) works well. But even without that, since lisps use functions at its root instead of objects, it makes sense to know the ones you want to use.

If you're new to Lisp, I'd recommend working through Land of Lisp [1], and pg's On Lisp [2] in order. They're both Common Lisp books, but they will introduce you to and expand your mind on (respectively) what's possible with all the power Lisp gives you. Virtually everything you learn in those books will be very nice tools to have in your toolbox as a Clojure dev.

As for the best starting Clojure book, Clojure Programming [3] is excellent. It has great OOP -> FP examples, is fairly extensive and well-written.

[1] http://landoflisp.com [2] http://www.paulgraham.com/onlisptext.html [3] http://www.clojurebook.com

As for Emacs vs Vim, I also use Vim for Clojure development. There's definitely a bias toward Emacs in the community, but that doesn't mean that you have to go with Emacs. In fact, there are now useful plugins/packages to work with Clojure in Vim, Sublime, IntelliJ, Eclipse, as well as Emacs. There's even two editors written in Clojure itself: Clooj (https://github.com/arthuredelstein/clooj) and the afore-linked LightTable.

Or the newer Smartparens: https://github.com/Fuco1/smartparens/wiki

https://github.com/Fuco1/smartparens

I admit that I have not tried kibit yet. However, LightTable/REPL is a great tool for this endeavour. If only clojure could have an error tracking report that would be comparable to the wonderful implementation that can be found with the python IDLE.. but I guess that is too much to ask?

  Traceback (most recent call last):
    File "C:/Users/wuschel/Desktop/error-track.py", line 3,   in <module>
      newstrin = teststrin + 3
  TypeError: cannot concatenate 'str' and 'int' objects

  clojure.lang.Compiler$CompilerException: 
  java.lang.RuntimeException: clojure.lang.Compiler$CompilerException: java.lang.RuntimeException: Unable to resolve symbol: b in this context, compiling:(null:4:1)

Quite often my experience when learning a new language is "Am I doing this right? Or even close to right?"

If kibit can turn your code into idiomatic Clojure then you have a tool for exploring your solutions and how close they look to Clojure as it might be written by a native.

It can also prompt questions "Why do it this way rather than this way?" which could be a good learning opportunity.

I see no harm, only benefit.

Matt

write the best code you can -> run kibit -> spend an hour reading the docs and every blog post you can find about a feature you didn't know about -> repeat

write the best code you can -> run kibit -> show off your awesome code, you're a rockstar!

kibit, so far as I understand it, is a pattern matching solution that can replace one structure with another - more idiomatic - structure. It doesn't add anything and, hence, can't actually solve your problems for you.

here's a short video demoing coding in clojure and other jvm languages:

http://www.youtube.com/watch?v=AqeOS2hqtMg

It get's better with every release, can't wait for the finished product.

ftp://ftp.ai.sri.com/pub/mailing-lists/slug/930331/msg00240.html

I hope that with the recent addition of plugins, LightTable will also be able to provide code inspection à la IntelliJ IDEA, since that's the feature I miss most.

You could try Cursive (http://www.cursiveclojure.com). It's pretty new but it's based on IntelliJ so we get a lot of features for free. We don't have a lot of inspections yet but they're coming soon (including kibit-in-the-editor type inspections).

If you go here (http://www.paulgraham.com/icad.html) and search for the heading 'What Made Lisp Different' it may better explain it

Even in the example given it's reduced the function to a 1 liner, I assumed because it was short enough that it's still legible. Is this trying to tell me my functions are too long?

"Article that is actually interesting" 0 comments

This is awesome. Thanks for sharing.