kdsch.org

PCB edge cuts from a 3D model

k@kdsch.org (Karl Schultheisz) — Thu, 13 Feb 2025 00:00:00 +0000

I’d like to explain how I use FreeCAD to create PCB edge cuts in KiCad.

I am starting from a STEP model of an off-the-shelf cast aluminum enclosure sold by Hammond. These are very popular for guitar pedals and other equipment. After selecting an enclosure that I think is the right size, I want to create a PCB edge cut by grabbing some of the geometry from the STEP model and extracting it into a SVG file. This creates the largest PCB that will fit in the enclosure. KiCad will let you import an SVG directly into the PCB edge cuts layer. And in Inkscape, the edge cuts SVG can be useful for understanding the 2D constraints of the design.

Recently

k@kdsch.org (Karl Schultheisz) — Thu, 31 Oct 2024 00:00:00 +0000

My life hasn’t turned out as I expected it. Being a husband a dad and a homeowner and a professional software engineer is harder than I thought it would be. And luck has not always served my health. I had a pituitary tumor removed last year — the surgery went fine, although recovery was rough. We learned the hard way that my pituitary gland has no function (I almost died from a stomach virus), so I take hormones. I lost my libido and realized that it was probably from a combination of testosterone and oxytocin, two chemicals that my body does not produce. I welcomed this insight as a scientific explanation of human behavior.

Writing system

k@kdsch.org (Karl Schultheisz) — Mon, 22 Jul 2024 00:00:00 +0000

I used to grab printer paper and scribble on it when I wanted to write something down. I’d often use the letter-sized sheets in landscape orientation to better fit between my keyboard and the edge of my desk. This led to stacks of loose paper piling up in my office. When I felt the need to declutter, I had to painstakingly decide page-by-page what to keep and discard. About two years ago, I got tired of this system and began to think about improvements.

How I got into software engineering

k@kdsch.org (Karl Schultheisz) — Fri, 05 Jul 2024 00:00:00 +0000

I didn’t plan to become a software engineer, and the story of how I got to be one may be interesting to you.

’90s

Electronics was one of my earliest interests. I learned by taking things apart. Later came the ability to put them back together. I also remember making a robotic line-follower kit with my dad and I had the first LEGO Mindstorms. I wasn’t good at programming it, but I liked the idea of programmable electro-mechanical LEGO models.

Simple bounded model checking

k@kdsch.org (Karl Schultheisz) — Wed, 22 May 2024 23:35:16 -0400

Bounded model checking is unit testing with superpowers. Thanks to symbolic simulation, you can test thousands – or billions – of cases simultaneously. You spend less time writing tests and more time finding broken edge cases.

I want to share a technique for applying bounded model checking that I recently started using. The advantages of this new technique are simplicity, flexibility, and clarity.

While it’s possible to run CBMC on entire programs, this is often impractical because whole programs can be slow to simulate. It also doesn’t apply to libraries. The more generic way to use CBMC is to create a set of carefully chosen entrypoints, which are called “harnesses” in CBMC’s documentation.

Audio stream median filter

k@kdsch.org (Karl Schultheisz) — Wed, 28 Feb 2024 00:00:00 +0000

Median filtering is used in image processing to remove noise and damage. I never encountered it as an audio effect. Let’s figure it out and try it! Here are the requirements:

Compute the median of the last N values of a signal for N ∈ [3, 48].
Do it in real-time.
On a 168-MHz ARM Cortex-M4F microcontroller.

I use a ring buffer in each solution. This is standard in audio stream processing. I don’t show its implementation because you can find it elsewhere, or challenge yourself to implement it!

Parallel development

k@kdsch.org (Karl Schultheisz) — Wed, 07 Feb 2024 15:52:31 -0500

Sometimes when I am developing something, I want to do an experiment or implement a prototype which is based on an existing design. I’ve found that modifying an old design to accommodate a new idea can be difficult. Also, it tends to make it hard to compare the new version with the old version, which is a really useful thing.

Refactoring a function

