It's normal, I think, to get overwhelmed by the sheer amount of parens you need to manage when learning a Lisp. When taken on its own, the syntax really is simple, but introducing another strange thing on top of already unfamiliar concepts doesn't help learning.
Some people will tell you that you will "get used to it" soon enough and that it's just a matter of practice. While there is some truth to these claims, I'm a pragmatist and so I prefer another approach: simply set up a decent environment for working with Lisp before you begin. There are many tools which make reading and writing Lisp code much easier: you need to either configure your editor to enable them or change the editor. There are some Clojure-specific editors out there, you can simply use one of them (my thoughts on them below).
Main things/features useful when working with Lisps:
- syntax highlighting for your Lisp (obviously!)
- automatic indentation (and re-indent) for your Lisp
- ability to highlight matching paren
- ability to jump to matching paren
- configurable syntax coloring and/or rainbow-style coloring of parens
- ability to wrap a text selection with parens
- automatically inserting closing paren
- ability to delete parens in pairs automatically
- par-edit or par-infer style structural editing
- auto-completion for module/function names
- quick access to the docs for a name under cursor
"Go to definition..." is good to have, but you can usually make do with
grepor "Find in files..." editor command
See the screenshots and a video for visual demonstration of what I'm talking about (click on the image to get a bigger version):
Also see here for a very good general introduction to editing Lisp along with explanation of what Parinfer is.
Clojure specific editors
After writing the above I realized that it would be good to give a couple of examples of beginner-friendly editors, which implement the features mentioned above. To my surprise there are some editors which target Clojure, some of them even maintained. Here's a short summary of what I found out:
Nightcode - I only played with it a little but I'm impressed at what it can do. I tried using parinfer some time back and it is much friendlier and easier to use than Paredit. In short: you never need to worry about parens when using Nightcode. Place a cursor where you need it and start typing: the parens will magically appear. It worked out of the box for me on Mac, however it refused to run on Fedora.
Clooj - inactive since 2012, has nearly none of the useful features, looks ugly and is slow. Forget it.
LightTable - supports many things mentioned above as plugins, but they tend to be disabled by default and enabling them is not as easy as it should be. The plugin-based architecture makes it interesting for polyglot projects, but it needs some configuration to get started and Nightcode needs none.
Cursive - a Clojure plugin for IntelliJ IDEA from JetBrains. I don't have any of their IDEs installed and so I didn't try it. Its feature list looks decent, though, so if you like IntelliJ this may be the best option for you.
Emacs and CIDER - that's what I use. I'd recommend you to only try this route if you already know some Emacs, otherwise it's going to be frustrating for a good while until you internalize all the strange names and such. CIDER itself is great, though, and integgrates with Leiningen, offers inline code evaluation, auto-completion, connecting to a running REPL and so on.
In short: give Nightcode a try if you can, otherwise use a Lisp/Clojure plugins for your current editor, like Sublime, IntelliJ or Eclipse. Come over to Emacs side once you get bored with those.
- A full "IntelliSense" - context aware auto-completion - is always nice to have, but you can live without it. For a while. ↵
- I stick with Paredit because I already got used to it and am efficient enough with it; I'd go for parienfer had I started learning about Lisps now. ↵