knlb

Writing is hard, but what I was trying to say is that it's okay to just send it as long as you're doing it consciously and intentionally (and I do that frequently enough); but if it's not an explicit choice that can be problematic.

Yeah, definitely. Also at times I've vibecoded successive iterations with better designs after seeing where the first ones collapsed -- the agents do a good job with a template and need much less prompting for the successive versions.

I had been holding off on testing out mojo till it was open sourced, and started picking it up this week.

So far I've been enjoying the language (pythonic, comptime, tile support) and plan to spend time using it to work with gpus to learn more, the puzzles are also pretty cool.

I recently started a section on my personal site for absolutely minimal and simple microblogging that I could Ctrl-F through: https://knlb.dev/scribbles/ -- I should probably give this a shot.

https://knlb.dev -- new digital garden; https://explog.in -- previous blog, leaving it as is for now though I expect I'll slowly absorb it into the garden.

> Do you debug JVM bytecode? V8's internals? No. You debug at your abstraction layer

In the fullness of time, you end up having to. Or at least I have. Which is why I always dislike additional layers and transforms at this point.

(eg. when I think about react native on android, I hear "now I'll have to be excellent at react/javascript and android/java/kotlin and C++ to be able to debug the bridge; not that "I can get away with just javascript".)

I've never really had the patience to fiddle a lot of with the hardware but have always wanted to use e-ink screens for working, specially on the move. (Tried the hacks for remarkable pro with a friend's recommendations, ultimately never kept using it).

The boox palma with android + (obsidian | termux + tailscale) when I need it has actually worked out well for me for writing | programming with a portable keyboard (nuphy). I even did this year's Advent of Code on it. (https://knlb.dev/logs/aoc25 has some photos)

I used to be scared of Awk, and then I read through the appendix / chapters of "More Programming Pearls" (https://www.amazon.com/More-Programming-Pearls-Confessions-C...) and it became a much easier to reason about language.

The structure can be a bit confusing if you've only seen one liners because it has a lot of defaults that kick in when not specified.

The pleasant surprise from learning to use awk was that bpftrace suddenly became much more understandable and easier to write as well, because it's partially inspired by awk.

The whole post feels like it was edited/modified by ChatGPT; `What we opened — in English, not a changelog`, `Why it matters (no fluff):`, `We are big believers in notebooks — full stop` are patterns that always make me feel like an LLM wrote it (sentence followed by a marketing qualifier).

I really liked Deepnote the product when I last used it, but the post definitely feels off.

Perfetto is definitely one of my favorite tools to use ever, thank you for working on it!

My personal favorite tool I've built this year is to dynamically generate a trace from a sql query, and allow quickly combining queries. Something like `SELECT timestamp, track, name, ` etc. where column names get transformed to packets automatically.

That way I can overlay multiple py-spy traces and instrumentation into a dynamically implemented generated perfetto trace, loaded into a perfetto iframe using the ping/pong mechanism at https://perfetto.dev/docs/visualization/deep-linking-to-perf....

Thanks for the post, this is pretty cool!

I feel like I've seen Cupti have fairly high overhead depending on the cuda version, but I'm not very confident -- did you happen to benchmark different workloads with cupti on/off?

---

If you're taking feature requests: a way to subscribe to -- and get tracebacks for -- cuda context creation would be very useful; I've definitely been surprised by finding processes on the wrong gpu and being easily able to figure out where they came from would be great.

I did a hack by using LD_PRELOAD to subscribe/publish the event, but never really followed through on getting the python stack trace.

Another vote for the Glove 80: I used the Kinesis Advantage 2 for 10 years (after a few initial signs of finger pain developing), then tried the new 360; and recently got the glove 80 so I could easily travel with it and fell in love with the keyboard.

It definitely doesn't feel as solid as the Kinesis or ergodox (which I used intermittently as well) but is the most comfortable keyboard I've used, the LEDs are actually useful (for showing battery life and bluetooth connections), and there are enough keys (including function keys); I don't like having to reason about layers at all, I want to be able to smoothly transition to my laptop's keyboard in a pinch).

Not the latest one just yet, I still want to play with it a lot more / bake in some more features -- but it's also terribly simple and doesn't do much at the moment.

The org mode one is at https://explog.in/config.html.

My current personal site (https://knlb.dev) is built with a single 500 line python file that starts with

  #!/usr/bin/env -S uv run --script
  # -*- mode: python -*-
  #
  # /// script
  # requires-python = ">=3.12"
  # dependencies = [
  #    "pyyaml", "flask", "markdown-it-py",
  #    "linkify-it-py", "mdit-py-plugins"
  # ]
  # ///

The HTML templates & CSS are baked into the file which is why it's so long. flask so that I can have a live view locally while writing new notes.

uv's easy dependency definition really made it much easier to manage these. My previous site was org exported to html and took much more effort.

(With the conceit that the website is a "notebook" I call this file "bind").

My similar trick is to rely on the tmux scrollback and pipe tokenized output into zsh so I can easily autocomplete against anything on the visible tmux screen

https://www.threads.com/@kunalb_/post/C6ZQIOVpwMd https://gist.github.com/kunalb/abfe5757e89ffba1cf3959c9543d9...

which has been really useful.

I wrote a fairly similar take on this a few years ago (without having read the original book mentioned here) -- https://explog.in/notes/debugging.html

Julia Evans also has a very nice zine on debugging: https://wizardzines.com/zines/debugging-guide/

Congratulations -- and thank you! I've been playing with Hy on and off (tried to do transformers with it, and then released https://github.com/kunalb/orphism written in hy). Time to pick it up again and take it for a spin

I have a small python (hy) package which extends the idea to horizon charts https://github.com/kunalb/orphism

Iain M Banks, the culture series touches on immortality and choosing / not choosing it. [edit: didn't read carefully enough. Sadly, he won't be available for interviewing]

Also the little schemer series, which just expect you to work things out by hand.

I just use emacs + org mode -> org-publish to generate my site [1] from org-mode with some customizations; it's been the most flexible and fun way to build a site I've had across all my attempts so far, particularly given that I can go meta and also publish the htmlized raw org files at the same time [2].

[1] Publishing config: http://explog.in/config.html [2] Org Source: http://explog.in/config.org.html