For example, when refactoring a function, I think it’s better to write a new function. This allows you to test — or better, prove — that the two versions agree. If you’re refactoring a function that your code calls directly in many places, this approach allows you to introduce the new function gradually rather than everywhere all at once. If you’ve ever faced lots of compiler errors during refactoring, you know what I’m talking about.

CBMC × (LTO – assertions)

k@kdsch.org (Karl Schultheisz) — Fri, 02 Feb 2024 12:00:47 -0500

My sampler project is not just a way for me to explore music tech. It’s also a research vehicle to explore better ways of engineering embedded software.

The code is written in style similar to design by contract. Functions check inputs and outputs by calling assert(). There are a lot of assertions, because I avoid using the && operator with conditions. Instead of writing

assert(fabsf(x) <= 1 && other_condition);

I write

assert(x <= 1);
assert(-1 <= x);
assert(other_condition);

This form provides higher resolution when an assertion fails: it lets me know precisely what condition happened. But it results in more branches, which reduces speed.

A year of writing a sampler

k@kdsch.org (Karl Schultheisz) — Tue, 12 Dec 2023 00:00:00 +0000

Last January, I got the itch to make a sampler using Meson, ISO C11, STM32F4, and libopencm3. The project lulled midyear, but has become something I want to refine over time.

I forget sometimes that I ported libopencm3 to Meson only to use Meson and libopencm3 together for this project. I guess that’s how much I care to have good tooling, and how little I want to compromise on using a classic programming language.

A decade of diarism

k@kdsch.org (Karl Schultheisz) — Mon, 11 Dec 2023 12:04:53 -0500

Ten years ago, I wrote the first post in my personal, electronic diary. It actually wasn’t my first try with diarism, but it’s the one that survived.

I wasn’t spurred to adopt it by a faddish impulse to improve myself. I realized that I got something from self-reflection. That realization began in a tender time of burdensome belief and fallacious faith. Somehow, despite my half-closed mind, I couldn’t suppress my desire to think, to understand myself.

About

k@kdsch.org (Karl Schultheisz) — Mon, 04 Dec 2023 00:00:00 +0000

Hi, I’m Karl, an embedded software developer living in Lancaster, Pennsylvania.

Cultured in Linux and holding a B.S. degree in electrical engineering, I’ve worked on technology for eight years. I focus on bettering embedded systems by taking inspiration from the wider world of software engineering. You might not find a person more zealous than me about code quality. I believe better code and better English require clearer thinking.

Free-flowing software stories

k@kdsch.org (Karl Schultheisz) — Fri, 19 May 2023 04:42:37 -0400

There’s an argument that despite the prevalence of search engines, Wikipedia, and large language models (LLMs), we still need to know things. We shouldn’t just look things up.

I think this argument could use better examples. Canonical knowledge, like Newtonian physics and text encodings, is not the best example of something you should memorize. Sure, you’d be faster at solving a problem if you know something relevant to that problem. But in some contexts, predicting what problem you’ll have, and what knowledge you will need, is hard. Knowing how to look up information is nearly as effective as knowing that a million facts are true, and doesn’t require me to adopt the habit of spaced repetition.

Work with Git submodules

k@kdsch.org (Karl Schultheisz) — Wed, 17 May 2023 14:39:16 -0400

Add a submodule at a specific commit

git submodule add https://git.sr.ht/~kdsch/bl
git -C bl/ checkout 113632ca
git add bl/
git commit -m 'add bl submodule at 113632ca'

List submodules

git submodule

Change the version of a submodule

git -C bl/ checkout f81b3582
git add bl/
git commit -m 'bl: update to f81b3582'

Change the remote of a submodule

git submodule set-url bl git@git.sr.ht:~kdsch/bl
git add .gitmodules
git commit -m 'bl: use ssh protocol for the remote'

Note git submodule set-url <path> will not work correctly if the path contains a trailing slash.

Take advantage of Git

k@kdsch.org (Karl Schultheisz) — Wed, 10 May 2023 10:15:28 -0400

