When I wrote about spacemacs, I thought spacemacs would be the thing that I would use for everything. Then I ported it to atom with proton and thought that would be the tool I would be using for everything since I could just implement features on the spot that it didn’t have yet. So what happened that I am writing about editors again?

As a VIM fan, I like micro optimizations. One thing in my workflow that I couldn’t stand was hammering j j j j to go down instead of 4j. I knew this keybinding was a lot faster, I just couldn’t get to teach myself to actually use it. After a bit of research I couldn’t find anything that helps me inside atom or emacs - but I found hardmode for vim. It was a bit overkill since it disables all hjkl keys but a good start. Then I found hardtime and it was like my prayers have been answered 🙏. It allows me to use hjkl exactly x times - and I can specify how much x is! Only problem - I need to use raw VIM.

Hello NeoVim (again)

Instead of vim though I grabbed NeoVim as my weapon of choice. Stuffed in my old config file just… to realize that things are not working the way I want them to. Plugins were outdated, keybindings were ‘meh’ and my old vimrc a complete mess. How were I ever able to work with this??

It had to go and something new had to be in it’s place, so I opened up a new vim pane and started hacking on my new vimrc with the goal that everything I use should be heavily optimized, consistent and use NeoVims async features if possible. No more syntastic lags on linting - neomake runs completely async!

I replaced vundle with the async vim-plug and re-added crucial packages that I needed - but something was still missing. I can’t just assign random leader keybindings after having such a blast with the spacemacs mnemonic. After changing the leader to <SPC> and re-arranging the keybindings a bit I was quite surprised to see what I ended up doing - re-creating mnemonic keybindings in vim! I also went the extra steps and moved everything related into a package of some sorts. A bit of sourcing here and there and suddenly I had “layers”! Just like in proton or spacemacs!

Quality plugins ahead

What eventually got me really into vim were probably the amazing plugins of junegunn, the guy that wrote vim-plug. I am absolutely impressed about the quality of these and didn’t have this much fun with vim for a long time. Stuff like fzf makes almost every command feel consistent.

He even wrote a color scheme using the official colors of probably my favorite city on the planet - Seoul. Just look how pretty it is:

In all seriousness, his plugin collection is amazing and I can highly recommend you to check it out if you are using vim. He might be the next tpope!

tl;dr

hardtime for vim made me go back into vim territory and NeoVim made me stay.

If you are a gvim guy like me, check out neovim-qt. It is a lot faster performance wise and more stable than Neovim.app.

Also my nvim dotfiles are a great starting point to get into vim. Everything is written very decoupled so you could just use whatever modules / packages you want and not source the rest.

Do I now use vim for everyting? Nah, probably not. proton is still my main weapon. These days I’m on a VIM streak with the goal to master the more advanced text navigation commands but most of time time proton (if the atom-shell wouldn’t suck so much battery….).

Let me know your thoughts on twitter.

Meet ClojureScript

Lately I’ve been doing a lot of clojure. I am glad that I finally arrived at a point where I don’t have to look into the documentation just to find out how to append something to a vector. Clojure is extremely well designed. I learned a lot just by listening to talks (especially the rich hickey ones!) and reading about the languages’ core concepts and the reasons behind them. But above all, Clojure is just fun to use and ClojureScript is even more fun! I love using it and even wrote a MarkDown editor in it. Lately clojurescript ended up becoming the magic that fueles my entire main editor.

What’s amazing about ClojureScript is that it can literally go everywhere javascript can go and man can javascript go to places these days. I even started to build freaking native apps with it! Imagine I would tell that to someone a few years back:

A: Oh that app looks cool. How did you build it?
B: Ah I’m using clojurescript to control the native view properties.
A: cloj… what?
B: Yeah, it cross compiles to javascript.
A: Javascript? native?
B: Javascript is then using react native to bridge into ObjC
A: 😮

I like clojurescript to that degree that I start to feel bothered if someone asks me to write raw javascript these days. I like it that much.

Clojure

The only thing I am not 100% happy with right now is… well… clojure! I tried a few times to use it on the serverside but it just never felt completely right to me. I ended up searching all these little building blocks like migrations, database connections, router and templating, and proceeded to stack them together… somehow.

Then there was the big problem of libraries getting abandoned. Here’s a example: When I wrote my first server it took me ages to find lobos - the migration library everyone told me to use. Shortly after, it turned inactive and communication around it died. Suddenly noone wanted to use lobos. A few questions here and there and people told me to just write SQL files and pipe them with clojure into the db.

Clojure people feel to me like these people that like to build stuff raw and by themselves. To have full control over every aspect and if a building block doesn’t exist yet - it will just get written on the spot. My server eventually worked and that is what counts, right? But I wasn’t happy maintaining it. All these lego bricks felt glued together in a not stable way.

So I kept going on my way, sometimes using clojure, but most of the times django for my server stuff. I kept adding things to my you-should-check-that-out-list including Go, Rust, and a few frameworks here and there, just waiting for me to have some more free time.

