Luciano Laratelli

Setting up dynamic DNS for Namecheap using Dockerized Caddy

2024-06-24T00:00:00Z

The internet is unusable without ad blocking, so I route all of our network traffic through Pi-hole running on my home server to block ads. I want that same experience when I'm away from home, so I set up a VPN with WireGuard to allow me to use my home Pi-hole as the DNS server for my phone and laptop when on the go.

This works great except for when my home network falls over, or I lose power, or when the unexpected happens. We recently went on vacation and, of course, the day we got there, some "unexpected" happened and I was suddenly without an ad blocker on my phone. Before figuring out what went wrong, I quickly spun up a similar WireGuard + Pi-hole setup on a Droplet so I could use the internet without losing my mind.

Thanks to a friend who stopped by our apartment for an unrelated reason, I learned that the issue was that our ISP had changed our public IP on us. This is the first time this has happened to me in the.... five? six? years I've been running a homelab, over four different ISPs.

I thought dynamic DNS would save me, but it seemed clear that I'd configured ddclient incorrectly. Since I run Caddy, I wondered if I could shove dynamic DNS into that. It turns out that's possible with this random "Caddy app"I found, as long as I install the right Caddy DNS provider. I use namecheap, so I grabbed that one.

Using this Caddy app and a Caddy DNS provider involes compiling Caddy with these modules. My home server uses Docker Compose (on Arch, btw) so I need to make an image with the DNS provider built in. The documentation has an example for this (under adding custom Caddy modules), which is great!

My Caddy block previously looked like this:

x-common-variables: &common-variables
  PGID: 1000
  PUID: 1000
  TZ: America/New_York

services:
  caddy:
    container_name: caddy
    image: caddy:2.8.4
    restart: unless-stopped
    environment:
      <<: *common-variables
      HOST: "my.host" # an actual domain name here
      LOCAL_IP: 192.168.1.2
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./appdata/caddy/Caddyfile:/etc/caddy/Caddyfile
      - ./appdata/caddy/site:/srv
      - ./appdata/caddy/data:/data
      - ./appdata/caddy/config:/config

Looking at the documentation for Docker Compose, I want something like this:

x-common-variables: &common-variables
  PGID: 1000
  PUID: 1000
  TZ: America/New_York

services:
  caddy:
    container_name: caddy
    restart: unless-stopped
    build: ./custom-caddy-build
    environment:
      <<: *common-variables
      HOST: "my.host" # an actual domain name here
      LOCAL_IP: 192.168.1.2
      NAMECHEAP_SECRET_KEY: "definitely-my-secret-key"
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./appdata/caddy/Caddyfile:/etc/caddy/Caddyfile
      - ./appdata/caddy/site:/srv
      - ./appdata/caddy/data:/data
      - ./appdata/caddy/config:/config

Then, in custom-caddy-build/Dockerfile:

FROM caddy:2.8.4-builder AS builder

RUN xcaddy build\
    --with github.com/caddy-dns/namecheap\
    --with github.com/mholt/caddy-dynamicdns

FROM caddy:2.8.4

COPY --from=builder /usr/bin/caddy /usr/bin/caddy

Then I ran sudo docker-compose up -d as normal and... it just worked. Neat!

Now I configure the dynamic DNS plugin, in my Caddyfile:

{
	dynamic_dns {
		provider namecheap {
			api_key {$NAMECHEAP_SECRET_KEY}
			user my-namecheap-user
		}
		domains {
			my.host @ www
			my.host my-subdomain
			my.host my-other-subdomain
		}
	}
}

