Clojure on Ken Huang

Your Screenshots Deserve Better. Introducing Backdrop.

whatacold@gmail.com (Ken Huang) — Tue, 10 Mar 2026 22:49:27 +0800

Have you ever been there? You've just finished a brilliant piece of code, designed a slick UI, or found the perfect example for a tutorial. You take a screenshot to share your work, but when you look at it… it's just… plain.

You could share it as is, but it lacks professionalism. Or, you could spend the next 15 minutes wrestling with a heavy-duty design tool, carefully placing it on a background, adding a shadow, and rounding the corners, all for a single image.

🥷 Clojure Pro Tip 5: Hiccup Raw

whatacold@gmail.com (Ken Huang) — Thu, 15 May 2025 12:49:27 +0800

In case you don’t know it, we can use raw strings, like embedding JS code, in hiccup.

I just found out we can use raw to prevent strings from getting escaped. I used to have to define a dedicated app.js for that, which would need an extra HTTP request.

Hiccup raw in action

Looking back, I should’ve found this at the very beginning, as it’s just mentioned on its GitHub homepage, but somehow I missed it.

🥷 Clojure Pro Tip 4: Cider ClojureDocs

whatacold@gmail.com (Ken Huang) — Tue, 29 Apr 2025 12:49:27 +0800

Sometimes, we may want a few examples of a Clojure API for inspiration while developing, especially when reading other people's or open source code.

With Cider in Emacs, we can run M-x cider-doc to see the docstring for the symbol. We can even use M-x cider-clojuredocs for some examples if the symbol is from the language core.

Running M-x cider-clojuredocs

I happened to find this command recently. I bet I was not the only one who didn't know it, thus I'm sharing.

🥷 Clojure Pro Tip 3: the Thread-As Macro

whatacold@gmail.com (Ken Huang) — Wed, 23 Apr 2025 12:49:27 +0800

So you're more than excited to find out how Clojure's thread macros can make code clean and concise, you just love it! But at some point you'll be trapped a bit as the threaded argument's positions are inconsistent using -> or ->>.

Luckily, you can use as-> to place the argument wherever you like:

Lambda vs. thread-as

🥷 Clojure Pro Tip 2: group-by

whatacold@gmail.com (Ken Huang) — Fri, 18 Apr 2025 12:49:27 +0800

It's amazingly easy to group things in Clojure. The language core provides a group-by function directly. Together with many built-in functions or key functions, it creates a ton of possibilities, and we can also bake our grouping function if none is satisfying.

group-by

Example from Clojure Koans.

🥷 Clojure Pro Tip 1: the Discard Reader Symbol

whatacold@gmail.com (Ken Huang) — Sat, 05 Apr 2025 12:49:27 +0800

In Clojure, we can use comment (aka Rich Comment Blocks) for tests or experiments in development. However, since a comment evaluates to nil, you may run into surprising results or even errors if you misuse it.

Comment vs. Discard

In these scenarios, you may tend to use ; to comment them out, but a better choice is to use the discard reader symbol #_.

Rewrite of a Flask Web App in Clojure

whatacold@gmail.com (Ken Huang) — Sat, 22 Feb 2025 22:46:05 +0800

Intro

A few years ago, I made a simple web app in Flask to deal with some text processing problems from my daily work. It has two main features:

Feature #1: generating compile_commands.json for GNU Makefile projects written in C/C++ using the output of the make command. Because, unlike CMake, the make command can't generate it.
Feature #2: extract text using Python regex. It's handy when I feel like sed/awk/grep's line-oriented processing isn't enough for the task at hand.

BTW, I'm improving my English by watching YouTube videos every single day; If you're also learning English, or any languages, LanguagePuppy can definitely help you. It's a Chrome extension I developed using Clojure. Check it out:

Constructing Clojure Maps Conditionally

whatacold@gmail.com (Ken Huang) — Sun, 05 Jan 2025 10:40:07 +0800

I was wondering how to construct a multi-key map conditionally while I was coding in Clojure. Ideally, I would like to build it "in one pass" like {:bar 2 (when true :baz 3)}, but from what I had collected from Blue Sky, it seemed that's impossible, or it's just not an idiomatic way to program like that in Clojure. (Or, is this just a side effect of writing too much imperative code?)

Getting Started with Cider for Clojure Programming

whatacold@gmail.com (Ken Huang) — Sun, 22 Dec 2024 17:17:15 +0800