Git is awesome, but delivers most of its value when used beyond the utter basics.

Write multi-line commit messages

I’ve seen some codebases that make me wonder if the developers know that git commit -m isn’t the only way to commit changes. Some changes are too complex to summarize in one line.

I never use -m anyway because I want to heed the commit message style guidelines, and my editor helps me do that.

A port of libopencm3's build system to Meson

k@kdsch.org (Karl Schultheisz) — Tue, 02 May 2023 00:00:00 +0000

I am porting libopencm3’s build system to Meson. I’ve used Make for a long time. Here’s why I want to use Meson for new projects.

Meson puts me in charge of dependency integration, not some vendor or SDK. I don’t want to copy files into my source tree or be tied to some “workspace” that an IDE requires. I want to point at a Git commit. Git submodules are too hard to delete. I’ve written about this.

Automating in-tree dependencies with Meson

k@kdsch.org (Karl Schultheisz) — Tue, 07 Feb 2023 21:56:27 -0500

System-installed libraries don’t make sense in a microcontroller project, which naturally wants all code to be in the project tree. Vendoring¹ creates the tree by hand, offering cumbersome ways to specify the version of a dependency and to update the tree when it changes. This habit may struggle to keep a pace of development that supports software over a long lifecycle.

Git submodules simplify specifying a version and updating the tree automatically. However, their reputation for fragility has been earned fairly.

On the job again

k@kdsch.org (Karl Schultheisz) — Sun, 01 Jan 2023 11:16:13 -0500

In late November, I started an embedded software engineering job. My first task was to troubleshoot a network module whose creators were no longer at the company. The module uses a 32-bit microcontroller running a real-time operating system (RTOS). One of my colleagues had observed via serial logs that the system was running out of memory. The software design uses multiple heap allocators. He suspected a memory leak and asked me to investigate the RTOS’s heap allocations.

Reverse engineering the Korg ES-1

k@kdsch.org (Karl Schultheisz) — Sat, 13 Aug 2022 22:19:40 -0400

Korg released the ES-1 in 2000 and describes it as a “rhythm production sampler”. It’s relevant today as a piece of cheap used hardware that’s easy and fun to use.

And not only for making music!

Actually, reversing it is the main reason I have it.

I’ve taken a technical interest in samplers since the time I became aware of their creative use in the production of late 1990’s drum & bass. I dreamt of my own product ideas and wanted to better understand how samplers are designed. In that respect, the ES-1 would only be a rough guide, because technology is much different today. Nevertheless, I felt the ES-1 offered me a lesson.

Promoting a culture of mental health

k@kdsch.org (Karl Schultheisz) — Mon, 30 May 2022 20:51:32 -0400

America has a culture problem: we don’t know how to promote mental health. While I view mental health—and public health generally—as a collective responsibility, sharing what you’ve learned about mental health nudges the system in the right direction. So that’s what I’m going to do in this post.

My life was never as stressful as during the coronavirus pandemic. While much media coverage about workers during this time told the story of their awkward transition to working from home, my situation was totally different. I had been laid off (you know—fired, but politely) from my fully remote job a few months prior and was in the middle of a delicate career transition. I had just begun a new professional networking effort and had made some good connections; I even did some consulting work for one of them.

Fuzzing Hare

k@kdsch.org (Karl Schultheisz) — Sat, 21 May 2022 08:28:51 -0400

Some years ago, I first encountered American Fuzzy Lop (AFL), a fuzz tester. I found it nifty and forgot about it. I recognized the term “fuzz testing”, but didn’t understand it. I wrote mostly Go then, so I didn’t need AFL, which targets C programs.

With time, my interest in C deepened, as I savored its set of tradeoffs in the great expanse of Language–Designland. I remembered that C programs benefit from nifty tooling. What was that fuzzer called? I should try it.

Evolving a technique for unit testing in C

k@kdsch.org (Karl Schultheisz) — Mon, 11 Apr 2022 13:43:23 -0400