I had to enable access to the namecheap API for my account before this would work. user is just my username for namecheap. To use the API, I had to add an IP address to their allowlist. This is concerning because if my IP address changes (the exact problem I'm trying to solve), I'm not sure that I'll be able to... actually hit the namecheap API to update my dynamic DNS? We'll cross that bridge when we inevitably get to it.

Anyways, how do I check that everything worked? I set up an A+ Dynamic DNS record pointing to 127.0.0.1. I figured if that value gets updated when I restart Caddy, that means I've set things up correctly. That... did not work. The A+ record would (inexplicably) get changed to an A record with the same placeholder IP address.

My next validation attempt was to change the IP address of a subdomain. I observed a change here! The list of subdomains got a new entry for the subdomain I changed with the correct IP address, with the old placeholder one still present as well. This is apparently a known problem that is namecheap's fault so I won't sweat it too much, because the DNS does still work.

The dynamic DNS thing (a "Caddy app") has a dynamic_domains feature that I used originally, but it spammed a bunch of messages in my logs when I tried to use it:

caddy  | {"level":"info","ts":1719245958.4446826,"logger":"dynamic_dns","msg":"domain not found in DNS","domain":"atuin.my.host"}

I ended up specifying my domains manually, as above. This does turn into One More Thing I Have To Remember To Do Whenever I Add A New Service To My Home Lab but that's okay.

Last thing is to format my Caddyfile:

sudo docker exec -it caddy caddy fmt --overwrite /etc/caddy/Caddyfile

Neat!

Setting up unattended access for our building's keypad

2024-03-13T00:00:00Z

Our building has this keypad for opening the front door:

This keypad is half of the entry system. It allows guests to enter a code for the unit they want to access. The computer that's hooked up to the keypad is also connected to a phone line. When it receives a code, it maps that to a phone number (provided manually at move-in time) and rings the designated person, who then enters 9 on their phone to grant access. The other half of the entry system is for owners and residents. We use a fob to get access via doors as well as open the gate to the building's parking garage. This system works well enough for most cases, but I had some items on my wish list:

The system lacks emergency access. If I were to lose my fob, I would have no way to get into the building on my own; I would have to either phone a neighbor, bother someone on the HOA board, or wait for someone to walk in or out.
Giving out the code that routes to my unit is tantamount to giving out my phone number. After some time at our last apartment complex, I started receiving calls from the gate even when I wasn't expecting any visitors or deliveries. Besides being frustrating, this is also a security concern: if I'm expecting a visitor and someone tries my code around the time my visitor should arrive, I may mistakenly allow the wrong person in.^[1]
The system lacks unattended access for trusted guests. I can't always pick up the phone, even if I am home.

Two other motivating factors are that fobs cost $35 each and there's a hard cap on the quantity of fobs the building will issue us.^[2]

I volunteer for the building by setting up the fobs and phone numbers for new residents, which has had two main benefits. The first is that I get to meet new folks as they come to our building, which is always nice. The second is that I (necessarily) have access to the awful, Windows 7-running Dell PC that controls the fob system, which means I can mess around with the values for our unit whenever I want.

Here's what I did: I added a second code for our unit that calls a Twilio number. That Twilio number is using a Twilio Flow, a no-code thing, to accept input from the person at the door. It validates if that input is a code I've provided, then sends the Door Open signal (the number 9) back to the keypad. The flow looks like this:

That redacted URL points at a Twilio Function (classic^[3]) which is not much code at all:

exports.handler = async (context, event, callback) => {
  const good = new Set([
    '123456', // definitely my real code
    '234567', // real code for my neighbor
    '345678', // absolutely the real code for a trusted friend
  ]);
  
  if (good.has(event.code)) {
    return callback();
  } else {
    return callback('bad code');
  }
}

This has been a really gratifying real-world (i.e., not just software) project for me. It has saved me multiple times that I've left my fob at home by accident. I forget it's there until I need it and it has not failed me yet. This setup combined with a lockbox with a key to our front door at an undisclosed location makes it so a lot more has to go wrong for us to be locked out of our apartment. I've paid Twilio $41.36^[4] since February 12th, 2023 (when I set this up) which amounts to 10.47 cents a day^[5]. It is well worth it, both for the peace of mind and the delight I get when I use it.

When I started this project, I had this whole vision for some web-admin interface to add codes dynamically for deliveries, be able to only allow them on certain times, etc. In a rare (and maybe my first ever) moment of Technical Maturity, I said no to that and kept it as simple as you see here.

These systems ostensibly allow for communication between the person at the gate and the unit owner, but their common exposure to the elements makes this not work well in practice. At two of the three complexes we've lived in with these systems, it was impossible to hear what the person at the gate was saying. ↩︎
This is as per the HOA rules. I know for a fact this doesn't get followed but I'm not a cop. ↩︎
At some point before I started this, they had already come out with New Functions and suggested not using Functions (Classic) but the classic one seemed simpler to me at the time. ↩︎
I've paid them $20, $10.27, and $11.09. I have "auto-recharge" turned on, so when my balance on twilio dips below $10 I recharge up to $20. If we ever move I'll have to remember to disable the auto-recharge and then use it a bunch to not leave that money on the table. ↩︎
Computed 2024-03-13 ↩︎

I rewrote this site (again [again {again (again

2024-03-12T00:00:00Z

I rewrote my site again.

It has gone through at least five or six lives: first it was a Hugo site, then it was a Jekyll site (or maybe Jekyll was first), then I wrote it as a reagent SPA, then I wrote it as a server-rendered custom Clojure thing (first with Kit, then another rewrite with some lessons learned from Biff). This latest (and, dear god, hopefully the last) is with eleventy.

It's hard to retrace all of my motivations for these rewrites. The initial iterations used static site generators because I didn't know how to make a website from HTML and CSS. I did the SPA because a) Clojure and b) my friend Kiran had written his blog in a similar fashion. Then I switched to Kit because of the slowness of SPAs and general difficulties authoring posts. That was bad, too, though, so I rewrote again with a stripped-down version of Biff. That was fine, but when I went to add NamedTab, I found it not to my tastes again. It took me way too long to get a simple one-page site up!

I've been following Zach Leatherman, the creator and maintainer of eleventy, on Mastodon for some time. I liked what I was seeing, loved the documentation, so I figured I'd give it a go. After four or five hours of pleasant work spread out over about a week, the new site is ready! You're reading this post on it, in fact. I still have a few things to do (cleaning up the image pipeline, holding the CSS stuff correctly) but I like where it's at.

This switch simplified the deployment story for this site a lot. In the most recent iteration, publishing a new post meant:

Writing the post in org-mode
Exporting it to markdown
Committing and pushing to GitHub
CI runs to build a Docker image that gets deployed to Fly.io.

This takes between a minute and 45 seconds and three minutes. You may notice that it is also overkill for what amounts to a dumb pipe serving up some HTML and CSS.

Now it's: write blog post in either org-mode (then export it to markdown) or in markdown^[1]. Then, just deploy to sourcehut pages:

install:
    source ${HOME}/.nvm/nvm.sh && nvm use --reinstall-packages-from=current
    source ${HOME}/.nvm/nvm.sh && nvm use && yarn install
    
process:
    npx @11ty/eleventy
    
tar: 
  tar -C _site -cvz . > site.tar.gz

publish: 
  hut pages publish -d luciano.laratel.li site.tar.gz
  
deploy:
  just install
  just process
  just tar
  just publish

It's simpler, is nearly instant, and is a lot more flexible.

One downside is that sourcehut disallows tracking scripts, so I can no longer use plausible on this site. That is entirely a vanity thing that I may be able to live without. For the meantime, the convenience of this deployment strategy outweighs my desire for seeing my 17 visitors a month on a slick dashboard.

Some things (e.g. images) are just easier in markdown than trying to wrangle ox-hugo. ↩︎

A mental health toolkit

2023-09-29T15:43:00Z

Over the course of my last regular bout of therapy, my therapist got me to learn about behaviors that he referred to as my mental health toolkit. Some of these behaviors are things we learned are necessary every day (as close as I can get to it) while others are good for times of more difficult mental health challenges than the usual. I'm listing them partly to have them written down for myself, but also in the hopes someone finds a behavior that helps them too. A mental health toolkit can include behaviors that my good friend Mark calls 'psychic anchors' — things you can do to center yourself when you find yourself in need.

For my particular set of mental illnesses, the behaviors I want in my toolkit are those that induce my body to create dopamine (among other regulatory neurotransmitters). Part of the challenge is that some dopamine-creating behaviors don't go about dopamine production in a "sustainable" manner; instead, they cause a dopamine spike. You might feel good, really good, for a bit, but then the crash comes and you might end up feeling worse than before. Another part is that there isn't a prescriptive set of the sustainable behaviors that we're looking for that works for everybody. One person's positive mental health behavior might be another's mental health incident trigger. You've got to experiment.

I should note I'm not an expert: I'm just a guy that works at Computer. I have gone to many (many) years of therapy, though. This is what I've learned works for me, and my layman analysis of what that might mean for my brain.

Another important point is that these behaviors don't always work. Some days you can do everything right and still be in the mud psychologically. One of the many injustices of mental illness. But we must do what we can.

Physical activity #

This is an important one, and one that most people (anecdotally) find great success with. For me, just going on a long walk isn't enough. I need to get my heart rate up! Cardio and weight-lifting are great for this. I'm not as consistent as I should be but I do feel a large difference in my baseline mental health even going just once.

Tidying up #

It was kind of funny to find out how much this helped me. I always dreaded doing household chores (the self-sabotaging nature of ADHD is horrific) but once I realized how much better I feel when our space is neat I started actively seeking out opportunities to pick up. This positive feedback loop is very powerful:

I feel good -> let me clean up a little
     ↑                     ↓
      ↖                   ↙
         Our space is clean

While this one is dangerous:

I feel bad -> tidying up is the worst thing I can imagine
    ↑                       ↓
     ↖                    ↙
       Our space is messy

I wasn't able to really harness the positive feedback loop until I started taking medication that actually worked for me.

Medication #

I spent years in undergrad trying but failing to find medication that worked for me. This type of diagnosis is hard! Eventually I just stopped taking medication altogether and dealt with life raw. It was only when I started seeing my latest therapist that I was able to get a proper diagnosis. After a couple sessions with me, he blew my mind when he said I had "a textbook case of undiagnosed adult ADHD." ADHD medication changed almost everything about how I engage with my life. It can't and won't be a solution for everyone, but if you have a therapist and doctor you trust and they recommend something, I hope it is helpful.

Socializing #

I spent most of my life thinking I was an introvert because I felt awkward in social situations. Some of those feelings were certainly part of the process of coming into my own as a person — finding your way as a teenager and young adult can be hard! Looking back, I now recognize that many of those feelings stemmed from mental illness. That type of feeling can often push you away from socializing.

I learned I'm not an introvert when the government began reducing COVID restrictions and people started congregating again. I've always worked from home, but because I started working professionally in 2021, I had no ability to get out of the house for much of my early professional life. Once I had the ability to do so, I realized I needed to — that social contact was deeply energizing for me in a restorative way. This is different than for my partner, who is a self-described "extroverted-introvert". She feels the need to recharge her social batteries with some alone time after a series of repeated outings.

Getting adequate amounts of socializing is tough, because working from home means I don't really have a "third place".^[1] A potential solution is just paying for one by going to a local coffee shop or buying access to a co-working space. Though I do like to go to our local coffee shop, it isn't a perfect solution because of the ongoing costs, the un-ergonomic work environment, and the difficulties of taking meetings in a public space. Co-working spaces are even more expensive than a daily coffee or two. This is all cheaper than a daily commute, of course.

"Just go out on weekends" is not an end-all solution either. Weekend outings are great, and definitely help! But they yield a big dopamine spike compared to the steady socializing you might get from a co-working space or commuting to an office.^[2] This isn't something I always want to do, either — if my partner wants to stay in to decompress, going out means her sacrificing her social battery recharging time for my well-being (I love her for this, but it's not ideal) or it means not necessarily spending quality weekend time together. It certainly isn't a requirement that we be joined at the hip all weekend, so sometimes I go this route. Going out, of course, costs money. Very few social places remain where you can go without paying for the privilege.

I have contemplated getting an in-person or hybrid job, but the Miami tech scene is not conducive to my doing so. There's a lot of reasons for this that aren't related to this post, so I won't get into them. I would also probably have to buy a car, which seems like nasty business given how much I've enjoyed being car-free for the last couple years.

Journaling #

My boss at my first software job (a great person) taught me this one when I expressed I was overwhelmed with the number of tasks I had to do for a project. He told me to write everything down to get it out of my head. It is shocking how much it helps. My therapist later taught me I should be doing this for my personal things too. Especially in moments where my mental health is poor, journaling helps me to externalize those thoughts.

One of my first girlfriends (my first serious girlfriend) taught me about writing a letter when you're angry at someone, explaining how you feel. Then you shred or burn it. The process of writing down how you feel while addressing it to someone is a calming exercise that helps you settle before talking to the person about how you feel (related: "Never send an email when you're angry.")

Blogging is a similar tool. I'm doing it right now! I think it's better for writing about things I've learned and want to have somewhere than for my thoughts and feelings, especially when I'm in a poor state of mental health — the privacy of the journal page brings a lot of psychological safety. I also don't have to edit out curse words. But having a written, public record of an idea makes you refine the thought in a way that journaling doesn't. You have to pick the right tool for the job.

Taking a shower #

This is the primary "psychic anchor" I learned from Mark. This doesn't refer to a needed shower as part of a regular hygiene schedule, though it can. This refers to the positive effect of taking a step out of the (physical, mental, emotional) space I'm in and taking a quiet couple minutes in the shower. It's really effective and helps a lot for anxiety. This is more of a "quick fix" type strategy than the others, but the dopamine spike is long lasting.

I've been dabbling with cold showers recently, and have really been enjoying it. I can't explain why, but after the initial five seconds of "damn, that's cold!" I feel good. It feels good to do something that involves "mental toughness" but that isn't the only aspect that's pleasant about it.

See wikipedia ↩︎
This is a huge topic on its own; I don't want to derail by getting into the 800 externalities on each side of the WFH debate. ↩︎

Task ordering

2023-07-18T13:21:00Z

Lily and I wear retainers every night. We clean them daily using a regular toothbrush and liquid hand soap. Cleaning these retainers at the end of the day, before bed, is one of my least favorite chores. I dealt with that for a long time! I would delay, put it off, getting in to bed fifteen or twenty minutes later than I would have if I would have just washed the damn things as soon as I finished flossing and brushing my teeth. For a while, I tried cleaning the retainers before the flossing and tooth brushing, but that didn't improve things. After a while I figured out a way to resolve my issue: I now clean our retainers in the morning, immediately after brushing my teeth. It's the easiest thing in the world at that point in the day, but feels impossible at night.

Though my issue with the nighttime retainer cleaning is probably just a classic ADHD Moment, after I got the morning thing going, it got me thinking about task ordering. It's not a novel idea that tasks have orderings. A simple example is a task where you don't have the knowledge to accomplish it yet. You can't accomplish it without getting the knowledge first. Not every ordering is "strict", though — the retainer cleaning saga involved at least three orderings.

floss -> nighttime tooth brushing -> clean retainers -> get in bed

clean retainers -> floss -> nighttime tooth brushing -> get in bed

wake up -> random morning things -> morning tooth brushing -> clean retainers -> [ .. the whole day .. ] -> floss -> nighttime tooth brushing -> get in bed

Once I had noticed that, I realized I'd seen variations of the concept before.

Structured Procrastination is well known, and one of my favorite essays of its kind. It's about ordering your tasks so that there's always something you don't want to do (but have committed to doing) at the "end of the list."

CPUs do out-of-order execution.

The Engineer/Manager Pendulum is about flipping the traditional

Start Career -> IC -> Management -> End Career

order into

Start Career -> IC -> Management -> IC -> Management -> End career
                                    ↑         ↓
                                     ↖_______↙

There are algorithms that utilize amortization to improve their average performance. C++'s std::vector notably uses this technique to achieve (amortized) constant cost when growing in capacity. This is a reordering of tasks from this expensive loop:

Make vector with capacity 1 -> add item -> increase capacity
                                    ↑         ↓
                                     ↖_______↙

To one that minimizes the number of times we increase capacity.

DFA minimization is an algorithm for reducing the number of states in a (deterministic and finite) automaton. We remove states if we can show they're equivalent. Now that I think about it, removal is only sort of like reordering. There's a world of difference between "I clean my retainers in the morning instead of at night" and "I don't clean my retainers".

Project management tools are all about task reordering.

Task reordering isn't a magical solution. I despise washing our coffee pot and can't find a good time of day to do it. Part of the problem is that we don't use it every day; some mornings we have tea, yerba mate, or go out for coffee instead. Maybe if I worked the washing of the coffee pot into a fixed place in my daily routine, I would realize it's in the wrong place in the routine, place it correctly, and then be able to wash it as easily as I clean the retainers.

Maybe part of the problem is that reordering tasks only works for low-friction tasks where the cost to start doing them is low. Some tasks are really four or five tasks dressed in a trench coat disguised as a single task, and it's not always easy to tell that from a todo list. Comparing "cleaning the retainers" to "washing the coffee pot" doesn't convey any of this context. But cleaning the retainers takes two minutes at most, while the coffee pot involves making sure there's space on the dish drying rack, ensuring there's space in the sink, putting on the dishwashing gloves, then washing the four separate pieces of the coffee pot ensemble.

Those first two steps (of the single "washing the coffee pot" task!) might create a cascade of new tasks. If the dishes on the drying rack are wet, we'd have to dry them then put them away. Is the sink full because the dishwasher is running? If that's the case, maybe there isn't space in the sink to wash the coffee pot. This can go on and on.

Getting things done is hard, especially with executive function disorders like ADHD. Thinking about the order of tasks has helped me a great deal.

Using CLJS and shadow-cljs for serverless DigitalOcean Functions

2023-01-12T01:08:00Z

DigitalOcean (DO) Functions: "a serverless computing solution that runs on-demand, enabling you to focus on your code, scale instantly with confidence, and save costs by eliminating the need to maintain servers." Since I'm a fanatic, I would like to write some Clojure for my serverless use case. Because DO offers Node as a runtime, we're able to use ClojureScript to write code and deploy it to the serverless, er, server.

Source code for this blog post is available.

You'll need a DO account. Log in, select the appropriate team, then select Functions on the left-hand column. Create a function namespace and you're ready to go.

Next we need the doctl binary. Here's what I did:

brew install doctl
doctl auth init
doctl serverless install
doctl serverless connect

This gets you authenticated with DO so you can deploy from the command line.

npx create-cljs-project do_serverless
cd do_serverless

Now, let's edit the generated shadow.cljs a bit. Add this map as the value under :builds:

{:core {:target :node-script
         :main core/main
         :output-to "packages/do-serverless/core/core.js"}}

Create src/main/core.cljs and define main in it:

(ns core)

(defn main [])

Create packages/do-serverless/core/package.json with this in it:

{
  "name": "core",
  "version": "1.0.0",
  "description": "CLJS on DO!",
  "main": "core.js",
  "dependencies": {
    "source-map-support": "^0.5.21"
  },
  "devDependencies": {}
}

Lastly, create project.yml:

packages:
  - name: do-serverless
    actions:
      - name: core
        runtime: nodejs:default

OK! Let's see where we're at:

shadow-cljs release core
doctl serverless deploy .

Now we can go to the Functions tab on DO's site and run our function by first going to the function namespace, clicking on the name of the function, and hitting Run. I get this error:

2023-01-12T11:14:08.172732642Z stdout: Action entrypoint 'main' is not a function.

What tha...

At this point, I dug around and found that DO maintains a bunch of sample functions. Going to the Node one, we see this:

exports.main = (args) => { ... }

Huh. OK, so let's do that in our example, src/main/core.cljs:

(ns core)

(defn main [& args]
  (println "hello!")
  (println "args: " args))

(set! js/exports.main main)

And re-build and deploy.

2023-01-12T11:22:14.933096349Z stdout: hello!
2023-01-12T11:22:14.933797937Z stdout: args:  nil
2023-01-12T11:22:14.961195498Z stdout: hello!
2023-01-12T11:22:14.982016323Z stdout: args:  (#js {} ... // output truncated

Ok, so when our function executes, our main gets executed twice. I don't know why this happens. If I run our compiled javascript file locally with node, I only see one execution:

$ node packages/do-serverless/core/core.js
hello!
args:  nil

So, OK, some detail that's above my head. My use case for serverless would, uh, not do well with running everything twice. So, what to do?

Well, we know whatever we tell shadow our main is will get run. And we also know whatever we tell DO our main is (the js/exports.main bit) will also run. Well, I only care about the DO side of things!

(ns core)

(defn my-actual-function [& args]
  (println "hello!")
  (println "args: " args))

(defn main [])

(set! js/exports.main my-actual-function)

2023-01-12T11:28:57.786063804Z stdout: hello!
2023-01-12T11:28:57.793552189Z stdout: args:  (#js {} ... // output truncated

Neat!

Setting up mu4e with iCloud custom domains with Doom Emacs on Arch Linux

2022-04-19T00:32:00Z

Here's how I set up mu4e with Doom Emacs on Arch Linux for my custom domain hosted on iCloud. I'm using mbsync, mu, and msmpt. I originally went with a systemd timer as detailed in the first two sections as recommended in the Arch wiki, but mu4e actually has a built-in functionality to deal with this for us. Note that what I've written here is the minimum I needed to do to actually sync, send, and read emails from emacs. There's a lot more you can do.

Configuration files #

In init.el, under :email

(mu4e +org)

config.el:

(set-email-account! "icloud"
  '((mu4e-sent-folder       . "/icloud/Sent")
    (mu4e-drafts-folder     . "/icloud/Drafts")
    (mu4e-trash-folder      . "/icloud/Trash")
    (mu4e-refile-folder     . "/icloud/Archive")
    (smtpmail-smtp-user     . "lucianolaratelli")
    (mu4e-compose-signature . "\n\nLuciano"))
  t)

(after! mu4e
  (setq sendmail-program (executable-find "msmtp")
        send-mail-function #'smtpmail-send-it
        smtpmail-stream-type 'starttls
        message-sendmail-f-is-evil t
        message-sendmail-extra-arguments '("--read-envelope-from")
        message-send-mail-function #'message-send-mail-with-sendmail))

In $HOME/.config/system/user/mbsync.timer:

[Unit]
Description=Mailbox synchronization timer

[Timer]
OnBootSec=1m
OnUnitActiveSec=5m
Unit=mbsync.service

[Install]
WantedBy=timers.target

$HOME/.config/system/user/mbsync.service:

[Unit]
Description=Mailbox synchronization service

[Service]
Type=oneshot
ExecStart=/usr/bin/mbsync --verbose --all

[Install]
WantedBy=default.target

$HOME/.mbsyncrc:

# imap account information
IMAPAccount icloud
Host imap.mail.me.com
User lucianolaratelli@icloud.com
PassCmd "secret-tool lookup email luciano@laratel.li"
SSLType IMAPS
Port 993

# remote storage (use the imap account specified above)
IMAPStore icloud-remote
Account icloud

# local storage
MaildirStore icloud-local
Path ~/Dropbox/mailbox/icloud/
Inbox ~/Dropbox/mailbox/icloud*Inbox
Subfolders Verbatim

# channel to remote storage
Channel icloud
Far :icloud-remote:
Near :icloud-local:
Patterns *
Create Near
Sync All
Expunge Both
SyncState *

The crucial part when you're using a custom domain hosted on iCloud is to use your iCloud email address instead of the custom one. I thought this was a bug with custom domains (I've run into another one) but I called Apple's support and they told me I needed to use the iCloud email address. You can find this on an iPhone or iPad by going to Settings, tapping on your name up top, and tapping on Name, Phone Numbers, Email. I had @me.com and @icloud.com emails there. I went with the @icloud.com one. Apple's docs on third-party iCloud clients say you can use just the part before the domain, but I included the whole thing just in case. Without further ado, $HOME/.msmptrc:

defaults
tls_trust_file /etc/ssl/certs/ca-certificates.crt
logfile ~/.maildir/msmtp.log
protocol smtp

account icloud
auth on
host smtp.mail.me.com
port 587
protocol smtp
from luciano@laratel.li
user ${ICLOUD_EMAIL_ADDRESS}
passwordeval "secret-tool lookup email luciano@laratel.li"
tls on
tls_starttls on

account default : icloud

I have tls and tls_starttls both on. I think I only need one of these, but I don't want to muck with testing my mail configuration to get a blog post out. You might need one, the other, or both. Exercise for the reader!

I was originally using gpg as described by Erich Grunewald in his very helpful post, but unlocking my yubikey every five minutes became a pain and I figured my login keychain was secure enough for my (unsophisticated) threat model.

Install and enable packages #

yay mbsync
sudo pacman -S msmtp
yay mu mu4e # impossible to find mu otherwise

mkdir -p ~/home/Dropbox/mailbox/icloud
mbsync -Va
mu init -m ~/Dropbox/mailbox --my-address luciano@laratel.li
mu index

systemctl enable --user --now mbsync
systemctl enable --user --now mbsync.timer

doom sync

At this point you can run emacs, <SPC> o m, and get to emailin'!

Moving away from systemd #

This was working fine but I wasn't getting in-emacs notifications when new emails came in, even though mbsync was running on schedule! So I got rid of the mbsync.timer service with systemctl disable --now --user mbsync.timer. I kept mbsync.service so that my email syncs when I log in for the day. Then, in my config.el:

(after! mu4e (setq mu4e-get-mail-command "mbsync --verbose --all"
                   mu4e-update-interval 300))

I restarted emacs and I was good to go.

Resources #

Tecosaur's awe-inspiring config
The already-mentioned post from Erich Grunewald
The Doom Emacs mu4e module documentation (also from Tecosaur)
davemail
This article, though it focuses on macOS

Closing Pull Requests (and Issues) on Github Without Using Github's Web UI

2021-04-04T00:00:00Z

Motivation #

I like to use magit to interact with git. I wanted to figure out how exactly the command-line version of git (which magit is running under the hood) interacts with pull requests on GitHub, because the workflow at my job is to make commits on feature branches, then merge them onto develop following a PR (which provides time for code review.)

Closing a PR (but not issues) #

I'm making the assumption you have a PR to merge a branch test onto a branch develop, with some linked issues. Here's how you close PR when you merge. Note that this doesn't close the associated issues. First, checkout your local copy of develop: b c develop, then and pull any changes from your remote with F origin/develop. Merge test into develop with m m test. Finally, push the changes to the remote: p origin/develop.

Closing the PR and the issues #

To get the issues to close, you must edit the commit message for the merge with m e test after checking out develop. The merge commit must mention each of the issues you wish to close. I usually go for a commit message like this:

Merge branch 'test'

* test:
  commit 1

Closes #14
Closes #16

What doesn't work #

Sadly, you can't use the PR number in the Closes string to close the associated issues. You have to enumerate the issues explicitly. You also can't do Closes #1, #2, #3. Each issue has to have its own closing keyword.

Generating LLVM IR For Classes Using LLVM's C++ API

2020-07-03T20:13:25Z

Introduction #

I'm spending my summer using LLVM to generate code for DJ, the programming language Dr. Ligatti devised for the spring 2020 Compilers course at USF. This post will demonstrate how to use LLVM's C++ API to generate LLVM IR for DJ Code that is similar to this C example:

#include <stdio.h>
#include <stdlib.h>

struct B {
  struct B *a;
  int b;
};

int main() {
  struct B *b = malloc(sizeof(struct B));

  b->b = 2020;
  printf("%d\n", b->b);
}

At this point, you may be wondering why I'm not showing you a C++ example that actually uses a class. Let's try it:

#include <cstdio>

class B {
public:
  int a;
  int method() { return 2; }
};

int main() {
  B *b = new B();
  b->a = 2018;
  printf("%d\n", b->a + b->method());
}

When I started working on generating classes, I noticed something in the LLVM IR for the C++ example:

%class.B = type { i32 }

define linkonce_odr dso_local i32 @_ZN1B6methodEv(%class.B* %0) #4 comdat align 2 {
  %2 = alloca %class.B*, align 8
  store %class.B* %0, %class.B** %2, align 8
  %3 = load %class.B*, %class.B** %2, align 8
  ret i32 2
}

LLVM (and probably everyone else) separates class definitions from method declarations! Realizing this was a crucial moment for me; up until that point, I had been searching endlessly: "how does LLVM generate code for classes", "LLVM IR class code gen", "LLVM class generation". This message from the LLVM-dev mailing list pushed me to think in terms of how LLVM lowers C to its IR, instead of C++. I realized that meant I should be looking for struct methods, which were not hard to find, and was finally able to get started.

Learning From Clang #

My first step when trying to determine what LLVM is doing is to first use clang to generate some LLVM IR for me, by running clang -S -O0 -emit-llvm example.c. This outputs the LLVM IR to a file example.ll, which will let us see exactly what's happening by asking clang to not do any optimizations. Here's the IR for the C example above, cleaned up a bit for brevity:

%struct.B = type { %struct.B*, i32 }

define dso_local i32 @main() #0 {
  %1 = alloca %struct.B*, align 8
  %2 = call noalias i8* @malloc(i64 16) #3
  %3 = bitcast i8* %2 to %struct.B*
  store %struct.B* %3, %struct.B** %1, align 8
  %4 = load %struct.B*, %struct.B** %1, align 8
  %5 = getelementptr inbounds %struct.B, %struct.B* %4, i32 0, i32 1
  store i32 2020, i32* %5, align 8
  %6 = load %struct.B*, %struct.B** %1, align 8
  %7 = getelementptr inbounds %struct.B, %struct.B* %6, i32 0, i32 1
  %8 = load i32, i32* %7, align 8
  %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %8)
  ret i32 0
}

Let's walk through what's happening here.

The struct declaration is in global scope, consisting of its name and the types that make it up. We create a variable of pointer to the struct using alloca. malloc allocates space for the pointer; the pointer returned from malloc gets cast to the struct type and ends up in the variable we declared. Lastly, the getelementptr (GEP) instruction gets us a pointer to a requested field (the i32 1 at the end there is getting the 1th field in the struct).

With these steps acting as a guide, let's build an example program that will generate equivalent IR from scratch.

Implementation #

We'll be building a file example.cpp step-by-step. I haven't included snippets that involve declaring main or printf, since we've seen those before; find those in the full code listing below.

After including the requisite LLVM headers and declaring any data structures, we start by allocating a struct using StructType::create(). After this, we tell LLVM what members compose this struct; in our case, we have a pointer of the struct's type and an integer. PointerType::getUnqual uses the default address space; we could just as easily use PointerType::get() by getting the address space using PointerType::getAddressSpace(), or passing 0 to it for the default address space.

std::map<std::string, StructType *> allocatedClasses;
allocatedClasses["B"] = StructType::create(TheContext, "B");
std::vector<Type *> structMembers = {
    PointerType::getUnqual(allocatedClasses["B"]),
    Type::getInt32Ty(TheContext)};
allocatedClasses["B"]->setBody(structMembers);

Once we have a pointer to the struct's type, we can create a variable of it:

static std::map<std::string, AllocaInst *> NamedValues;
NamedValues["b"] = Builder.CreateAlloca(
    PointerType::getUnqual(allocatedClasses["B"]), NamedValues["b"]);

Now we can allocate space for a struct using CallInst::CreateMalloc(). Using Builder.Insert() is crucial here. You'll notice it's hidden in the Builder.CreateStore() call. Some LLVM API methods that return Instructions don't insert them for you!

auto typeSize = ConstantExpr::getSizeOf(allocatedClasses["B"]);
auto I = CallInst::CreateMalloc(
    Builder.GetInsertBlock(), Type::getInt64Ty(TheContext),
    allocatedClasses["B"], typeSize, nullptr, nullptr, "");
Builder.CreateStore(Builder.Insert(I), NamedValues["b"]);

Once we've allocated space, we can assign to it using the infamous GEP instruction. GEP does pointer arithmetic for us. The first zero is always required; it's dereferencing the struct pointer we get from allocatedClasses.

std::vector<Value *> elementIndex = {
    ConstantInt::get(TheContext, APInt(32, 0)),
    ConstantInt::get(TheContext, APInt(32, 1))};
Value *GEP =
    Builder.CreateGEP(Builder.CreateLoad(NamedValues["b"]), elementIndex);

Builder.CreateStore(ConstantInt::get(TheContext, APInt(32, 2020)), GEP);

Now that we've stored to the variable, we can read from it, using GEP again. We reuse elementIndex from above.

GEP = Builder.CreateGEP(Builder.CreateLoad(NamedValues["b"]), elementIndex);

auto loaded = Builder.CreateLoad(GEP);

And we're done! At this point we proceed with the printf calls as before, using loaded as the second argument. You can check out the full IR output of this program down below.

Caveats #

There are some differences between the LLVM IR generated by our example and clang's. My struct type is just B; it seems they've prepended struct. to their type name (they appear to do this for class types as well.) When clang allocates, they always align. I haven't taken the time to learn how to do this yet, so the example does not align. Struct size computation is not done in the clang-generated IR; mine does the computation at runtime.

Beyond these, I am pretty happy with how similar they turned out! This shows how powerful LLVM's API is.

Changelog #

2020-07-27 #

I updated the read and store operations to use IRBuilder::CreateGEP instead of using GetElementPtrInst::Create and then IRBuilder::Insert as I did originally. This is much cleaner.

Full Code Listing #

C++ Code #

To compile and run this example, save it as example.cpp and then run:

clang++ `llvm-config --cxxflags --ldflags --system-libs --libs all` example.cpp
./a.out > example.ll
clang example.ll
./a.out

I used clang version 10.0.0-4ubuntu1 (on x86) with version 10.0.0 of the LLVM libraries. You can check with clang --version and llvm-config --version.

#include "llvm/ADT/APInt.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/raw_ostream.h"
#include <map>
#include <memory>
#include <vector>

using namespace llvm;

static LLVMContext TheContext; static IRBuilder<> Builder(TheContext);

int main() {
  static std::unique_ptr<Module> TheModule =
      std::make_unique<Module>("example.cpp", TheContext);

  std::map<std::string, StructType *> allocatedClasses;
  allocatedClasses["B"] = StructType::create(TheContext, "B");
  std::vector<Type *> structMembers = {
      PointerType::getUnqual(allocatedClasses["B"]),
      Type::getInt32Ty(TheContext)};
  allocatedClasses["B"]->setBody(structMembers);

  std::vector<Type *> args;
  args.push_back(Type::getInt8PtrTy(TheContext));
  FunctionType *printfType =
      FunctionType::get(Builder.getInt32Ty(), args, true);
  Function::Create(printfType, Function::ExternalLinkage, "printf",
                   TheModule.get());

  FunctionType *mainType = FunctionType::get(Builder.getInt32Ty(), false);
  Function *main = Function::Create(mainType, Function::ExternalLinkage, "main",
                                    TheModule.get());
  BasicBlock *entry = BasicBlock::Create(TheContext, "entry", main);
  Builder.SetInsertPoint(entry);

  static std::map<std::string, AllocaInst *> NamedValues;
  NamedValues["b"] = Builder.CreateAlloca(
      PointerType::getUnqual(allocatedClasses["B"]), NamedValues["b"]);

  auto typeSize = ConstantExpr::getSizeOf(allocatedClasses["B"]);
  auto I = CallInst::CreateMalloc(
      Builder.GetInsertBlock(), Type::getInt64Ty(TheContext),
      allocatedClasses["B"], typeSize, nullptr, nullptr, "");
  Builder.CreateStore(Builder.Insert(I), NamedValues["b"]);

  std::vector<Value *> elementIndex = {
      ConstantInt::get(TheContext, APInt(32, 0)),
      ConstantInt::get(TheContext, APInt(32, 1))};
  Value *GEP =
      Builder.CreateGEP(Builder.CreateLoad(NamedValues["b"]), elementIndex);

  Builder.CreateStore(ConstantInt::get(TheContext, APInt(32, 2020)), GEP);

  GEP = Builder.CreateGEP(Builder.CreateLoad(NamedValues["b"]), elementIndex);

  auto loaded = Builder.CreateLoad(GEP);

  /*Set up printf arguments*/
  std::vector<Value *> printArgs;
  Value *formatStr = Builder.CreateGlobalStringPtr("%d\n");
  printArgs.push_back(formatStr);
  printArgs.push_back(loaded);
  Builder.CreateCall(TheModule->getFunction("printf"), printArgs);
  /*return value for `main`*/
  Builder.CreateRet(ConstantInt::get(TheContext, APInt(32, 0)));
  /*Emit the LLVM IR to the console*/
  TheModule->print(outs(), nullptr);
}

LLVM IR #

; ModuleID = 'example.cpp'
source_filename = "example.cpp"

%B = type { %B*, i32 }

@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1

declare i32 @printf(i8*, ...)

define i32 @main() {
entry:
  %0 = alloca %B*
  %malloccall = tail call i8* @malloc(i64 ptrtoint (%B* getelementptr (%B, %B* null, i32 1) to i64))
  %1 = bitcast i8* %malloccall to %B*
  store %B* %1, %B** %0
  %2 = load %B*, %B** %0
  %3 = getelementptr %B, %B* %2, i32 0, i32 1
  store i32 2020, i32* %3
  %4 = load %B*, %B** %0
  %5 = getelementptr %B, %B* %4, i32 0, i32 1
  %6 = load i32, i32* %5
  %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @0, i32 0, i32 0), i32 %6)
  ret i32 0
}

