I would very much NOT recommend using something like parinfer; IMO if one is learning lisp, one ought not to try to avoid the parentheses, but rather learn the advantages of using them. So instead of parinfer, use paredit and learn the key bindings for moving up/down/formard one sexpr at a time. It's frustrating at first, but after a few days, you will never want to go back to line oriented languages.
Well, first of all let me emphasise again that it's not an either/or proposition, they work together perfectly fine. Personally I use paredit extensively and yes, going back to a language/environment without it feels like having to work with my hands tied behind my back, but I still make use of parinfer as well.
Sometimes just deleting a couple of lines in Vim (IdeaVIM in my case) and knowing that parinfer will take care of the parens feels faster and more comfortable to me than using paredit. YMMV.
And as far as beginners are concerned - for someone coming from an OOP/imperative programming/C-style syntax background, a LISP will seem very foreign and weird for many reasons, the parens being just one of them.
I think having the ability to get your feet wet and start dabbling without an upfront investment is a good thing and the "jumping into the deep end" approach isn't for everyone, especially not for many beginners who at this point have only a very vague idea that a LISP might be for them and are already facing a number of new concepts that they need to get their heads around.
Parinfer requires no investment, Paredit requires some. Not much, but still. And going from one to the other as one feels drawn to explore the language is, I think, a perfectly natural transition, which requires no unlearning or changing of habits whatsoever, and as such it's also a more accessible path to getting into LISP. In my book, that's a good thing.
But here we're beginning to move into a general attitude/philosophy territory that's hard to argue about, so I'd be perfectly comfortable with agreeing to disagree and leaving it at that.
Counterpoint: there is justification in the claim that the possibility of parinfer is one of the advantages of parentheses. So maybe: use parinfer, but don't overlook the other advantages of parentheses.
For me the largest difference is that Clojure carries
over all your dynamic bindings when creating new
threads (via 'future') and in lazy seqs, whereas
Common Lisp (typically) does not. I now understand
why they choose to do it this way, but I wish the documentation was much clearer in this regards.
The CL standard doesn't deal with threads at all, so different implementations do things differently. But typically the user can control what the initial bindings of a thread are through keyword arguments to whatever function spawns threads.
I made a dialect once called VoqLisp in which a thread carried the dynamic bindings visible in the code which spawned it.
This then resembled POSIX environment variables: "FOO=bar command arg" and was handy in a similar way. You could use let to set up a bunch of parameters affecting the thread, and then create it in that body.
