I have recently switched my Neovim setup to use lightline.vim and at the same time I was experimenting with colour schemes. Getting lightline to switch colours along with the rest of the editor is non-trivial, but I think I have figured it out, so I am going to share my setup.
When I was still researching this fabled obscure language called Lisp one thing people kept saying about it is that “Lisp is a programmable programming language”, but I could never figure out what they meant by that. It sounds like a smug buzzword or like a gimmick from an academic toy language. Lisp programmers have gotten so used to metaprogramming in Lisp that they seem to forget that it is either an entirely alien concept to people, or something people have been burned by too often (like every C programmer).
When I first learned about rotation matrices they appeared quite “magic”; if you squinted your eyes a bit it sort of made sense, and if you did the math you could prove that the matrix does indeed perform the rotation and that all the group properties are met, but none of that explains where that form comes from, why it works. In this blog post I will explore a way to derive the formula for rotation matrices step by step. If you wish to follow along you need only basic knowledge of linear algebra and trigonometry.
Vim has good support for Scheme, but the problem with Scheme is that every implementation adds its own features to the language. My guile.vim plugin aims to improve support for GNU Guile by augmenting these settings. It can attempt to detect when a Scheme file is Guile-specific and it adds syntax highlighting for Guile-specific forms.
I use GitLab to host my various projects, but it is always a good idea to be able to have an automatic mirror set up. It adds redundancy in case something goes wrong with GitLab, and having a mirror on a popular site like GitHub allows people to file issues without signing up for a less popular service. I am writing this down for myself so I don't have to figure out how to set up a mirror every time anew. This was written for GitLab version 12.0.0.
In order to make writing Awk scripts easier I have written a new Neovim plugin: Awk-ward.nvim (GitHub mirror). This plugins allows you to edit an Awk script or its input, and see the output live as you are making changes.
When I wrote guile-messagepack I needed an object to represent the nil
value, which embodies the concept of "nothingness" or "no value" in
MessagePack. None of the existing objects like #f or '() were adequate,
so I decided to make a new one: nothing. It does not make sense for there to
be multiple instance of nothing, so it had to be a singleton. In this blog
post I will describe a way of creating such a singleton.
NCM2 is a plugin for Neovim and Vim which provides users with a unified completion menu. By default it displays nothing, users need to add sources for completion. These plugins instruct NCM2 on how to get completion candidates for a particular use-case, such as words in the current buffer, or function names in a programming language. The NCM2 documentation explains how to write the individual pieces of a source, and in this blog post I am going to dive into how to connect those pieces into a working source.
I have written a Common Lisp completion source for NCM2, built upon Vlime. It provides asynchronous Common Lisp completion and should work in both Vim and Neovim, depending on how well NCM2 and Vlime themselves work.
In the previous article we have seen how to pack an object, this time we will see how to unpack it again on the receiving end.
In this part of the series I want to go into how to pack data to bytes in MessagePack. We will see how to dynamically dispatch on type and how to pack a selection of particular types.
When I originally set out to write MsgPack.rkt, a Racket implementation of the MessagePack protocol, I had a hard time wrapping my mind around where to begin. I had no experience in writing a serialisation library, and reading the source code of existing implementations only revealed the what, but not the why. This is why I'm starting this short mini-series of blog posts to provide a commentary on my implementation. I hope that it will serve other people who are looking for a starting point to their own implementations.
The first major step in phasing out the bloat that is Bootstrap from my website is done. None of the layout depends on any Bootstrap classes and markup. Instead, the layout is built from scratch using the new Flexbox and Grid features.
In the process of de-Bootstrapping the workshop I have to replace whole components provided by Bootstrap with my own constructs. The menu bar is one of the larger components I use, it's fairly complex and requires a lot of non-semantic markup to get working. In this blog post I will describe step by step how I built mine, which requires less markup and does not rely on Javascript. You can try the demo to see what we are going for (please resize your window to see the responsiveness).
I have set up a channel for GNU Guix to build Neovim. This channel serves as an experimental staging ground for porting Neovim (and perhaps other related projects in the future) to the Guix functional package manager. When the packages are deemed stable and correct enough they will be submitted to Guix proper.
One of the new features of Neovim is its ability to write plugins in any programming language, provided that there is a plugin host available. I have wanted to play around with the Common Lisp host for a while, and I like for something useful to come out of it in the end, so I created Quicklisp.nvim, a plugin which allows users to manage Common Lisp libraries from inside Neovim.
Over two years already without rewriting the workshop? I have to rectify this, with the greatest rewrite yet! I have abandoned Pelican because I constantly had to adjust things manually after the build process, and even then there were parts of the website that weren't working. This put me off from blogging, since after each post I would have to stitch everything back together by hand. Seeing that no static site generator would be able to meet my needs I decided to instead write my own in Scheme.