declare noalias i8* @malloc(i64)

Generating Calls to scanf From LLVM IR

2020-06-15T15:41:03Z

Introduction #

I'm spending my summer using LLVM to generate code for DJ, the programming language Dr. Ligatti devised for the spring 2020 Compilers course at USF.

DJ provides a readNat function, which reads a natural number from the console and returns its value. In the course, this function was readily available in the instruction set our compilers generated (this was also devised by Dr. Ligatti.) Because readNat is in this sense provided by the runtime, I had to make it available in some fashion from my LLVM-backed compiler. While this function is similar enough to printNat, it presents some added difficulty. This is due to my choice to use scanf as readNat's backend, which requires a memory location in which to store the value.

The example below generates IR which is equivalent to the pseudocode printNat(readNat()). This way, we can verify that the read succeeded!

The code #

#include "llvm/ADT/APInt.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/raw_ostream.h"
#include <memory>
#include <vector>

using namespace llvm;

static LLVMContext TheContext;
static IRBuilder<> Builder(TheContext);

int main() {
  static std::unique_ptr<Module> TheModule;

  TheModule = std::make_unique<Module>("inputFile", TheContext);

  /*set up the function prototype for printf and scanf*/
  std::vector<Type *> runTimeFuncArgs = {Type::getInt8PtrTy(TheContext)};
  /*true specifies the function as variadic*/
  FunctionType *runTimeFuncType =
      FunctionType::get(Builder.getInt32Ty(), runTimeFuncArgs, true);

  Function::Create(runTimeFuncType, Function::ExternalLinkage, "printf",
                   TheModule.get());
  Function::Create(runTimeFuncType, Function::ExternalLinkage, "scanf",
                   TheModule.get());

  /*set up and declare main; begin inserting into it*/
  FunctionType *mainType = FunctionType::get(Builder.getInt32Ty(), false);
  Function *main = Function::Create(mainType, Function::ExternalLinkage, "main",
                                    TheModule.get());
  BasicBlock *entry = BasicBlock::Create(TheContext, "entry", main);
  Builder.SetInsertPoint(entry);

  Builder.GetInsertBlock()->getParent();
  /*set up scanf arguments*/
  Value *scanfFormat = Builder.CreateGlobalStringPtr("%u");
  AllocaInst *Alloca =
      Builder.CreateAlloca(Type::getInt32Ty(TheContext), nullptr, "temp");
  std::vector<Value *> scanfArgs = {scanfFormat, Alloca};

  Function *theScanf = TheModule->getFunction("scanf");
  Builder.CreateCall(theScanf, scanfArgs);

  /*set up printf arguments, loading the value that was read in from Alloca*/
  Function *thePrintf = TheModule->getFunction("printf");
  Value *printfFormat = Builder.CreateGlobalStringPtr("%u\n");
  std::vector<Value *> printfArgs = {printfFormat, Builder.CreateLoad(Alloca)};
  Builder.CreateCall(thePrintf, printfArgs);

  /*return value for `main`*/
  Builder.CreateRet(Builder.CreateLoad(Alloca));
  /*Emit the LLVM IR to the console*/
  TheModule->print(outs(), nullptr);
}

