Gwendolyn James

Sun, 09 Nov 2025 20:23:17 -0700

I’ve been learning about web development using svelte. It’s cool wrapping my head around this stuff finally. It’s been nice having the experience of learning new debugger tools and whatnot; it’s always a combination of frustration and sudden moments of enlightenment.

I spent the last week on vacation from work. I’ve been growing a decent sized piece of infrastructure at my day job for years now, and a small piece at home that I use to learn lessons and tease myself that I can go independent some day. I spent the week cleaning up old ansible and making it all uniform, really investing in justfile tasks to drive entire workflows from one tool, building out my vibe-coded small business idea, that sort of stuff.

Seeing how much better it feels to have nothing in between the workflows I want to activate and my mind, that I understand every codebase really well right now, it’s such a freeing lack of friction. I improved all my build times down from 2 1/2 minutes-ish to under 30 seconds, and it feels amazing knowing I get all my feedback that rapidly.

I dunno, it feels like lessons to bring over to dayjob. I always miss the feeling of my personal projects when I’m at work; I move so much more fluidly in this environment, with better tools. The degree of friction getting decisions made at work is aggravating at times: I have to work with teams that are backlogged enough that it can be weeks before a job is unblocked.

I should maybe try and design our workflows to insulate us a bit more, but it feels like the wrong solution. The right solution is always going to be to tackle friction head-on, but god damn is it tiring.

all it cost me was not writing a line of it

Sun, 19 Oct 2025 08:42:21 -0700

Learning has always been hard

I’ve always found that learning a new skill takes time and effort. It helps that I normally learn things that I enjoy, but even so it’s tough to learn a little more calculus, start learning javascript, tackle learning Spanish or French.

I find that letting the grind be hard, being okay with slow progress, this is a mindset game that sometimes works and sometimes doesn’t.

Getting to 70% Is Easy Now

The last time I learned a new language well enough to feel confident every day in it, it was golang.

I’ve been learning svelte recently. It’s so much harder, not because Svelte’s bad or anything but because I can ask Claude for a “code sample” and the next thing I know I’m eight commits down and have most of what I want and the part that’s left is both hard to get Claude to build and hard for my own skills to approach because I haven’t trained them.

Learning is 95% Doing

I have a tool that genuinely makes it easy to remove the “doing” part from learning a new framework. I feel like I feel when I eat cheap carbs: I know they will make me put on weight, I know that’s basically bad for me, I know they’re delicious in a way that fibrous greens aren’t.

Am I putting on brain-fat? Getting brain-weak and brain-lazy? I know I’ve seen smart people, much smarter than me, who I’d charactertise today as brain-lazy because they’ve started mistaking conversations with ChatGPT for thinking through a problem, started sharing unedited conversations and trying to persuade me they’re a whitepaper.

In Praise of a Shitty First Draft

I think the book “bird by bird” is the one that contains the “In praise of a shitty first draft” essay. It talks you through acknowledging internally that writing something good isn’t the hard part, it’s finishing anything at all. The productivity people seem to get to the same idea: you should lower your standards for your first attempt because it’s hard enough just to finish.

My first attempt at a sveltekit app works and does 70% of what I want 70% of the time, and all it cost me was that I didn’t write a line of it. That last 30% is a hard wall to climb when my skills haven’t been developed.

My skills haven’t been developed. They’re not developing when I let Claude prototype and prototype until I stop.

I’m seeing how to get brain-obese, and I’m watching opinions on that obesity evolve in our community.

Remember the first time you saw the Chauncey Morlan photo, the 1890s circus dude who was billed as the heaviest man on the planet, and you thought to yourself “damn, I see people bigger than that on the street these days”? We’re used to living our lives obese, seeing obese neighbours and coworkers, feeling uncomfortable without knowing how much better it can be.

Our brains, our minds, we can get comfortable with this shitty normalisation there too. You see people now who argue not only that never-before seen levels of obesity are perfectly ordinary, they’re latching on to interesting ideas like the aquatic ape and twisting it into explanations of humanity to make the argument that the non-obese are the problem, the unusual ones historically.

We’ll get used to people not completing thoughts, not being able to complete thoughts, not able to design an end to end workflow, not thinking through problems. We’re already letting ourselves have Claude write the code, have Claude and CoPilot perform the code review, have them resolve their own meaningless observations, chase their own tails.

