- Frederick Giasson’s Weblog - http://fgiasson.com/blog -
My Optimal GNU Emacs Settings for Developing Clojure (so far)
Posted By Frederick Giasson On May 22, 2014 @ 1:59 pm In Clojure,Semantic Web | 10 Comments
In the coming months, I will start to publish a series of blog posts that will explain how RDF  data can be serialized in Clojure  code and more importantly what are the benefits of doing this. At Structured Dynamics , we started to invest resources into this research project and we believe that it will become a game changer regarding how people will consume, use and produce RDF data.
But I want to take a humble first step into this journey just by explaining how I ended up configuring Emacs  for working with Clojure. I want to take the time to do this since this is a trials and errors process, and that it may be somewhat time-consuming for the new comers.
Before discussing how I configured Emacs, I want to introduce you to the new IDE: Light Table . This new IDE is mean to be the next generation of code editor. If you are new to Clojure, and more particularly if you never used Emacs before, I would strongly suggest you to start with this code editor. It is not only simple to use, but all the packages you will require to work with Clojure are already built-in.
As you may know, GNU Emacs has been developed using Emacs Lisp (a Lisp dialect). This means that it can be extended by installing and enabling packages, all configurations options and behaviors can be changes, and even while it is running! Light Table is no different. It has been developed in ClosureScript, and it can be extended the same way. To me, the two real innovations with Light Table are:
instarepl is a way to evaluate the value of anything, while you are coding, directly inline in your code. This is really powerful and handy when prototyping and testing code. Every time you type some code, it get evaluated in the
REPL , and displayed inline in the code editor.
watches are like permanent
instarepl that you place within the code. Then every time the value changes, you see the result in the watch section. This is really handy when you have to see the value of some computation while the application, or part of the application, are running. You get a live output of what is being computed, directly into your code.
The only drawback I have with LightTable is that there is no legacy
REPL available (yet?). This means that if you want to evaluate something unrelated to your code, you have to write the code directly into the editor and then evaluate it with the
instarepl. Another issue regarding some use cases is that the evaluation of the code can become confusing like when you define a Jetty server in your code. Since everything get evaluated automatically (if the live mode is enabled) then it can start the server without you knowing it. Then to stop it, you have to write a line of code into your code and then to evaluate it to stop the server.
Because of the nature of my work, I am a heavy user of multiple monitors (daily working with six monitors). This means that properly handling multiple monitors is essential to my productivity. That is another issue I have with LightTable: you can create new windows that you can move to other monitors, but these windows are unconnected: they are different instances of LightTable.
Simple is beautiful, and it is why I really do like LightTable and why I think it is what beginners should use to start working with Clojure. However, it is not yet perfect for what I have to do. That is why I choose to use GNU Emacs for my daily work.
I don’t think that GNU Emacs needs any kind of introduction. It is heavy, it is unnatural, it takes time to get used to, the learning curve is steep, but… hell it is powerful for working with Lisp dialects like Clojure!
The problem with Emacs is not just to learn the endless list of key bindings (even if you can go a long way with the core ones), but also to configure it for your taste. Since everything can be configured, and that there exists hundred of all kind of packages, it takes time to configures all the options you want, and all the modules you require. This is the main reason I wrote this blog post: to share my (currently) best set of configuration options and packages for using Emacs for developing with Clojure.
I am personally developing on Windows 8, but these steps should be platform agnostic. You only have to download and install the latest GNU Emacs 24 version .
The first thing you have to do is to locate you
.emacs file. All the configurations I am defining in this blog post goes into that file.
Once Emacs is installed, the first thing you have to do is to install all the packages that are required to develop in Clojure or that will make your life easier for handling the code. The packages that you have to install are:
Before installing them, we have to tell Emacs to use the Marmelade  packages repository where all these packages are hosted and ready to the installed into your Emacs instance. At the top of your .emacs file, put:
Important note: only use the MELPA repository if you want to install non-stable modules such as the Noctulix theme. If you are not expecting using it, then I would strongly suggest you to remove it and only to keep the MELPA-Stable repository in that list.
If you are editing your
.emacs file directly into Emacs, and you can re-evaluate the settings file using Emacs, then by moving cursor at each top-level expression end (after closing parenthesis) and press
C-x C-e. However, it may be faster just to close and restart Emacs to take the new settings into account. You can use any of these methods for the following set of settings changes.
Before changing any more settings, we will first install all the required packages using the following sequence of commands:
M-x package-install [RET] cider [RET]
M-x package-install [RET] clojure-mode [RET]
M-x package-install [RET] clojure-test-mode[RET]
M-x package-install [RET] auto-complete[RET]
M-x package-install [RET] ac-nrepl [RET]
M-x package-install [RET] paredit[RET]
M-x package-install [RET] popup [RET]
M-x package-install [RET] rainbow-delimiters [RET]
M-x package-install [RET] rainbow-mode [RET]
Additionally, you could have used
M-x package-list-packages, then move your cursor in the buffer to the packages’ line. Then press
i (for install) and once all the packages are selected, you could have press
x (execute) to install all the packages all at once.
In the list of commands above,
M-x is the “meta-key” normally bound to the left
Alt key on your keyboard. So,
M-x usually means
Now that all the packages are installed, let’s take a look at how we should configure them.
If you are using an English/US keyboard, you can skip this section. Since I use a French Canadian layout (On an English/US Das Keyboard !), I had multiple issues to have my keys working since all the binding changed in Emacs. To solve this problem, I simply had to define that language configuration option. Then I had to start using the right
Alt key of my keyboard to write my brackets, curly brackets, etc:
Since I am growing older (and that I have much screen estates with six monitors), I need bigger fonts. I like coding using
Courier New, so I just configured it to use the font size 13 instead of the default 10:
The next step is to configure the auto-completion feature everywhere in Emacs: in any buffer, nREPL or in the mini-buffer. Then we want the auto-completion to appear in a contextual menu where the
docstrings (documentation) of the functions will be displayed:
What is really helpful is to be able to pop the documentation for any symbol at any time just by pressing a series of keys. What need to be done is to configure
ac-nrepl to bind this behavior to the
C-c C-d sequence of keys:
Par Edit  is the package that will help you out automatically formatting you Clojure code. It will balance the parenthesis, automatically indenting your
Another handy feature is to enable, by default, the show-parent-mode configuration option. That way, every time the cursor points to a parenthesis, the parent parenthesis will be highlighted into the user interface. This is an essential most-have with Par Edit:
Another essential package to have to help you out maintaining these parenthesis. The rainbow delimiters will change the color of the parenthesis depending on how “deep” they are into the structure. Another essential visual cue:
Did I say that I like LightTable? In fact, I really to like their dark theme. It is the best I saw so far. I never used any in my life since I never liked any of them. But that one is really neat, particularly to help visualizing Clojure code. That is why I really wanted to get a LightTable theme for Emacs. It exists and it is called Noctilux  and works exactly the same way with the same colors.
If you want to install it, you can get it directly from the packages archives. Type
M-x package-list-packages then search and install
Then enable it by adding this setting:
Then I wanted to bind some behaviors to the
F-keys. What I wanted is to be able to run Cider, to be able to start and stop Par Edit and to switch frames (windows within monitors) in a single click. I also added a shortkey for starting
speedbar  for the current buffer, it is an essential for managing project files. What I did is to bind these behaviors to these keys:
There is one thing that I really didn’t like, and it was the default behavior of the scrolling of Emacs on Windows. After some searching, I found the following configurations that I could fix to have a smoother scrolling behavior on Windows :
Here is the full configuration file that I am using:
Now that we have the proper development environment in place, the next blog posts will really get into the heart of the matter: what are the different ways to serialize RDF data in Clojure code, how the generated code can be used, what are the benefits, how it changes the way that data (RDF in this case, but really any data) can be produced and consumed.
We think that there are profound implications into how we, as Semantic Web specialists, will work with data instances and ontologies in the future. The initial project that will embed and benefit from these new principles and techniques will be the next version of the UMBEL  ontology.
Final note: there are an endless list of features and packages for Emacs. Obviously, I don’t know all of them, so if you are aware of any settings or packages that I missed here and that could improve this setup, please share them in the comments.
Article printed from Frederick Giasson’s Weblog: http://fgiasson.com/blog
URL to article: http://fgiasson.com/blog/index.php/2014/05/22/my-optimal-gnu-emacs-settings-for-developing-clojure-so-far/
URLs in this post:
 RDF: http://en.wikipedia.org/wiki/Resource_Description_Framework
 Clojure: http://clojure.org/
 Structured Dynamics: http://structureddynamics.com
 Emacs: http://www.gnu.org/software/emacs/
 Light Table: http://www.lighttable.com/
 GNU Emacs 24 version: http://www.gnu.org/software/emacs/#Obtaining
 cider: https://github.com/clojure-emacs/cider
 Slime: http://common-lisp.net/project/slime/
 Marmelade: http://marmalade-repo.org/packages/
 Das Keyboard: http://www.daskeyboard.com/
 nREPL: https://github.com/clojure/tools.nrepl
 Par Edit: http://www.emacswiki.org/emacs/ParEdit
 Noctilux: https://github.com/stafu/noctilux-theme
 speedbar: http://www.gnu.org/software/emacs/manual/html_node/speedbar/
 smoother scrolling behavior on Windows: http://www.emacswiki.org/emacs/SmoothScrolling
 UMBEL: http://umbel.org