The main takeaway here is the use of the CreateAlloca method to create a named value to store the value that scanf reads in.

Compiling #

I am using clang/llvm versions 10.0.0 at the time of this writing. I compile the above as clang++ `llvm-config --cxxflags --ldflags --system-libs --libs all` test.cpp. When run, it generates the following IR:

; ModuleID = 'inputFile'
source_filename = "inputFile"

@0 = private unnamed_addr constant [3 x i8] c"%u\00", align 1
@1 = private unnamed_addr constant [4 x i8] c"%u\0A\00", align 1

declare i32 @printf(i8*, ...)

declare i32 @scanf(i8*, ...)

define i32 @main() {
entry:
  %temp = alloca i32
  %0 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @0, i32 0, i32 0), i32* %temp)
  %1 = load i32, i32* %temp
  %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @1, i32 0, i32 0), i32 %1)
  %3 = load i32, i32* %temp
  ret i32 %3
}

Just like last time, we throw the output IR into a file test.ll and compile it with clang:

$ clang test.ll
warning: overriding the module target triple with x86_64-pc-linux-gnu [-Woverride-module]
1 warning generated.

$ ./a.out
4
4

Considerations #

scanf is generally considered to be unsafe.

Here's what happens when we feed our example a string:

$ ./a.out
fasd
0

