The quality of the modern software craftsperson can be calculated using the following formula:

$$Q propto frac{(stars + downloads)}{sloc}$$Q∝sloc(stars+downloads)​

What this shows is we need to maximise engagement relative to the amount of code written in order to be recognised as a superstar coder, the fabled 10x developer.

By maximising our quality quotient, we ensure a guaranteed place at the next venture-backed unicorn, where one’s fraction of a point will yield at least double your annual salary in just 10+ years of daily standups, years waiting on CI, a couple of paltry promotions and a minimum four rounds of dilution.

Taste is everything

As we all know, code is a liability that brings with it tedious tests and troublesome tooling. Minor discomforts that ensure the introduction of microservices, event sourcing, and ultimately a large rewrite.

As connoisseurs, we’ll elect for an elegant and succinct language to keep SLOC to a minimum, without having to resort to golfing.

Any language that insists on automated, invisible insertion of semicolons, or that promotes verbosity is immediately out.

APL-family languages rank highly on both expressivity and power, but no one’s going to believe your hexadecimal-to-RGB colour conversion library written in Q has legitimately been downloaded a thousand times this week.

The obvious choice is a Lisp, and to firmly plant a foot in both the highly academic, left-leaning libertarian camp and hyper-corporate, capitalist, FTSE-ranking enterprise, we’ll be going with a Lisp that runs on your favourite flavours of both Java and JavaScript Virtual Machines. That’s right, the equally hip and stable, Clojure.

Silicon minions

While the days of free compute subsidised by venture capital are largely behind us, Microsoft do still give away a few minutes of compute each month to all GitHub users, so it’s possible for us to demonstrate our technical chops by infating those all important numbers with a little bit of automation. 🐣🐣🪨

If you don’t already have a couple of small packages that do one thing well, you might fork an established project, rebrand it, and improve it by adding a code of conduct or helpfully reformatting the ugly source code using Prettier. The Clojure codebase itself could be a good starting point for taking your career to the moon.

I’ll use a couple of small libraries I wrote some years ago to propel my rocketship.

• invetica/media-types
• invetica/spec
• invetica/uri

Our language of choice relies on a package repository owned by Microsoft GitHub. Clojars provides us with handy little badges we can embed in our webpages but these don’t include the all important counters, so we’ll have to team up with Shields.io and relax our CSP accordingly.

We’ll be making use of GitHub’s scheduled workflows to fetch our unduly ignored packages on the hour. You could choose to do so more frequently, or on a more arcane schedule but who’s got time for cron syntax when you can just sleep.

As this code executes on the backend rather than in the browser, it is written in YAML.

on:
  workflow_dispatch:

  schedule:
    - cron: '0 * * * *'

jobs:
  prepare:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Prepare java
        uses: actions/setup-java@v3
        with:
          distribution: 'zulu'
          java-version: '8'

      - name: Install clojure tools
        uses: DeLaGuardo/setup-clojure@11.0
        with:
          cli: latest

      - name: Deep breath
        run: bin/delay

      - name: Prepare a selection of delightful dependencies
        run: bin/prepare

At this point you’re probably wondering why my steps are so poetically named. Do not forget that code is poetry, and that markup languages like YAML inevitably evolve into Turing-complete interpolated programming environments. Leverage enjambment to pay homage to punch cards.

To fly under the radar of other engineers wary of our meteori