Or, just maybe I’m getting old

The fear I have here is remembering the headlines of a hundred, two hundred years ago. Vicemius Knox must surely have felt fear when he wrote “If it is true, that the present age is more corrupt than the preceding, the great multiplication of Novels probably contributes to its degeneracy.”

Am I being scared by a change in behaviour that’ll basically all come out in the wash? Hard to say, hard to say, hard to say. Maybe society changes, maybe some people do stop being able to write code using some approaches that I think have merit. Who am I to say what approaches have merit, though? Surely Linus or Kate or my friend Doug would all look at what I write and recognise that I’m barely software literate.

It’s all so much to take in.

Mon, 27 Jan 2025 21:12:10 -0700

As a follow up to my last post on Charm’s Logger package, I took a look at memory usage for a predefined logLevel, a raw int 100, and math.MaxInt32. My hypothesis was that math.MaxInt32 is more efficient, but using math.MaxInt32, there were no memory allocations shown by the profiler. Amazing!

How Does Charm Logger Format Logs?

Fri, 24 Jan 2025 07:23:43 -0700

I woke up today wondering how charm’s logger library (https://github.com/charmbracelet/log) actually handles log levels. I know they have some levels predefined in an enum, but what’re they doing with that? This is relevant to #golang #opensource #programming #readingcode

logger.Log is the natural entrypoint, as it’s the actual code doing the logging https://github.com/charmbracelet/log/blob/1e6353e3ca793f1177148e09f990ef220e19b037/logger.go#L56

It dispatches to logger.handle, which has this curious setup:

func (l *Logger) handle(level Level, ts time.Time, frames []runtime.Frame, msg interface{}, keyvals ...interface{}) {

	var kvs []interface{}
	if l.reportTimestamp && !ts.IsZero() {
		kvs = append(kvs, TimestampKey, ts)
	}

	if level != noLevel {
		kvs = append(kvs, LevelKey, level)
	}

I think this means that no matter your log level, whether the log will print or not, the logger always constructs a log line for you, unless you match the noLevel?

As a note, noLevel is private, but is defined as math.MaxInt32. This probably means the most efficient way to generate no logs is to declare your own equivalent noLog level as a default, but I can come back to that in a few paragraphs.

So how do the logs get written? Scanning to the end of the function, it’s this straightforwards l.b.WriteTo(l.w). l is a pointer to the logger struct, b is a bytes.buffer inside that logger, and it’s written out to whatever destination is stored in an io.writer called w.

So if we can understand how b get populated, we’ve cracked how these logs are written. The answer is in this switch statement, though it’s indirect:

	switch l.formatter {
	case LogfmtFormatter:
		l.logfmtFormatter(kvs...)
	case JSONFormatter:
		l.jsonFormatter(kvs...)
	default:
		l.textFormatter(kvs...)

Each of these formatters accepts responsibility for populating the buffer with an appropriately formatted log output. The logfmtFormatter, for example, begins with e := logfmt.NewEncoder(&l.b), accepting a reference to the buffer.

So, that’s the story. Logs are appended to a key value store, which is handed to a formatter that writes formatted output to a buffer on the logger, which is then written.

I’ll come back to the question of figuring out if the best performing no-opt logger is setting hte logLevel to math.MaxInt32 in my next post about this.

Sun, 19 Jan 2025 08:48:12 -0700

Time to update my logo. find . -iname "*.html" -exec sed -i '' 's/logo.png/dolphint.png/' {} \; I never did fall in love with xargs.

Sun, 19 Jan 2025 08:44:51 -0700

The joy of maintaining a website as flat files is mostly found in using sed for sitewide refactoring.

two goals today

Sun, 19 Jan 2025 08:17:46 -0700

My first goal today is to look at PlayTechnique’s website, simplify the front page to a clearer “this could be a business you trust” message, and figure out what layout works for the combination of blog posts and project docs that’re on there.

My second goal is to begin the Jinx rewrite I’ve been avoiding for a year. Jinx is such a great workflow for dockerised Jenkins, it’s a shame not to finish it up and get it released. I want it to meet my original goal of rails-like cli for Jenkins containers.

Sun, 19 Jan 2025 08:11:47 -0700

The scary thing in my heart is holding simultaneously knowledge that I am a productive, ordinary person with minor ambitions, and that the legislators of the country are okay legally redefining me as a terrifying monster.

Sat, 18 Jan 2025 11:14:35 -0700

I was sad to find out that Hey email doesn’t support being an SMTP relay. The UI’s really quite nice, but I have a few alerts I need to forward, so it’s on to the next big thing.

Tue, 14 Jan 2025 07:49:06 -0700

Every day I remember my Productive Days and think “I should get an early start on work, because Productive feels Good” and every morning I sit here reading a little book or codebase unrelated to work and feel joy instead of the productive good.

Tue, 14 Jan 2025 07:44:38 -0700

Damn I wish I’d written this - github.com/esnet/gdg… It’s a CLI tool for grabbing grafana dashboards from your instance. I want to take a day off to read it and learn. It uses mockery, Taskfiles, a VHS tape (I haven’t used VHS since rails!), go-releaser. A joyful tool romp!

Mon, 13 Jan 2025 07:07:27 -0700

I started watching videos on prompt engineering yesterday. So far I’m thirty minutes in and it feels like a scam. I keep thinking from reading Simon Williamson’s blog that there’s utility to understanding the models when crafting prompts, but gosh darn it more feels like a prose writing course.

Thu, 09 Jan 2025 22:46:46 -0700

It’s a small thing but this evening I understand the permission in a browser extension’s manifest a bit better than this morning, and the errors caused by incorrect permissions, and that’s progress and that’s enough.

Thu, 09 Jan 2025 07:15:30 -0700

Yay, I said, now we have a log ingester and this is great! But one who had been here before said no, now our troubles begin for now we have to learn yet another unique query language.

Tue, 07 Jan 2025 18:43:35 -0700

I found a neat CLI tool today. Check out man comm

comm – select or reject lines common to two files

Try it out! ls > 1.txt && ls | sed '$d' > 2.txt && comm 1.txt 2.txt

Tue, 07 Jan 2025 18:39:58 -0700

What an interesting way to discover I can’t write an html tag directly in micro.blog. </rss> was the missing tag, for all nobody who wondered.

Tue, 07 Jan 2025 18:28:32 -0700

Fixed the rss feed in Andrew. It turned out I was missing a . How simple a fix!

Tue, 07 Jan 2025 17:17:59 -0700

I’m not sure if micro.blog is replacing my quotes with smart quotes, or if it’s something else in the stack. Truly it was irritating when it came to copy/paste my code this morning.

Tue, 07 Jan 2025 08:29:05 -0700

Two projects today: fix the rss feed for Andrew, and put together yesterday’s #fluentbit investigations as a wee go program. First, I should decide if my headache is mellow enough to go back to work.

Mon, 06 Jan 2025 13:49:29 -0700

Moving on from source codem, here’s the log paths reconstructed: ; k get pods –all-namespaces -o json | jq -r ‘.items[] | .metadata.name + “” + .metadata.namespace + “” + (.spec.containers[].name) + “-” + (.status.containerStatuses[].containerID | split("://")[1]) + “.log”’

Mon, 06 Jan 2025 13:43:22 -0700

Ah, the legacy pattern doesn’t contain the namespace. I wonder if that’s why it’s legacy…

The legacy tests do include the namespace. Odd github.com/kubernete…

Mon, 06 Jan 2025 13:32:56 -0700

I as close! This seems like a good enough reference for the log path github.com/kubernete…

logPath := fmt.Sprintf("%s_%s-%s", podFullName, containerName, containerID)

Mon, 06 Jan 2025 13:21:20 -0700

When fluentbit retrieves logs, it’s worth knowing two things:

It gets container logs, not pod logs
dockerd arranges for a container’s name in the log file to be podName_namespace_imageName-dockerdContainerID

I assume different container daemons might give ‘em different names. I’ll check…

Mon, 06 Jan 2025 13:12:59 -0700

The answer was to ask ChatGPT to solve the question for me:

; kubectl get pods –all-namespaces -o jsonpath="{range .items[]}{.spec.containers[].name}{'\n'}{end}"

Mon, 06 Jan 2025 13:08:48 -0700

A few minutes later I’ve edited the configmap for fluentbit and restarted the pod. The fluentbit logs now show this:

[error] [input:tail:tail.0] read error, check permissions: /var/log/justnocontainers/*.log

Okay, so what’s the quickest way to see all the actual containers using kubectl…