And some floats:

$ ./a.out
2.3333333
2

$ ./a.out
2.666666666666667
2

You'll also notice the format strings for printf and scanf differ by a newline. I noticed that using the printf format string (with the newline) for scanf resulted in the following behavior:

$ ./a.out
2 # normal readNat input
3 # entered by me
2 # printNat output

It's been a while since I'd used scanf (it's unsafe!) so I had forgotten how it deals with trailing whitespace.

A solution to this would be to implement readNat directly in the compiler, as suggested by the LLVM tutorial. This would make it simple to implement error checking in readNat. I have not done this myself; when I attempted to follow their suggestion I ran into problems calling the function from the IR and opted to find an alternate method.

Generating Calls to printf From LLVM IR

2020-06-03T02:22:22Z

Introduction #

I'm spending my summer using LLVM to generate code for DJ, the programming language Dr. Ligatti devised for the spring 2020 Compilers course at USF. DJ provides a printNat function, which prints a natural number to the console. In the course, this function was readily available in the instruction set our compilers generated (this was also devised by Dr. Ligatti.) Because printNat is in this sense provided by the runtime, I had to make it available in some fashion from my LLVM-backed compiler. I wasn't able to succeed in doing this the way the LLVM Kaleidoscope tutorial suggests, so after some research, I implemented the functionality as in the example below.

The code #

#include "llvm/ADT/APInt.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/raw_ostream.h"
#include <memory>
#include <vector>

using namespace llvm;

static LLVMContext TheContext;
static IRBuilder<> Builder(TheContext);

int main() {
  static std::unique_ptr<Module> TheModule;
  TheModule = std::make_unique<Module>("inputFile", TheContext);
  /*Declare that printf exists and has signature int (i8*, ...)**/
  std::vector<Type *> args;
  args.push_back(Type::getInt8PtrTy(TheContext));
  /*`true` specifies the function as variadic*/
  FunctionType *printfType =
      FunctionType::get(Builder.getInt32Ty(), args, true);
  Function::Create(printfType, Function::ExternalLinkage, "printf",
                   TheModule.get());
  /*begin codegen for `main`*/
  FunctionType *mainType = FunctionType::get(Builder.getInt32Ty(), false);
  Function *main = Function::Create(mainType, Function::ExternalLinkage, "main",
                                    TheModule.get());
  BasicBlock *entry = BasicBlock::Create(TheContext, "entry", main);
  Builder.SetInsertPoint(entry);
  /*Set up printf arguments*/
  std::vector<Value *> printArgs;
  Value *formatStr = Builder.CreateGlobalStringPtr("%d\n");
  printArgs.push_back(formatStr);
  /*We will be printing "20"*/
  printArgs.push_back(ConstantInt::get(TheContext, APInt(32, 20)));
  Builder.CreateCall(TheModule->getFunction("printf"), printArgs);
  /*return value for `main`*/
  Builder.CreateRet(ConstantInt::get(TheContext, APInt(32, 0)));
  /*Emit the LLVM IR to the console*/
  TheModule->print(outs(), nullptr);
}

Compiling #

; ModuleID = 'inputFile'
source_filename = "inputFile"

@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1

declare i32 @printf(i8\*, ...)

define i32 @main() {
entry:
%0 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]\* @0, i32 0, i32 0), i32 20)
ret i32 0
}