I expect to be writing a lot more lately, because today is my son’s first day of daycare. My stint as a full-time parent is officially over, and now it’s time to get back in the groove. I plan to write more on that soon.

In a previous article, I described a way to do table-driven testing in C. Since then, experience with this technique (and others) has suggested an evolution.

Faust: an experience report

k@kdsch.org (Karl Schultheisz) — Wed, 16 Feb 2022 20:51:17 -0500

For those who do not know, Faust is a domain-specific language (DSL) for developing audio digital signal processors. It is a functional programming language developed by GRAME, a French research institution, since about 2002. The Faust compiler, and the majority of accessory code, is written in C++, although the compiler also targets other languages.

I’ve been using Faust for about two years. I found it a pretty easy language to learn, given that I was already comfortable with functional programming. The five block diagram operators still seem a bit magical, but I get by.

FOSS and socialism

k@kdsch.org (Karl Schultheisz) — Tue, 08 Feb 2022 03:46:00 -0500

Sometimes comparisons are drawn between the free software movement and socialism. In an article about software licensing, Drew DeVault described free software as a “socialist utopia… ripe for exploitation by capitalists”. Andrew Keen accused Lawrence Lessig, a prominent free-culture activist, of being an “intellectual property communist”. An article published in Jacobin Magazine claims “free software isn’t socialism for your computer”. What is the relationship between socialism and the free software movement?

"Compensation"

k@kdsch.org (Karl Schultheisz) — Sun, 28 Nov 2021 21:07:31 -0500

December 2019, Lancaster, Pennsylvania. CareerLink office. The tone was set by the front desk staff. I was asked what I was here for. “R-E-S-E-A.” “OK, re-see ya.” As I signed in, I was told to check a certain box, but I did not see which one. I guessed correctly. I was then directed down the hall to the third door on the right, a small classroom. I had to sign in there, too. Did I have my letter? Yes. Did I have my 304’s? I don’t know what that is. “It’s OK; I’ll explain it.”

Recently

k@kdsch.org (Karl Schultheisz) — Fri, 12 Nov 2021 04:55:10 -0500

Reading

I read Ursula K. Le Guin’s The Dispossessed to great inspiration last month. It’s the first novel I’ve read since The Kite Runner when I began college. The first paragraphs took a bit of acclimation, but thereafter I was hooked.

I want my child(ren) to read it, maybe after some education in philosophy and science. The book’s effect isn’t to predict future technology, but to affirm the complexity of humanity and to challenge us to meet ourselves with a philosophy that deserves us. For Le Guin, Taoism is such a philosophy.

Knowledge is made in curious ways

k@kdsch.org (Karl Schultheisz) — Fri, 22 Oct 2021 04:57:29 -0400

Since I began writing ode2dsp (mentioned previously), it has been refactored a few times, and has achieved what it set out to do. Success! Maybe.

When ode2dsp was first conceived, it was meant to be a tool to prevent silly mistakes in creating models. Having built this, it was not difficult to add other features that leverage the existing data structures—namely, computing stability conditions. I expected this to enable developers to anticipate stability issues in generated models.

Convert ODEs to DSP—with a tool

k@kdsch.org (Karl Schultheisz) — Wed, 15 Sep 2021 14:57:06 -0400

Since my last post, I embraced the mathematical challenges of DSP. I quickly tired of writing—and miswriting—equations by hand. Then, I betrayed all of my mathematics instructors by using computer algebra to check my results. I betrayed them again when I felt the computer was simply better than me at the job. But I vindicated computer scientists when I resolved to automate the symbolic computations.

I’ve been a SageMath user since 2013, back when it was called Sage and it only ran on Linux. Sage was a main reason I began using Linux, and I feel a strong bond with the project. However, after eight years, I’ve learned more about software development, and Sage feels inconsistent, complex, opaque, and difficult to use. Sage’s goal is to compete with proprietary software like Mathematica. And as an open source project, it opted to integrate many independent mathematics packages under one interface. Mathematica is old enough to have crufty corners, but it has no such burden as integrating dozens of unrelated bits of software, and I do not doubt that it achieves much smoother integration than Sage ever will. (Maxima, Sage’s default backend for common symbolic calculations, has no programmatic interface—no API—and fully assumes that only a human being sitting at a terminal is interacting with it.)

