About me

Hi! My name is Andrey Listopadov (a.k.a. Andrey Orst), and I’m a software developer and free software enthusiast. I use Clojure as my primary language, and have a lot of experience in C and bare metal programming. I’m a huge fan of Lisps, studying Common Lisp, and helping with the development of the Fennel language.

This is my personal space, where I share my thoughts on various (not only) programming-related topics. I do so not very regularly, so if you’re interested, you can follow me via an RSS feed to get notified of new posts. If you like something I do or want to give feedback, there’s a link section below, which describes how you can contact me. All my work is open source, and I value its principles and principles of free software.

You can think of me as a text editor enthusiast, as I often try out various text editors, and sometimes contribute to their ecosystems. I’ve written a somewhat in-depth overview of various text editors and my thoughts on why one may be better than another in various contexts.

I also like studying various programming languages to expand my reach and learn new paradigms. Furthermore, I have various amounts of experience in languages like Perl, Lua, Rust, Awk, Clojure, Scheme, Python, C, C++, Common Lisp, Zig, Racket, Erlang, and Elixir. My operating system of choice is GNU/Linux and GNU Emacs is my preferred editing software.

Projects that I made or worked on

I do a lot of stuff, and that’s primarily the reason why I decided to create this blog, so I could keep my thoughts a bit more organized, and occasionally write about stuff I’ve built. Below are some projects of mine in arbitrary order, some of which I consider finished, and some of which are still in the phase of active development.

Fennel

As I’ve already mentioned, I’m working on the Fennel language itself as well as on various libraries, or just projects that I find fun. I like Fennel very much, because it brings together the simplicity and expressiveness of Lua with the flexibility of the Lisp macro system, and does so in a very smart way.

fennel-proto-repl-protocol - a protocol powering fennel-proto-repl in the fennel-mode Emacs package.
with-debugger - a (work in progress) step debugger for Fennel.
Brick Game with a Twist - an entry to the first Fennel game jam.
fennel-async - an experimental library for asynchronous programming in Fennel.
Fennel-conditions - a condition system for Fennel language.
Fenneldoc - a tool to turn Fennel function metadata into documentation.
LÖVE F.A.B.R.I.K. - implementation of Forward and Backward Reaching Inverse Kinematics algorithm in Fennel using LÖVE game engine.
LÖVE Raymarching - an example implementation of the raymarching algorithm done in Fennel language using LÖVE2D game engine. Post link.

Clojure libraries for Fennel

These libraries are very much Clojure inspired:

lazy-seq - lazy sequence manipulation library for Fennel and Lua.
itable - immutable table library for Lua and Fennel.
Cljlib - a general-purpose library for Fennel language that brings functions and macros from Clojure’s core namespace. It integrates both lazy-seq and itable to provide experience very similar to what you can get from Clojure.
async.fnl - A core.async port for Fennel.
fennel-test - a Clojure-inspired unit testing library for fennel.

The aim of these libraries is to make Clojure programmers more comfortable with Fennel by providing a set of features they already know. The result may not be idiomatic Lua, but it isn’t always the target to pursue.

Clojure(Script)

Clojure is my main language at work, and I did a few hobby projects in it in my spare time:

basic raycasting engine - a small raycasting demo in ClojureScript and a tutorial on how it was done.
time-control - a CLI app I made as a practice with GraalVM, and used for a while to keep track of how much time I spent on various activities. It was built in a rush, so it’s not the greatest example of my Clojure skills.
wave function collapse - an implementation of the WFC algorithm that I’ve also explained in a post. The demo page features a basic tile-based editor, and some examples to try.
cheat-json - a JSON parsing library, that basically removes bits of JSON syntax and reads the result as EDN. It’s not very fast, probably doesn’t support some tricky JSON examples, and was made more as a joke.
CljLox - an interpreter from the first half of the Crafting Interpreters book implemented in Clojure. It features a fully immutable and extendable parser, tokenizer, and interpreter.
pipeline-extras - a supplementary library for clojure.core.async, that provides fixed version of pipeline-async, as well as unordered pipeline variants.

Emacs

My main text editor, which I use both to write code, this blog, take notes, do agenda, and other stuff. My configuration is quite extensive, and I’m trying to extract useful stuff from it into packages:

ob-fennel - Org Babel support for the Fennel language
isayt.el - indent s-expressions as you type. Basically does what the name says.
fennel-mode - major mode for the Fennel language. I’m a co-maintainer of this package.
region-bindings.el - not to be confused with region-bindings-mode. This is another implementation of the same feature, which works better for my own use cases. It was a part of my config for a long time, but I decided to move it into a separate package.
common-lisp-modes.el - a mode for enabling common modes for various lisps.
infinite.el - experimental windowing system with infinite workspace.

Kakoune

I’ve used this text editor for some time, heavily configured it, and developed this set of plugins over time:

plug.kak - a plugin manager for Kakoune.
fzf.kak - a fzf integration plugin.
smarttab.kak - Vim’s smarttab feature.
powerline.kak - a status line plugin with themes and contextual behavior.
langmap.kak - a plugin to toggle keyboard layout for insert mode only.
pmanage.kak - plugin to spawn and manage background processes.
tagbar.kak - a code outline view with Ctags.
kaktree - an integrated filetree explorer with Tmux support.
base16-gruvbox.kak - unofficial base16 variant of gruvbox color theme.

Vim

I’ve used Vim (and NeoVim) for a very long time, and it was my first experience with a hackable text editor. The following plugins were originally meant for personal use, but I’ve published those anyway.

SimpleSnippets.vim - a small and fast snippet manager and template engine.
SimpleClangFormat.vim - a clang-format integration plugin.
SimpleWorkspaces.vim - Visual Studio Code inspired workspaces for Vim.

Rust

The Rust programming language was what finally motivated me to move away from C to some other language and start this blog. I really liked the concepts behind the borrow checking system, and overall Rust was pretty fun. For self-exercise purposes, I’ve written GRScheme - a small scheme-like language interpreter in Rust. Here’s the series of articles in which I go into implementation details. It’s not the greatest way to make a language, and the code is not the best either, but I’m still proud of it.

Lua

I’m not the biggest fan of the Lua language, it’s just that I like its virtual machine characteristics. Most stuff I’m making for it is done in Fennel because it is a better language.

lua-inst - A simple implementation of ISO 8601 date parser for Lua.

Links

I don’t use social networks that much. The preferred ways of reaching me are by Email or Telegram, just beware that I may be slow to respond.

Most things that I do are available under MIT or GPL3 licenses on my GitLab or GitHub profiles. So if you have any issues with any of my projects, like bugs, or want to submit a feature request, consider using the appropriate git forge, where the project is hosted.

GitLab: @andreyorst
GitHub: @andreyorst
Email: andreyorst@gmail.com
Telegram: @aorst

If you use Email you can optionally encrypt the message with the GPG key below.

GPG public key