Instead of writing a whole output pass (see here for that,) we can throw the output IR into a file test.ll and compile it with clang:

$ clang test.ll
warning: overriding the module target triple with x86_64-pc-linux-gnu [-Woverride-module]
1 warning generated.
$ ./a.out
20

A caveat and potential solution #

Of course, a program won't only have one print statement in it! Using the example above as part of a codegen method for a print statement node in your AST will result in having a new constant declared for each print statement in the program:

...
@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@1 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@2 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@3 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
...

I haven't resolved this issue in my own code base yet. I did attempt having the formatStr variable be global, but this was causing seg faults in the CreateGlobalStringPtr method. It seems like the constmerge transform pass handles this, but I have yet to implement any passes in my compiler beyond the one that emits object code.

Calculating System Velocities Using LAMMPS

2018-07-19T00:09:11Z

For the water research I've been doing, it is useful to get the velocity autocorrelation function, which gives the density of states of the system. Here is how I ended up doing it:

compute 1 all property/atom vx vy vz

compute s_v_x all reduce sum vx
variable vel_x equal c_s_v_x
fix print_vel_x all print 1 "$(step) ${vel_x}" file "vel_x.txt" screen no

compute s_v_y all reduce sum vy
variable vel_y equal c_s_v_y
fix print_vel_y all print 1 "$(step) ${vel_y}" file "vel_y.tyt" screen no

