For a while one of the biggest complaints people had about
Projectile was that the
alien indexing wasn’t fast enough (especially on big projects). The
reason for the (relatively) bad performance was pretty simple - even
though Projectile would normally obtain the list of project files
pretty fast (e.g. by using
git ls-files) it always did some
post-processing of the results (e.g. filtering, sorting, etc), which
is a very slow operation in Elisp on a big dataset.
Today I’ve added a new indexing
that simply dispenses with all of the post-processing and gives you
the raw power you always craved for. It’s called
yeah - naming is hard!) and it’s going to be the default indexing
method going forward (starting with Projectile 1.1 which should be released pretty soon).
You can read a bit more about it in Projectile’s
If you find yourself missing Projectile’s old behaviour just add the following to your config:
(setq projectile-indexing-method 'alien)
The old tried and true
alien method is still around, it’s just no longer the default.
P.S. I encourage all of you to help out with some of the open tickets
marked with “Help Wanted” or “Good First Issue” here. I’m trying to
clean-up shop after a long period of stagnation and I can certainly
use some help!
P.P.S. The recent 1.0 release was just a precursor to some bigger changes I
had planned to do for quite a while. Stay tuned for more updates!
Update Shortly after writing this post I’ve reconsidered the
turbo-alien naming and I opted to rename the old
alien method to
hybrid (as it was truly a hybrid of
and to change the name of
turbo-alien to simply
alien. Naming is
Back in 2013 I wrote about my favourite productivity boost in Emacs,
namely remapping Return to
which in combination with the classic remapping of
Control makes it really easy to get a grip on Emacs’s obsession with
the Control key.
In the original article I suggested to OS X (now macOS) users the tool
KeyRemap4MacBook, which was eventually renamed to
Karabiner. Unfortunately this tool
stopped working in macOS Sierra, due to some internal kernel
That was pretty painful for me as it meant that on my old MacBook
I couldn’t upgrade to the newest macOS editions and on my new
MacBook I couldn’t type properly in Emacs (as it came with Sierra pre-installed)…
Fortunately 2 years later this is finally solved - the Karabiner team
rewrote Karabiner from scratch for newer macOS releases and recently
added my dream feature to the new
Karabiner Elements. Unlike in the
past though, this remapping is not actually bundled with Karabiner by
default, so you have to download and enable it manually from
That’s actually even better than what I had originally suggested, as
here it’s also suggested to use
CapsLock with a dual purpose as
Control when held down and
Escape otherwise. I have no
idea how this never came to my mind, but it’s truly epic! A crazy
productivity boost just got even crazier!
CIDER is a popular Clojure
programming environment for Emacs.
In a nutshell - CIDER extends Emacs with support for interactive
programming in Clojure. The features are centered around
an Emacs minor-mode that complements
supports editing Clojure source files,
cider-mode adds support for
interacting with a running Clojure process for compilation, debugging,
definition and documentation lookup, running tests and so on.
You can safely think of CIDER as SLIME (a legendary Common Lisp programming
environment) for Clojure - after all SLIME was the principle
inspiration for CIDER to begin with. If you’re interested in some
historical background you can check out my talk on the subject The
Evolution of the Emacs tooling for
Many people who are new to Lisps (and Emacs) really struggle with the concept of
“interactive programming” and are often asking what’s the easiest (and
fastest) way to “grok” (understand) it.
While CIDER has an extensive manual and a section
on interactive programming there,
it seems for most people that’s not enough to get a clear understanding
of interactive programming fundamentals and appreciate its advantages.
I always felt what CIDER needed were more video tutorials on the
subject, but for one reason or another I never found the time to
produce any. In the past this amazing intro to
SLIME really changed my
perception of SLIME and got me from 0 to 80 in like one hour. I wanted
to do the same for CIDER users! And I accidentally did this in a way
last year - at a FP conference I was attending to present CIDER, one
of the speakers dropped out, and I was invited to fill in for them
with a hands-on session on CIDER. It was officially named Deep Dive
into CIDER, but probably
“Intro to CIDER” would have been a more appropriate name, and it’s
likely the best video introduction to CIDER around today. It’s
certainly not my finest piece of work, and I definitely have to
revisit the idea for proper high-quality tutorials in the future, but
it’s better than nothing. I hope at least some of you would find it useful!
You might also find some of the additional CIDER
mentioned in the manual helpful.
In Emacs you can evaluate Emacs Lisp pretty much anywhere - even
in the minibuffer. Writing
Emacs Lisp in the minibuffer, however, is not exactly fantastic
experience out-of-the-box - there’s
TAB completion, but what about
paredit for instance?
If only there was a way to enable them… I suggested one trick in my
original post on
eval-expression, but Emacs 24.4 made things even
easier by adding
eval-expression-minibuffer-setup-hook. To enable
eldoc for minibuffer evaluations use this snippet:
(add-hook 'eval-expression-minibuffer-setup-hook #'eldoc-mode)
paredit you can use this one:
(add-hook 'eval-expression-minibuffer-setup-hook #'paredit-mode)
Obviously you can do the same for any other minor mode you might need.
The best thing about this setup is that it will work with tools like
SLIME as well (they have similar
commands which allow you to evaluate Clojure & Common Lisp code and
those command trigger
If you know the name of some command, but you’ve forgotten its
keybinding(s) there are 3 common options to look the keybinding(s) up.
This will display some information about the command in question in a help buffer.
Important bits of this information include where is the command defined, what are its
keybindingings if any, and its documentation.
This will display the keybindings of the command in the minibuffer. If you’re interested only
in the keybindings you should prefer this option over
After you invoke some command using
M-x you’ll see a suggestion to use
its keybinding instead in the minibuffer.
That’s all for now, folks!