Nonlinear DSP is good, fun, and hard

k@kdsch.org (Karl Schultheisz) — Thu, 12 Aug 2021 13:40:26 -0400

From day to day, my job is to take care of my son, and will be for the foreseeable future. While I enjoy him trotting up to me, book in hand, speaking the unfathomable, I anticipate a break. When I get a break, I like to spend it on something that unites all of my skills, interests, and concerns, and lately that has been digital signal processing.

Though I spent the past year focusing on hardware, especially analog circuits, it’s not the best thing for me to focus on right now, for many reasons. I love analog electronics, so this was a bittersweet realization. But DSP makes me more content.

Small is beautiful

k@kdsch.org (Karl Schultheisz) — Tue, 27 Jul 2021 03:50:15 -0400

bl is a tiny backlight adjuster I wrote for myself. I’ve used it for years without needing to change it very much. When I am feeling sad, I enjoy reading its codebase.

The tool was first written in Go and later rewritten in C for the sake of minimalism. A neat way to see its simplicity is to run it with strace and count the lines of the output.

$ strace -o /dev/stdout bl + | wc -l
14

Its build system, designed to reduce size and dependencies, generates 33 kB. Its tests achieve clarity by following an unusual convention. bl adjusts smoothly at any brightness level, since it scales by a constant factor.

"Coming to an understanding"

k@kdsch.org (Karl Schultheisz) — Mon, 12 Jul 2021 19:55:30 -0400

Format: MP3
Size: 1.8 MB
Duration: 5:18

How to liberate billions of Android users

k@kdsch.org (Karl Schultheisz) — Sat, 10 Jul 2021 12:42:19 -0400

As of 2019, there were 2.5 billion active Android devices. Typically, software vendors such as Google, Samsung, LG, and Motorola only support devices for two or three years. After that, vendors drop software updates, a complaint motivating the development of postmarketOS, a Linux distribution targeting mobile devices. Users’ ability to adopt such community-controlled software is hindered, however, by vendors’ persistent grip on bootloaders—refusal to unlock them to allow installing third-party software. Vendors act like they own these devices.

Smart: starting an electronics biz during a chip shortage

k@kdsch.org (Karl Schultheisz) — Wed, 31 Mar 2021 17:09:15 +0000

At some point while designing an electronic product, one has to decide the hardware implementation. The number of options is a thing of awe. To gather relevant information and focus on one aspect at a time can get you past the paralysis. And make your requirements and constraints clear.

Should you face a shortage of semiconductors, you want to avoid committing to special chips. Aim for the least common denominator, seems right. I look at what’s in stock now and might be relieved to find things that could work, yet fear them scarce come production time. Companies nimble enough are redesigning their products to use whatever is available. Others hoard. Wisdom seems to be that nobody should expect the shortage to clear up before ‘22.

Wait, maybe not Rust

k@kdsch.org (Karl Schultheisz) — Fri, 12 Feb 2021 19:02:06 +0000

I don’t like to come to conclusions prematurely, but the fact is that most human decisions are made from the gut, before we become aware of it, despite our conscious rationalization. One such decision is whether to develop Recursyn using C or Rust. Here’s the rationalization.

Rust is the “most loved” programming language. Doesn’t that mean it’s a good choice for new systems programming projects? Even professional Rust consultants are skeptical:

Recursyn development report 0

k@kdsch.org (Karl Schultheisz) — Sun, 24 Jan 2021 22:11:00 +0000

What’s the current status of Recursyn?

I’m evaluating developing the firmware in Rust, particularly the application logic and peripheral drivers. Rust is attractive because it is a modern language, simpler than C++, targeting microcontrollers, with a large enough community to provide most of the functionality Recursyn needs. Rust comes with challenges, however; the language reference is incomplete at 316 pages, and its ecosystem is known to often break APIs. In addition, typestate interfaces, which are often used in embedded Rust to enforce contracts, seem to incur a cost in readability. If Recursyn ultimately suffers from these tradeoffs, it probably needs C.

Recursyn: analog resampling synthesizer

k@kdsch.org (Karl Schultheisz) — Fri, 08 Jan 2021 05:06:10 +0000

I’ve been listening to drum & bass music since my teens, but only late last year did I study in detail the history of its production. Drum & bass was the among the first music genres to explore the remotest sound design possibilities of digital sampling. This exploration resembled an unwitting turn of electronic music toward a much earlier musical movement, musique concrète, which employed similar techniques of unrecognizable sound. The golden age of drum & bass coincided with the apex of hardware samplers, which were rapidly killed off by personal computers running digital audio workstations. Drum & bass survived, but in symbiosis with different tools.

Faust Brings Functional Programming to DSP

k@kdsch.org (Karl Schultheisz) — Mon, 04 Jan 2021 16:42:17 +0000

In the future, all radical new languages will be domain-specific languages.

Peter Alvaro

If you write digital signal processing code and you haven’t encountered Faust, it’s worth a look, especially if you have ever wanted a change of pace from writing DSP in C/C++. Faust is a functional language for DSP that cuts through the noise.

I first used functional programming professionally when last year I contributed to a web GUI in Elm. Many of the arguments for using Elm over JavaScript are also relevant to using Faust over C/C++. Elm is simple enough that I came to grasp it in a few months. I was hooked; I started using it for hobby projects, like a CIEXYZ-to-RGB color picker. And when I started using Faust a few months ago, I felt the same zing.

My 2020: Development Comes to a Head

k@kdsch.org (Karl Schultheisz) — Thu, 10 Dec 2020 12:44:14 +0000

Over the past 15 months, my life has rapidly transformed. But for you to understand the significance of that transformation, I have to tell you the story of my life since high school.

In 2001, I was fourteen years old, skateboarding, and listening to the Chemical Brothers. When I entered tenth grade, I enrolled in an electronic technology program at a vo-tech school, a decision to exert greater control over my education, not to skip college and become a technician. Leonard Krug, my instructor, recognized and nourished my curiosity with significant latitude to explore. Voltage-controlled filters enchanted me, and I built a four-pole filter using LM13600’s as part of a joint senior project. (The other part was a digital oscillator/sequencer designed by Andrew Meehan, my friend to this day.) During this period, I received a book that offered permanent career inspiration: The Art and Science of Analog Circuit Design, by Jim Williams.

The Musician Taught the Engineer

k@kdsch.org (Karl Schultheisz) — Tue, 22 Sep 2020 16:37:10 +0000

Tatsuya Takahashi, a designer of modern analog synthesizers, has a coherent philosophy of musical instrument design. He argues that the guitar has been a dominant instrument because of its superiority in a number of aspects. The guitar is versatile: it can play chords or leads, rhythms or melodies. The guitar is portable: light enough to carry, loud enough for a small gathering. The guitar is autonomous: it is self-powered and needs no special environment, such as a production studio, to make music. The guitar is expressive: it responds inherently to nuances of touch and articulation, which a skilled performer can put to musical use. The guitar is simple: a set of strings attached to a wooden resonator, not banks of knobs and switches.

Useful Work Logging

k@kdsch.org (Karl Schultheisz) — Mon, 17 Feb 2020 17:25:21 +0000

Ticket systems such as Atlassian Jira can bridge developers and product owners, if used effectively. Developers don’t need see logging their work as an arbitrary chore that happens to please management. Work logging keeps product owners informed about development pace and can help teams of developers use resources efficiently.

I use the verbal phrase “work logging” rather than the noun phrase “work log” to emphasize the practice over the artifact. The goal isn’t merely to produce an artifact, but to tell the story of development.

Troubleshooting Home Network Quality Issues

k@kdsch.org (Karl Schultheisz) — Tue, 04 Feb 2020 22:22:20 +0000