compute s_v_z all reduce sum vz
variable vel_z equal c_s_v_z
fix print_vel_z all print 1 "$(step) ${vel_z}" file "vel_z.tzt" screen no

One of the things that always trips me up in LAMMPS is the difference between using variables created by the user (e.g. vel_x above) and using variables LAMMPS provides (e.g. step.) When using them in, for example, a fix print, user-created variables must be wrapped in curly brackets, while the LAMMPS-provided variables must be wrapped in parens.

Calculating System Dipoles Using LAMMPS

2018-07-10T15:23:05Z

As part of my research in Philadelphia with Matt, we needed to calculate system dipoles using LAMMPS. We were having a lot of trouble using the provided dipole/chunk compute so we went about figuring it out another way instead. This was a pain to do (could not find it anywhere on the internet, probably because everyone else is smart enough to figure out how to use dipole/chunk) so here is how we ended up doing it:

variable dipole_x atom x*q
variable dipole_y atom y*q
variable dipole_z atom z*q
#systemDipole_x
compute sD_x all reduce sum v_dipole_x
compute sD_y all reduce sum v_dipole_y
compute sD_z all reduce sum v_dipole_z

#just in case you need only one dipole...
#variable system_dipole_x equal c_sD_x
variable total_system_dipole equal sqrt((c_sD_x*c_sD_x)+(c_sD_y*c_sD_y)+(c_sD_z*c_sD_z))

fix get_total_system_dipole all print 1 "$(step) ${total_system_dipole}" file "dipole.txt"