A few days ago I wanted to start a new side project - an app to be specific. My fingers were itching to do a real world app in clojurescript but needed something for the server. I started mocking things up with django but then took a short look at my list. On first place was something called elixir. “Elixir, huh?”, I thought and opened the website

Hello Elixir

When I first checked out Elixir I didn’t think of much. Looks like ruby and feels like ruby with a bit of clojure sugar sprinkled in. The |> operator is obviously taken straight out it. Atoms are no longer state containers but now what I would call… a keyword? In any way, being a functional language inspired by clojure and coming directly from clojure I felt home right away.

I downloaded phoenix, figured out ecto, hacked my API server together and went on with my app. That was until I had to implement a image upload and resize service to s3.

My django instinct told me to find the celery of the elixir world but what came next completely changed my way I looked at the language.

You see - I didn’t read the entire documentation on elixir-lang (which I should have done). I wanted to get a feel for the language first before going into all the little details. When I asked on the elixir slack for the idiomatic way of implementing a worker I got pointed to the processes, agents and genserver guides.

I knew that elixir is running inside the erlang VM but I never used erlang before and all I knew about it was from hearing about it.

Mind = 💥

To summarise it very short: The concurrency handling of elixir is just effing amazing. Without any troubles and at any time you can spin up subprocesses, pass stuff to them, link them together and build your little network.

Processes are completely isolated and very well managed. I never had the feeling that using processes will now lock me into a big headache network of synchronisation, orchestration and possible chaos. And even if something goes wrong - elixir and erlang actually encourage you to let things fail! No try/catch blocks and exception handling. You just let the process fail and the supervisor will take care of troubleshooting and restart that thing - just like that!

Here’s an example that really shows how powerful this is: State management! The recommended way of storing state in elixir is… a process! You have a process that holds your piece of state and reacts to defined messages passed to it: e.g. store and retrieve. I mean… what?!

If you now connect another node to your mesh network, that node could immediately send messages to the same state management process if it knows it’s identifier (e.g. :kwstore1). Just like that you suddenly have state management - but synchronised on multiple machines… I mean… what?!?!

The joy of concurrency and even more 😮 = 💥

Elixir doesn’t care if you have 1 node or a thousand. It directly works with all of them right away.

Let’s go back to my image upload and resize example: In django I would take the image, push it to s3, push a message into amqp / redis, tell the user “success” and let a worker process the resizing before marking the image as “processed” in a db. 3 components: Web server, queue server, worker.

Now elixir. I take the image, put it on the disk and push the original to s3. I tell the user “success” but at the same time spin up a child process with the reference to image on the disk. The user gets his “success” but the child process lives on! It does it’s resizing stuff, uploads to s3, updates the db and if something goes wrong like a timeout from s3, then so what? It just crashes, the supervisor restarts the process and it tries again. All while the user is already gone! Without a queue! Without a worker! Out of the box!

To give that more context, on heroku with django I would have to scale up another worker process (costs $), add a amqp server (even more $) and let everything run at the same time. On heroku with elixir I can literally have all of that inside a free dyno! I could even spin up 50 worker processes and it could still run inside the same free dyno without a cent extra if I am nice with memory.

And you know actually how easy it is to spawn a simple child process?

spawn fn ->
	IO.puts “Hello from Child”
end

But I’m just scratching the surface of this amazing language. Phoenix for example has built in support for websockets, you know what this means when it comes to elixir? You could connect to server1, I could connect to server98934 which is part of the same mesh and we could still chat with each other without any extra work!

Elixir made it damn appealing to use concurrency programming. I never fear that I will break something essential because it is just this well done. It is designed that it actually encourages you to use these features more often - because seriously, why wouldn’t you?

Scripted Elixir

Amazing syntax, functional programming, REPL driven development, unbeatable concurrency model - how could you make this language even more attractive? I will tell you how:

Elixir has 2 ways of executing your code: Pre-compiled and scripted. Pre-compiled means that once you are ready to run your app you tell elixir (or mix) to compile everything down and execute it. But what could scripted mean?

[i] λ elixir -e ‘IO.puts “Hello World”’
Hello World

…that’s what it means! Elixir comes with a scripted mode that compiles your code on the spot in memory before executing it! No slow spinning up java to execute your clojure code or compile it into javascript. Executing elixir in scripted mode takes 1 second at max and doesn’t require you to have anything set up. No project, no mix - nothing.

The language of my dreams?

I know it is too early to judge but I really like Elixir. I didn’t have this much fun programming on the server since I initially discovered django. Pair Elixir on the server with clojurescript on the client and you have the stack of my dreams - powerful and fun programming on the client and server at the same time (let’s call it dave-stack).

I will continue my journey with Elixir. If you didn’t check it out - I highly urge you to do so. It could very easily become the next ruby in a very short time.