Personal weblog

TL;DR: Using lazy sequences for API consumption has advantages in memory consumption and promotes interactive development.

HTTP APIs are ubiquitous and consuming them is a programming task coming up quite regularly (at least for me). Therefore I found the following idiom pretty useful, which turns a paginated, remote data source (in this case the GitHub jobs API) into a lazy sequence:

(defn- fetch-lazy-jobs-seq!
  ([]
   (fetch-lazy-jobs-seq! 0))
  ([page]
   (let [jobs-url     (fn [page](format "https://jobs.github.com/positions.json?page=%d" page))
         {body :body} (http/get (jobs-url page) {:as :json})]
     (if (seq body)
       (lazy-cat body (fetch-lazy-jobs-seq! (inc page)))
       body))))

In the REPL it is comfortable to just inspect parts of the data without waiting for many HTTP requests to be send:

TL;DR: Leiningen provides facilities that make using a REPL driven workflow a breeze. You should consider using them on your projects for a more pleasant development experience.

If you change work environments once in a while you know that there is one thing that you are doing quite a lot of when starting off: Cloning quite a lot of repositories. Microservices, git and infrastructure as code among other things have let to a big number of repositories in almost all organizations.

As I was doing that the last time it got really tedious. Mainly because I wanted to search the whole code base and that did not work with the local gitlab instance. Naturally I turned to the shell to give this a shot and as it turns out it is a one liner (line breaks added for your convenience ;)), mostly thanks to python-gitlab and the inherent awesomeness of the shell:

Just a few days ago I finally fixed an annoyance with my Thinkpad T460p and the Ultra Dock: Removing the laptop from the Dock results in it going into hibernation. Then after opening the lid it does not switch the built in screen back on. This turns out to be easy to fix.

Undocking and docking leads to a lot of events which can be observed by a simple

sudo acpi_listen

The event that seems to be the most promising is used as a trigger to correct the display settings. In my case that meant putting

Releasing libraries is a tedious but important task. There is lots to do and lots to screw up:

• Tagging the release state
• Making a clean build
• Signing the artifacts
• Pushing them to some repository
• Bumping the version to the next snapshot iteration
• And so on and so forth…

Having a dark past in the java world I looked for something like the maven release plugin for leiningen, which automates the whole process quite nicely. Turns out there exist a lot of release plugins. Right now clojars lists 50 results for the search term release.

These days I stumbled upon some code committed by a very competent but sadly no longer present colleague and was baffled to see this:

catch (Throwable t (log/error t "horrible things happend))

This left me puzzled and after looking for clues why this had been done (and not finding any) I decided to remove this exception dodger and move on. Turns out I created a bug.

Why? Because this code was called in a job scheduler from the very popular overtone/at-at library. And it showed the following behavior: