dwight drops a cat named garbage into vance refrigeration

Some convenient clipboard-based conversions

I added two clipboard-based conversions to clawe recently. Maybe the beginning of a pattern?

(defn clipboard-org->markdown
  ([] (clipboard-org->markdown nil))
  ([_]
   (->> (clipboard/get-clip "clipboard")
        string/split-lines
        org-crud.parse/parse-lines
        org-crud.markdown/item->md-body
        (string/join "\n")
        clipboard/set-clip)))

(defcom/defcom convert-clipboard-org-to-markdown clipboard-org->markdown)

(defn clipboard-json->edn
  ([] (clipboard-json->edn nil))
  ([_]
   (let [json-blob (-> (clipboard/get-clip "clipboard") (string/trim))
         ;; for now assumes we're grabbing a partial object, so a leading
         ;; string means we'll wrap the whole thing as an object
         json-blob (if (re-seq #"^\"" json-blob)
                     (str "{" json-blob "}")
                     json-blob)]
     (-> json-blob
          (json/parse-string true)
          str
          clipboard/set-clip))))

(defcom/defcom convert-clipboard-json-to-edn clipboard-json->edn)

These convert org to markdown, and json to edn. You first copy the content to your clipboard, then invoke the command via rofi.

> I do this via clawe's m-x command, which is so-named as a metaphor to emacs' > extended command style.

The commands convert the content and place it back on your clipboard.

Reach out if you're trying to use these - at the moment they are tied somewhat strongly to some ralphie and org-crud namespaces, but these could be broken out into smaller tools if there's interest.

The org->markdown use-case is primarily for copy-pasting org into slack or github discussions.

The json->edn use-case is copying vega, vega-lite, or other json-based examples into clojure code.

More cider-eval-sexp-up-to-point magic

More interactive programming wins, and extending on a cider TIL a few weeks ago, in which I learned that you can partially evaluate threads: you can partially evaluate more than just threads!

I was working through a somewhat complicated bit in a let block, when it occurred to me there's no reason why I shouldn't evaluate the expression up to the point - and the same command ( cider-eval-sexp-up-to-point ) just-worked!

(defn clipboard-json->edn
  ([] (clipboard-json->edn nil))
  ([_]
   (let [json-blob (-> (clipboard/get-clip "clipboard") (string/trim))
         json-blob (if (re-seq #"^\"" json-blob)
                     (str "{" json-blob "}")
                     json-blob)]
     json-blob

     ;; | <--- point right here, eval and now we can cider-inspect `json-blob`

     (->> json-blob
          (#(json/parse-string % true))
          str
          clipboard/set-clip))))

This is one of the major benefits of lisp -based languages - the regularity of the forms make this kind of thing simple to implement (from a tooling perspective) and easy for users to work with. Once you understand it in one case, the rest just make sense.

Publishing some core workspace notes

Some of these are farther along than others!

These workspace files are living files, and typically are the first target for docs, ideas, progress, and related file links.

Feel free to peruse and let me know what you think!

• Clawe
• Ralphie
• Doctor
• Dino
• russmatney/org-crud

Publishing link targets

There are a number of files that I link to that are somewhat ambiguous - should it be a whole file, or a tag? Examples include godot.org and clojure.org. When writing a daily note, should I tag it as godot-related? Or should I link it to the godot file? I tend to blur that line when working in org.

There are benefits to pulling everything together - it helps to deduplicate and see where your ideas can be combined. Pulling things into the same file makes it easy to munge everything into a minimal set of ideas.

Huge files have their problems too tho, as do heirarchies. Tags and links help to break that down - your daily item or one-off idea can belong to multiple buckets.

Part of the goal of this org-blog journey is to surface and connect these things together - pulling in items with the same tags, and getting a look at backlinks.

I think these posts are going to be a bit of a mess for a while. Getting them surfaced is a step forward for me - it's a step toward review, and figuring out if there's anything of value in here. Clean up will be slow, but we'll get there. Let the games begin!

• clojure
• emacs
• godot

Others published, not linked here - more to come!

Publishing some favorite lists

> As a tool to help writing a novel in a month, make a list of things you love in novels. It also says to make a list of things you hate....

The point is, this is a great resource for yourself, especially when you get stuck and aren't sure what comes next.

I enjoy capture for collecting ideas - these lists have built up (and will continue to build), and I like to think they're helping me find my voice in game design and development.

• things i love in games
• games i love

kinematic body as child, not root component

I've never really done this, but it seems like it should be a reasonable approach?

finally figured out an missing instance method bug