Here is the outline for my cider tutorial on YouTube, covering basic things you need to know to get started with cider, and starting exploring the fun of clojure programming with the REPL-driven programming approach.

Jack In to a REPL

C-c M-j (cider-jack-in-clj): start a nREPL and jack in. It works in a project or with a sole .clj file.
M-x cider-connect-clj: run the command and then fill in hostname and port. It could be useful in some cases. e.g. on Windows, I can start the nREPL manually and then connect to it separately.

Evaluate Things

C-M-x (cider-eval-defun-at-point): evaluate current top-level form.
C-x C-e (cider-eval-last-sexp): evaluate the preceding form.
C-c C-k (cider-load-buffer): evaluate/load the current buffer.
C-c C-p (cider-pprint-eval-last-sexp): Pprint the result in a dedicated buffer. Great thing to do when the result is too large to fit in the echo area.

Note: I prefer to use the same key bindings as for Elisp, given that cider might bind a few keys to a single command!

A Few Quick Notes About babashka/fs

whatacold@gmail.com (Ken Huang) — Sat, 07 Dec 2024 22:24:41 +0800

Recently I've used babashka/fs a little bit, here are some quick notes for it:

Path vs File. Use Path whenever possible, according to this SO answer to "Java: Path vs File". This is actually Java related.
It's ok to use a path as a key for a clojure map. At my first try, I somehow came to the conclusion that it's not ok, while I was refactoring the live reload for clay. And later I found that it's totally fine to use it as a key. 😞
Use fs/path to construct file/directory paths, for example, (fs/path "/tmp" "foo" "bar" "baz.clj") will result in a path object for /tmp/foo/bar/baz.clj on linux. If you're coming from Python, it might remind you of os.path.join(path, *paths).
Use fs/createdirs for mkdir -p, though its name is a bit misleading, I first thought it's for creating a few dirs.
fs/with-temp-dir is convenient for creating tests.

Doing Unit test in Clojure Is Easy

whatacold@gmail.com (Ken Huang) — Thu, 28 Nov 2024 23:10:56 +0800

While refactoring the live reload feature of Clay, I realized I'd better break long functions into smaller and functional ones (as many as I can), which is also a common practice in the clojure community.

Small pure functions not only are easy to verify on the development process (using a REPL), but also are easy to test. And unit tests are easy to write in clojure, just use deftest from clojure.test, a very basic one looks like this:

Clj-async-profiler Rocks

whatacold@gmail.com (Ken Huang) — Thu, 28 Nov 2024 22:23:32 +0800

While developing the live reload feature for Clay, a minimalistic Clojure tool for data visualization and literate programming, I found that it constantly takes ~1 minute for beholder to watch a directory. After some code inspect, I was still having no idea why it happened.

So I decided to use a profiler to find out what's going one under the hood, and Google immediately took me to clj-async-profiler. It's easy to set up following its basic usage docs:

Adding Clojure Dependencies from the Command Line

whatacold@gmail.com (Ken Huang) — Sat, 09 Nov 2024 21:02:56 +0800

While debugging a live reload issue of Clay a few days ago, I learned from Markus Agwin that we can actually add dependencies on the fly from the command line, just like this: clj -Sdeps "{:deps {org.scicloj/clay {:mvn/version \"2-beta21\"}}}".

Even better, we can add dependency from a Git repo and specify the commit hash: clj -Sdeps "{:deps {io.github.scicloj/clay {:git/url \"https://github.com/scicloj/clay.git\" :git/sha \"35a46541db66ae6b4e1af628b7c24c42d3be418f\"}}}", which is really helpful for experimenting and verifying things.

Some clj links (clj --help has a pointer for these URLs):

Bitten by Lazy Sequence of map

whatacold@gmail.com (Ken Huang) — Sat, 09 Nov 2024 21:02:56 +0800

While impletenting the live reload feature for Clay a few weeks ago, unfortunately, I was bitten by the laziness of map. It seems quite obvious we all know that its result is a lazy sequence, but I just can't help fall into the "trap".

At that time I was adding a vector to keep track of all beholder instances watching file changes in user specified directories. So then when it's time to stop all the watchers, I used something like to achieve the goal:

Anonymous Functions in Thread Macros

whatacold@gmail.com (Ken Huang) — Fri, 08 Nov 2024 21:02:56 +0800

