<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel>
<title>Benjamin Kiefl</title><link>https://benjaminkiefl.com/</link><description>Writing, discoveries, projects, and experiments from Benjamin Kiefl.</description><language>en</language>
<atom:link href="https://benjaminkiefl.com/index.xml" rel="self" type="application/rss+xml"/>
<item><title>Magnetic Acrobat</title><link>https://benjaminkiefl.com/lab/magnetic-acrobat/</link><guid isPermaLink="true">https://benjaminkiefl.com/lab/magnetic-acrobat/</guid><pubDate>Sun, 25 Oct 2026 12:00:00 &#43;0100</pubDate><description>Guide a metal ball through suspended rings in ten 3D puzzles. Place magnets and compose timed pulls. Built with GPT-6 Astra at Medium reasoning in OpenCode for about US$37.95.</description></item><item><title>Motion Workbench</title><link>https://benjaminkiefl.com/lab/motion-workbench/</link><guid isPermaLink="true">https://benjaminkiefl.com/lab/motion-workbench/</guid><pubDate>Sat, 24 Oct 2026 12:00:00 &#43;0200</pubDate><description>A C&#43;&#43; and WebAssembly motion workbench with programmable curves, manufacturing recipes, guided lessons, and an interactive explanation of the code. Built with GPT-6.1 Sol through OpenCode.</description></item><item><title>Machine cycle explorer</title><link>https://benjaminkiefl.com/lab/cycle-explorer/</link><guid isPermaLink="true">https://benjaminkiefl.com/lab/cycle-explorer/</guid><pubDate>Fri, 23 Oct 2026 23:30:00 &#43;0200</pubDate><description>Follow a simulated machine cycle, inject faults, and rewind the evidence. Built in one shot by GPT6-Astra in about 12 minutes.</description></item><item><title>Recipe studio</title><link>https://benjaminkiefl.com/lab/recipe-studio/</link><guid isPermaLink="true">https://benjaminkiefl.com/lab/recipe-studio/</guid><pubDate>Fri, 23 Oct 2026 23:00:00 &#43;0200</pubDate><description>A browser-based recipe editor, built and deployed by GPT6-Astra in about 20 minutes. My only added suggestion was the guided demo tours.</description></item><item><title>Progwatch</title><link>https://benjaminkiefl.com/projects/progwatch/</link><guid isPermaLink="true">https://benjaminkiefl.com/projects/progwatch/</guid><pubDate>Fri, 23 Oct 2026 00:00:00 &#43;0000</pubDate><description>A website for exploring the programming language landscape.</description></item><item><title>Dual-head laser sculptor</title><link>https://benjaminkiefl.com/lab/laser-machine/</link><guid isPermaLink="true">https://benjaminkiefl.com/lab/laser-machine/</guid><pubDate>Fri, 23 Oct 2026 00:00:00 &#43;0000</pubDate><description>A Three.js laser-sculpting experiment, built with GPT6-Astra in about two hours through multiple revisions and hands-on testing.</description></item><item><title>2026, September</title><link>https://benjaminkiefl.com/elsewhere/2026-09/</link><guid isPermaLink="true">https://benjaminkiefl.com/elsewhere/2026-09/</guid><pubDate>Sun, 04 Oct 2026 00:00:00 &#43;0000</pubDate><description>Links Lucid Planet - Lucid Planet II (Music Album) Haxe programming language A cop’s case for Flock Coordination, Good and Bad If math is more than proof, we need to better celebrate the rest of it Animation vs Math (Video) How to keep enjoying programming in a world of LLMs Commentary Lucid Planet - Lucid Planet II (Music Album) Artist: Lucid Planet, Album: Lucid Planet II, released: 2020-11-14
Phenomenal “progressive rock” album I’ve listened to repeatedly this month.
</description></item><item><title>AI replacing programmers</title><link>https://benjaminkiefl.com/posts/2025-12-24_ai-replaces-programmers/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2025-12-24_ai-replaces-programmers/</guid><pubDate>Wed, 24 Dec 2025 00:00:00 &#43;0000</pubDate><description>Introduction The AI hype brings w/ it, among many annoying tropes, the “programmers will be replaced soon” thesis that never struck me as even remotely accurate.
My perspective may be lacking
outside any Silicon Valley hype as a software engineer in machine manufacturing, where requirements and approaches probably differ from, say, a web startup and as a slow and conservative adopter of AI myself (mainly use it as a faster search engine for well-known APIs, specs, standard library functionality) but here’s why I don’t think I will be replaced soon:
</description></item><item><title>Pros/Cons for still studying C in 2025</title><link>https://benjaminkiefl.com/posts/2025-09-01_rational_learning_c/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2025-09-01_rational_learning_c/</guid><pubDate>Mon, 01 Sep 2025 00:00:00 &#43;0000</pubDate><description>Primer “Why would anyone still learn C in 2025 and beyond?” - The discussion came up w/ a friend of mine, and while talking about some of the reasons I found myself surprised at the still very solid rationale for this (far stronger than anticipated).
Small disclaimer: obviously, this is outside the realm of job requirements one might encounter. If your company uses, for example, Perl &amp; Fortran, that likely is enough reason to study those languages, disregarding general practicality.
</description></item><item><title>Chapel programming language</title><link>https://benjaminkiefl.com/posts/2025-01-30_chapel/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2025-01-30_chapel/</guid><pubDate>Thu, 30 Jan 2025 00:00:00 &#43;0000</pubDate><description>Alright alright… having written short posts regarding first explorations of Kotlin, Mojo, Elixir, JavaScript… and now Chapel, I think it’s safe to say I like to check out what’s out there and am curious about programming languages.
I just so happened to stumble upon Chapel this week and after having explored it for just a bit I’m surprised that I didn’t know about it before.
I’m interested particularly in performance, and always felt drawn towards performant languages. But as fun as it can be to think about L1, L2 cache sizes and to program in a data-oriented manner, it doesn’t mean much if your language of choice doesn’t lend itself to parallelization. Hardware, especially after the dawn of multi-core CPUs and now even more so given powerful GPUs, isn’t your PDP-11 C was invented for. (one could even argue assembly itself doesn’t map well to multi-core CPUs to begin with anymore…)
</description></item><item><title>C binsearch benchmarks</title><link>https://benjaminkiefl.com/posts/2024-11-28_binsearch/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-11-28_binsearch/</guid><pubDate>Thu, 28 Nov 2024 00:00:00 &#43;0000</pubDate><description>Binary search implementations and crude benchmarking.
V1: iterative straightforward solution V2: iterative slightly optimized solution one less comparison in the loop bsearch(): C stdlib’s bsearch w/ custom compare() I wasn’t surprised regarding -O0, but the fact V2 stays significantly faster even with the highest optimization level is quite surprising. Grain of salt: it might be the case that I’m not measuring what I think I’m measuring. Benchmarking accurately is quite the science, and the approach here is not super sophisticated.
</description></item><item><title>Elixir Exploration: The notion of State</title><link>https://benjaminkiefl.com/posts/2024-10-12_elixir_state/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-10-12_elixir_state/</guid><pubDate>Sat, 12 Oct 2024 00:00:00 &#43;0000</pubDate><description>Elixir is blowing my mind :)
State: in an OOP language you’d manage state (let’s assume a key-value store) probably via a class and use mutexes and locking for safe access across threads.
In Elixir it’s idiomatic to simply use a module, spawn your ‘state to be managed’ as a process, and send messages to it / retrieve messages from it.
KV is our module start_link/1 spawns a process it starts the function loop/1 the loop/1 function is private to the module and can’t be used outside the module as argument, it passes an empty map the first time round %{} the loop/1 function itself simply waits to receive messages the messages are tuples, the first element of which is an atom specifying the operation via pattern matching different actions are executed based on the received tuple {:get ... -&gt; sends the retrieved value back to the parent process {:put ... -&gt; stores the key-value pair in the map defmodule KV do def start_link do Task.start_link(fn -&gt; loop(%{}) end) end defp loop(map) do receive do {:get, key, caller} -&gt; send(caller, Map.get(map, key)) loop(map) {:put, key, value} -&gt; loop(Map.put(map, key, value)) end end end {:ok, kvPID} = KV.start_link() KV is a process which now keeps state (a map) we can send to the KV process (via its PID) we use :put and :get atoms to indicate storage/retrieval send(kvPID, {:put, &#34;one&#34;, 1}) send(kvPID, {:put, &#34;two&#34;, 2}) send(kvPID, {:get, &#34;one&#34;, self()}) # kvPID will send its response to the parent process answer = receive do val -&gt; &#34;value retrieved: #{val}&#34; nil -&gt; &#34;err: no such key&#34; after 500 -&gt; &#34;err: timeout (500ms)&#34; end IO.puts answer # value retrieved: 1 to reiterate: KV is not a class, we haven’t done anything w/ mutexes or locking the map we manage could now be accessed by TENS OF THOUSANDS of processes simultaneously without any race conditions or anything of the sort! Processes can be spawned in vast numbers, be registered (given a name) for easier referencing, be managed by supervisors to handle faults and respawn, and much more… Highly resilient with minimal syntax and boilerplate! And Elixir supports this process-based workflow through and through…
</description></item><item><title>JavaScript exploration</title><link>https://benjaminkiefl.com/posts/2024-09-15_javascript_fun/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-09-15_javascript_fun/</guid><pubDate>Sun, 15 Sep 2024 00:00:00 &#43;0000</pubDate><description>Did some JavaScript exploration and… phew… flexible, but… some insanity as well…
// arrow syntax =&gt; assigns anonymous functions const binarySearch = (arr, target) =&gt; { // sort() takes such an anoymous sorting function const sortedArr = arr.sort((a, b) =&gt; a - b); // `reduce((acc, curVal, curIdx, array) =&gt; { /* */ }, { initialAccValue });` // Note: while `_` denotes a placeholder, it&#39;s a legal variable name! // using it twice gives a &#39;SyntaxError: Duplicate parameter name&#39; // (you could actually use `_` and `__` as variables here...) return sortedArr.reduce((acc, _, __, array) =&gt; { // see `initialAccValue` specified after `{}` if (acc.found) return acc; const { low, high } = acc; // destructuring assignment // `{}` in place object creation // `...` spread operator // `...acc` spread acc properties into new object (shallow copy) // `found: false` property overriding, found overriden to be false if (low &gt; high) return { ...acc, found: false }; // the usual recursive binary search logic follows // we&#39;re continuously returning the `acc` object // using property overriding to modify it const mid = Math.floor((low &#43; high) / 2); if (array[mid] === target) { return { ...acc, found: true, index: mid }; } else if (array[mid] &lt; target) { return { ...acc, low: mid &#43; 1 }; } else { return { ...acc, high: mid - 1 }; } }, { low: 0, high: sortedArr.length - 1, found: false, index: -1 }); }; // each iteration of reduce() the `acc` is returned for &#39;further processing&#39; const numbers = [34, 7, 23, 32, 5, 62]; const target = 23; const result = binarySearch(numbers, target); if (result.found) { console.log(`Target ${target} found at index ${result.index}`); } else { console.log(`Target ${target} not found`); } // and since this isn&#39;t enough fun yet: // reduce&#39;s callback function takes _ANY_ number of parameters // undefined parameters are simply left undefined // this is JS being flexible (the function is _not_ overloaded) function example(a, b, c) { console.log(&#39;a: &#39;, a); console.log(&#39;b: &#39;, b); console.log(&#39;c: &#39;, c); } example(1); // you cannot only provide b, but can simulate this effect // (of course we can simply reuse the function name &#39;example&#39; cause...) function example(a, b) { console.log(&#39;a: &#39;, a); console.log(&#39;b: &#39;, b); } example(undefined, 2); // &#39;undefined&#39; is a special value representing value abscence // back to reduce: // a) illustration const numbers2 = [2, 4, 6, 8]; const result2 = numbers2.reduce((acc, curVal, curIdx, arr) =&gt; { console.log(`acc: ${acc} val: ${curVal} idx: ${curIdx} arr: ${arr}`); return acc; }, 0); // b) leaving last two parameters undefined const sum = numbers2.reduce((acc, curVal) =&gt; { return acc &#43; curVal; }, 0); console.log(sum); // 2 &#43; 4 &#43; 6 &#43; 8 Output:
</description></item><item><title>Mojo Programming Language</title><link>https://benjaminkiefl.com/posts/2024-09-08_mojo/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-09-08_mojo/</guid><pubDate>Sun, 08 Sep 2024 00:00:00 &#43;0000</pubDate><description>Now Python is not my favorite, so what’s so great about a Python superset that I’m curious about it? Mojo leverages Python’s full ecosystem: no fancy FFI, just import any Python library and use it. That’s good… Data Science, AI, ML, we got that covered, but so what, that’s Python? What’s beyond Python?
proper static types associated w/ great optimizations and proper compile-time checks SIMD optimizations proper parallelization autotune for vastly improved performance for a specific platform immutable variables And who’s behind it? Chris Lattner, the creator of LLVM, Clang, Swift, and one of the main drivers behind modern MLIR. You’ve got to consider it a serious project for this reason alone, the guy knows his stuff.
</description></item><item><title>Brief Kotlin Tour Highlights</title><link>https://benjaminkiefl.com/posts/2024-06-30_kotlin_tour/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-06-30_kotlin_tour/</guid><pubDate>Sun, 30 Jun 2024 00:00:00 &#43;0000</pubDate><description>Preamble Heard positive things about Kotlin, and it may even be practical for UI applications targeting Linux, Windows &amp; Android (on which it’s the first-class language). .NET seems an interesting competitor for the aforementioned use cases.
Kotlin definitely marks some positive checkboxes:
statically typed type inference less verbose than Java can compile to machine code cross-platform sizeable ecosystem if you consider Java libraries which, if you use them, make Kotlin-native more difficult to use Some of my favorite, albeit basic, language features based on having worked through the Kotlin Tour (and what follows isn’t really much more than a concise pick-and-choose from the tour):
</description></item><item><title>Counting Sort</title><link>https://benjaminkiefl.com/posts/2024-06-16_counting_sort/</link><guid isPermaLink="true">https://benjaminkiefl.com/posts/2024-06-16_counting_sort/</guid><pubDate>Wed, 19 Jun 2024 00:00:00 &#43;0000</pubDate><description>A sorting algorithm I came across. It comes w/ the caveat that values of the array to be sorted need to be within a reasonable range (since they are used as indices in the bookkeeping array).
But the principle is neat:
iterate over the array to be sorted create a bookkeeping array whose indices reflect the values of the array to be sorted values at specific indices denote how often a value appears in the unsorted array based on the bookkeeping array create a sorted version Quick implementation attempt:
</description></item>
</channel></rss>