Devices using my home wireless network have suffered from a mysterious quality issue for a few months. It manifests in the form of episodes, which vary a lot in their characteristics, but tend to have high latency (as high as 40 seconds) and sometimes high packet loss (greater than 80%). As Steve Litt tells us, intermittent problems challenge us the most, as unknown factors modulate them. Though the issue persists, I’ve learned a lot in troubleshooting it.

How I Make Terminal Sessions Productive

k@kdsch.org (Karl Schultheisz) — Fri, 31 Jan 2020 18:29:22 +0000

Call me old fashioned, but in an era of IDEs written in JavaScript reaching peak popularity among developers, I still use a terminal to get everything done. In contrast to IDEs, which attempt to own the main productivity experience and defer customization to plugins, being productive in the terminal hinges on hand-selecting your tools and knowing how to use them.

Here are some ways I stay productive in the terminal.

Hope for Reducing C/C++ Build Times

k@kdsch.org (Karl Schultheisz) — Sun, 19 Jan 2020 17:40:33 +0000

When I write software, I’m often motivated by a desire for structural simplicity. My low tolerance for complexity makes me avoid certain solutions, even if it means more work. A love of simplicity, in some contexts, is a strength. In others, it’s a weakness.

Embedded Linux development often entails building large amounts of system software, which is typically written in C and C++. Build times on the order of hours limit the speed of the development cycle. Many have complained about this situation, but feel little hope for improvement.

Data in the History of Automation Tools

k@kdsch.org (Karl Schultheisz) — Fri, 17 Jan 2020 20:22:13 +0000

Shells have always been used for both interaction and automation. Today, automation tools are highly evolved and diverse. Here are some notes I’ve taken while searching for meaning in the chaos.

Louis Pouzin coined the term “shell” and also wrote the first one: RUNCOM. This program featured composable commands and permitted automating repetitive tasks. Multics shell, inspired by Pouzin’s ideas, was created in 1965 by Glenda Schroeder. In 1971, Ken Thompson wrote a similar shell for Unix.

What I'm Up To

k@kdsch.org (Karl Schultheisz) — Thu, 19 Sep 2019 00:00:00 +0000

I’ve got a few projects rolling at the moment. The overall trend is to pursue intelligibility.

Document publishing

I’m in the process of learning Pollen, a next-generation document publishing tool written in Racket, a dialect of Scheme. I intend to use it for my résumé, this blog (sorry Hugo, you’re too complex), and random typographical stuff I produce for events such as parties. Matthew Butterick’s Practical Typography has turned me into an amateur typographer, such that I now offer free, unsolicited design services to friends who ask me to improve their writing. Having been a reader of SICP since about 2014, I have some experience in Scheme, but Racket seems much more featureful; more like C++ is to C, or Scala is to Java. I’ll have to proceed with caution.

Designing a Platform for Programming Language Experimentation

k@kdsch.org (Karl Schultheisz) — Wed, 11 Sep 2019 00:00:00 +0000

Roughly two years ago, I read a description of how a Forth interpreter works.

The Forth interpreter is very simple. It just does this over and over:

Read a line of input

While there is more data in the line:

Parse a whitespace-delimited word

Lookup the word in a list of defined words. If found, execute the code for that word.

Otherwise, try to interpret the word as a number in the current number base. If so, push it on the stack.

Otherwise display an error message

I remember the thrill of feeling that it was in reach. Two-hundred lines of Go later, I had written my first interpreter. Since then, the project branched out into a music composition language, an investigation of type systems (including Hindley-Milner type inference), a yearlong search for a Raymond Smullyan book, and most recently, a concatenative language based on Robert Kleffner’s “lambda-compose”. There were several blind alleys along the way. (Among them: trying to use propagation of constraints for type inference.)

I Slayed a Callback Dragon Today

k@kdsch.org (Karl Schultheisz) — Tue, 30 Jul 2019 00:00:00 +0000

I was writing some Core Bluetooth code on iOS when the dragon appeared.