While adding the live reload feature to Clay, I encountered a problem of applying anonymous functions to thread macros. For example, below is a simple snippet trying to wrap the input directory as a vector with the help of thread macro, but surprisingly, it errors out. After some searching, I figured out that I need to put the anonymous function into another pair of parentheses:

(-> "/tmp/"
    #(if (vector? %) % [%]))
;; => Syntax error (ClassCastException) compiling fn* at (simple4all.clj:19:1).
;;    class java.lang.String cannot be cast to class clojure.lang.ISeq (java.lang.String is in module java.base of loader 'bootstrap'; clojure.lang.ISeq is in unnamed module of loader 'app')

(-> "/tmp/"
    (#(if (vector? %) % [%])))
;; => ["/tmp/"]

Paul has a nice explanation on Stack Overflow, thread macros need the function forms to be lists, but anonymous functions are already lists, so the first expression, "/tmp/" in this example, will just be inserted into that list, just as illustrated below:

Starting a Clojure nREPL Manually for Cider

whatacold@gmail.com (Ken Huang) — Fri, 08 Nov 2024 00:02:56 +0800

While troubleshooting and fixing a live reload bug in Clay today, which required to start a minimal Clojure environment, I figured out how to start a nREPL from the command line.

Instead of using M-x cider-jack-in-clj directly from Emacs, actually we can manully bring up an nREPL with this: clj -Sdeps "{:deps {org.scicloj/clay {:mvn/version \"2-beta21\"} cider/cider-nrepl {:mvn/version \"0.50.2\"}}}" -m nrepl.cmdline --middleware "[cider.nrepl/cider-middleware]" (The clay part is only necessary for this debugging), and then connect to this nREPL using the Emacs command M-x cider-connect-clj.

Clojure reduce: one case for text processing

whatacold@gmail.com (Ken Huang) — Sun, 19 Sep 2021 10:39:23 +0800

As a practice, I managed to illustrate Clojure files using illustrate.clj, but my original idea was to annotate org-mode files of blogs. It's not uncommon that a blog post has some code snippets.

But it missed the feature until last night, as I wasn't sure how to implement it appropriately before and didn't have enough time.

For example, I may have an org-mode like this:

sum of two numbers:
#+begin_src clojure
(+ 1 2)
#+end_src

I want to have a result comment ((;; => 3)) after each top-level form after using illustrate.clj: sum of two numbers:

illustrate.clj to Illustrate Clojure Snippet

whatacold@gmail.com (Ken Huang) — Sat, 07 Aug 2021 18:49:25 +0800

To get my hands dirty with Clojure, I am trying to find or implement Clojure's string functions in the sense of Python. Python has powerful string APIs, and I also want to see how powerful Clojure could be in this field. That would be interesting.

As shown in the cheatsheet, Clojure has implemented most of them, and there are some that I have to implement myself, like title-case.

Along the way, I found it was a little cumbersome to append the evaluation result and the result of calling them, for example,

String Title Case in Clojure

whatacold@gmail.com (Ken Huang) — Sun, 25 Jul 2021 11:51:39 +0800

These days I like to write scripts for some tasks in Python instead of shell. One important reason I think that's because Python is powerful at string manipulation.

Recently I'm learning Clojure, and I'm trying to find similar ways in Clojure, one of them is s.title() for getting a title-cased version of a string. For example,

>>> ' Hello world'.title()
' Hello World'

How to do that in Clojure? To make the problem simple, let's assume that the input string only has letters and spaces, that is, [a-zA-Z ] in regex pattern.

String Manipulation in Clojure

whatacold@gmail.com (Ken Huang) — Thu, 22 Jul 2021 23:29:11 +0800

Python string APIs are powerful and concise, that is an important reason I use it to do a lot of scripting these days, join, split, strip, to name a few.

Since I am learning Clojure recently, I am wondering, how is string manipulation like in Clojure and how to implement equivalent ones?

I think it's an excellent opportunity to get familiar with Clojure. Before diving into the implementation, how to declare a multi-line string?

A Random Password Generator in Babashka

whatacold@gmail.com (Ken Huang) — Sun, 11 Jul 2021 09:18:41 +0800

I'm used to learning by practicing, so when I learned Clojure, I always kept an eye on chances to write code in it.

Scripting is an excellent field to practice, but the experience is not so good. On the one hand, it's too hacky to wrap Clojure code in a shell script with the shell bang. On the other hand, the startup time of JVM is too long to hurt the user experience.