A callback looks like a function. But it’s not a function; it’s an event disguised as a function.

Once you know the beast’s weakness, it’s simple, though not easy.

Don’t write callbacks. Write code to handle events. All events implicated by a particular objective. That code might be a state machine, or it might be something more complex. It’s much easier to debug a state machine than a callback dragon.

Designing a Concatenative Language

k@kdsch.org (Karl Schultheisz) — Wed, 05 Jun 2019 00:00:00 +0000

The tasks of designing a language and creating an interpreter are distinct, but practically, they are tightly coupled. The interpreter serves as a research vehicle for design choices. The language serves as an occasion for interpreter design.

The first interpreter I wrote was for a Forth-like, stack-based, postfix language. It was extremely simple, consisting of a tokenizer and a word evaluator, inspired by a description of the Open Firmware Forth interpreter. I got by with this minimal design for some months while I toyed around with language features and applications, particularly signal processing.

Write C to Test C

k@kdsch.org (Karl Schultheisz) — Thu, 16 May 2019 00:00:00 +0000

It disappoints me to see messy, procedural, assertion-based testing in C codebases. Here’s an example from the wild:

const char *key = "404";
const int values[3] = { 0, 1, 2 };

plan_no_plan();

Map *map = map_new();

ok(map && map_empty(map), "Creation");
ok(map_first(map, &key) == NULL && strcmp(key, "404") == 0, "First on empty map");
ok(map_empty(map_prefix(map, "404")), "Empty prefix map");

In assertion-based testing, it’s common to test an entire data structure in a single function, instead of testing one of its operations. This groups together tests for unrelated behaviors. Assertions tend to contain difficult boolean expressions that mutate state silently, coupling test cases together. They use magic to hide the test framework implementation, and reimplement features that your programming language already has.

What I learned from trying TCR

k@kdsch.org (Karl Schultheisz) — Sat, 13 Apr 2019 00:00:00 +0000

test && commit || revert (TCR) is a coding workflow proposed by extreme programming guru Kent Beck. I just tried it out. Here’s what I learned.

1. Starting out is somewhat paradoxical

You have to write tests that pass, otherwise they get deleted. So you end up aiming for silly things, like tests that test nothing or test stubs. After that, it seems to work well enough for something like a Fibonacci function.

Code Framing

k@kdsch.org (Karl Schultheisz) — Thu, 20 Dec 2018 00:00:00 +0000

I assume that our conceptualization of programming languages has been influenced by the grammatical moods of natural language. The imperative mood: imperative, statement-driven programming; the conditional and subjunctive moods: condtional statements and clauses; the indicative mood: declarations—be they data, constraints, relationships, or whatever.

Most programmers have more experience with programming constructs than with grammatical moods. But if such moods influence our idea of programming, maybe they can be a research vehicle in programming language design.

Clean Concurrency in Go

k@kdsch.org (Karl Schultheisz) — Fri, 13 Jul 2018 00:00:00 +0000

The Go programming language makes it possible to write readable software. But readability is not an ingredient of a language. It follows from the language’s design and how it is used.

In my brief experience with Go, using interfaces enhances readability. Interfaces can be used to separate concerns, so that unrelated thoughts don’t intrude on one another.

Concurrency, one of Go’s “headline features,” enables separation of concerns in a different way. In sequential code, two statements always happen in the same order, even if that order is irrelevant.

The Case for a Cooperative Internet Service Provider

k@kdsch.org (Karl Schultheisz) — Sun, 10 Jun 2018 00:00:00 +0000

As the Internet has evolved, new services have challenged the engineering and business assumptions of existing networks. BitTorrent and Comcast, Skype/iPhone and AT&T, Netflix/Level 3 and Comcast are just a few cases in which changing relations among Internet organizations have caused consumer dissatisfaction.

Consumers rightly see the risk in giving ISPs too much power. However, they typically lack insight into the technical and business situations that ISPs confront, for example, routing and peering agreements, making it easy for the actions of ISPs to be seen as Orwellian.