Month: December 2020

COVID, “Stimulus”, “Relief”, “Survival”, and word choice

People (or more precisely, pundits, politicians, and reporters) keep talking about the CARES act and the current deliberations in Congress as being about “a stimulus” or “stimulus checks”, etc., though some in the left wing of the Democratic party (including Reps. Ayanna Pressley and Alexandria Ocasio-Cortez) have started insisting on calling them “survival checks”, but I see hardly anyone using the term “relief”, and I wonder why that is.

On the one hand, the last time the government spent a lot of money all at once (or in a relatively short time) to try to help as many people as possible, as quickly as possible, was the ARRA under Obama, in response to the Great Recession, and that was constantly discussed as an “economic stimulus” bill, so in that way it makes some sense that the word “stimulus” would be sticky. On the other hand, “stimulus” and “relief” have different objects. You “stimulate” an economy; you give “relief” to a person. And of course you help a person “survive”.

I wonder if some politicians consider “survival” a more “marketable” word, a way to sidestep debates about moral hazard and so forth, because it implies an emergent, temporary crisis. If someone is in the path of an oncoming car, or is about to drown or fall off a roof or has been stung by a bee and needs their Epi-Pen, why, of course anyone would help them survive. If the economy — and it’s an article of faith in modern American politics, an axiom not to be questioned, that The Economy is an independent and unruly force that must be appeased at all costs — needs stimulus, why, we can pick and choose which economists we listen to about what form that stimulus should take, and decide we like the plan where it’s all tax credits and business loans.

To offer relief implies caring about people, and not just whether they’re barely existing, but whether they’re doing well. One needs relief from hardship, from suffering, from deprivation, from worry and stress. That’s an ongoing, maybe indefinite problem, and a problem of human empathy, not the abstract, imaginary machine-god of The Economy simply demanding that the numbers go up.

Right now people don’t need “stimulus”. People don’t have jobs, their bills and rents and mortages are coming due or overdue, and it’s not safe to be around other people. We’ve known since March what the right thing was to do, all along, and the government (which is to say, mainly Republicans, who control most of the veto points; maybe Democrats wouldn’t have done a good job either, but we know that many of them have at least argued for doing better, and we know the Republicans actually didn’t do the right things) has refused to. We should have had ongoing, monthly, non-means-tested, no-strings-attached relief checks to every person in the country, forgiveness of all federal student loan debt, cancellation of rents and mortgages (in the latter case, if necessary, by extending the mortgage terms by the number of months cancelled) and prohibition of eviction and foreclosure, massive federal investment into developing good practices for remote learning, even more massive investment — and worldwide collaboration — into coordinated research efforts for treatments and vaccines, federalizing production of masks and PPE if necessary, not scuppering the plan the USPS already had to deliver masks to everyone, and mobilizing the National Guard to distribute supplies, food, and medicine all over the country, to make sure everyone could safely and comfortably stay home until it was safe.

We didn’t do the right things, and a crisis became an ongoing, enormous catastrophe, and hundreds of thousands of people are needlessly dead—over 320,000 officially, but that’s well understood to be an undercount. If you look at general excess-death figures, and consider how many people died of COVID without getting diagnosed, and how many died of other causes because the health care system was overloaded, or because they didn’t seek enough care soon enough because they were afraid of COVID or because they’d lost their jobs and health coverage due to COVID, it’s hard not to conclude that the true number is probably already over 400,000. People don’t need “stimulus”, and they don’t need bare “survival”, they need relief.

Cproj: v1.0.0 is live!

I’ve just pushed v1.0.0 of Cproj up to Github. Usage is very simple: source cproj.sh (I have a line in my .bashrc to do that when my shell starts up), then type cproj <projname>. Cproj creates a <projname> directory and populates it with a ready-to-build project skeleton including source and header files, Makefile, and basic test suite using Scuttle. If Scuttle isn’t installed on the system (Cproj checks the default installation location /usr/local), Cproj attempts to download it from the main Github repository.

You can immediately cd <projname>; make to build the project and unit tests and run the test harness.

I listen to too many podcasts

I wasn’t getting through episodes fast enough to even keep up with new releases, let alone approach the present.

At some point I became one of those people who listens to podcasts on 2x-speed, because I’d subscribed to so many — and in many cases they had long backlogs I wanted to catch up on — that I wasn’t getting through episodes at normal speed fast enough to even keep up with the new releases, let alone asymptotically approach the present.

We’re in something of a Podcast Era now, and have been since the early 2010s. Long ago, before I even started my first blog (remember blogs?), there was a First Podcast Era, which began shortly before Ben Hammersley named them “podcasts” in 2004. (Before that, of course, there had been “internet radio” — mp3 streams, which we called shoutcasts after the popular server software produced by Nullsoft; listened to at 96 or even a luxurious 128kbps in Nullsoft’s ubiquitous Winamp media player; and which, as I recall, consisted mostly of European ambient and techno — but you had to be at your desktop computer for those, because in 1998 the iPod was still three years away.) Back in the First Podcast Era, of course there was no Spotify to offer far-right bigots a hundred million dollars, so you had to have a podcatcher app, or eventually iTunes, and figure out how to copy and paste an RSS URL into it. And there was no Patreon to funnel millions a year to “far-left” bigots, and as I recall not much in the way of podcast networks or available sponsorships, so most podcasts had what we would now consider fairly amateurish production, and were strictly side gigs.

Anyway, I used to listen to a lot of podcasts in 2005–2007 or thereabouts, but I sort of fell out of the habit, and by the time the Second Podcast Era got started in earnest around 2012–2013, I didn’t consider myself “a podcast guy”. But eventually I had friends who were doing podcasts, and I wanted to support my friends, and one thing led to another, so here I am with a paid Pocket Casts account and, uh…76 subscribed feeds.

Some of them have been limited runs, or have just ended, the way things sometimes do, without having had a planned ending; or work on a seasonal schedule and are between seasons currently; or are just on some kind of hiatus; so only about two-thirds of those are still releasing new episodes with any kind of frequency, but it’s still a lot to keep up with.

All this woolgathering was by way of establishing why I’m only just getting to the fourth season, “Twilight Mirage”, of Friends at the Table, an “actual play” (i.e. episodes are recordings of gameplay sessions of what we used to call a “pencil-and-paper role-playing game”) podcast that I believe is one of the best of the genre. FatT alternates (roughly) fantasy with (roughly) science fiction, so Twilight Mirage is the second sci-fi season, and the last episode I listened to was the post-mortem Q&A for “Winter in Hieron” and its prequel “Marielda,” which formed the second fantasy season.

The, I suppose, impresario (and also gamemaster) of Friends at the Table is Austin Walker, a critic and author, the former EIC of Vice‘s former Waypoint games vertical (now reduced to “Vice Gaming” because corporate decided there was too much individuality, though the podcast — remember podcasts? — Waypoint Radio lives on with Austin as host). Austin is a genuinely brilliant person, and Disney even let him write some Star Wars stories, and his talents as a GM are matched only by the FatT cast, and in particular Jack de Quidt’s stunning work composing the scores for each season. So when, around the midpoint of the Marielda/Winter postmortem, I heard Austin describe the season 2 (“COUNTER/Weight”) episode “An Animal Out of Context” as “the best thing I’ve ever made”, I decided, well, I remember that being great, but I should go listen to it again.

I don’t know if that episode, which intersperses small vignettes with the other main characters among longer stretches of Jack and Austin playing a GM-less, two-player storytelling game of their own design, recontextualized for the COUNTER/Weight setting, would have the same impact for someone who hadn’t followed the story up to that point, so I hesitate to recommend listening to just that episode alone. But there’s a moment, three-quarters or a little more of the way through, where in one of those side vignettes, Art Martinez-Tebbel mentions casually that “an animal out of context” (in a future zoo, as it happened) is a hard thing to understand — giving, presumably unknowingly in the moment, the episode its title and also perfectly summarizing the alienation Jack’s character feels. I had to pause and take a breath when I heard that again, because it crystallizes a lot of what I think is so great about FatT: that Austin and Jack were telling such a powerful story; that Art, separately, got at such a crucial idea in a different (as it were) context; that Austin and Alicia Acampora, the producer and also a cast member, caught that brief phrase and realized how well it evoked the episode’s themes.

This is a very rambly weekend post, but the short of it is, I’m glad that, in this Second Podcast Era, it can be feasible for a show like Friends at the Table to run for over six years, and if you think a collaborative longform fiction radio show “focused on critical worldbuilding, smart characterization, and fun interaction between good friends” sounds interesting, you should try giving it a listen.

New project: Cproj

Next I’ll start a real project. Or maybe I’ll just discover another bit of tooling that needs revision.

A couple of weeks ago, when I got started on what became Scuttle, I mentioned that the reason I wanted a simple but adequately featureful plain-C unit testing framework was that I was frustrated with the limitations of the more ad-hoc solution I’d built into my old cproj() shell script. It creates an even simpler test facility, but it was too simple.

Now that Scuttle v1.0.0 is done and published, I want to revisit Cproj. I haven’t touched this script in years, and I think there’s a lot of room to clean it up and make it more useful — and update it to use Scuttle as the testing framework it builds into the project skeletons it generates!

Much like Scuttle, the animating philosophy of Cproj is that it should be as self-contained as possible: the script contains its templates for the files it generates as here-documents, and runs pattern substitutions on them to produce the right output. The first time it’s run, the old Cproj actually writes out those templates to /etc/skel/proj/ (if run as root) or to $HOME/.skel/proj/, and on subsequent uses reads them from disk instead. I’m no longer sure there’s much value in doing that, so I’ll probably remove that functionality, and just use the here-docs directly every time, like Scuttle does.

After I finish fixing up Cproj, I should be ready to use my revised tooling to start a, you know, real project. Or maybe I’ll just discover another bit of tooling that needs revision.

Scuttle: v1.0.0 is live!

All right, it took me two weeks, but Scuttle v1.0.0 is now live. I think it’s pretty easy to use, and it’s very lightweight. The full README is over at github, of course, but it basically works as I outlined in the project introduction. No one really needed a new unit test framework, but I wrote one anyway, and now I’m going to use it in subsequent projects as often as I can.

I hope other people also find it useful!

Happy Third Lastjediversary

Three years ago today, December 15th 2017, the best Star Wars movie to date — by the director who, to date, showed the best understanding of what Star Wars is about and what it’s for — hit theaters. So this is just a quick appreciation post for Rian Johnson and The Last Jedi, which was so much better than it needed to be, and whose most important themes were, as far as I can tell, immediately and thoughtlessly cast aside as soon as J.J. Abrams came back to the franchise.

I should do a whole-series rewatch soon.

Scuttle: pre-update update

Scuttle is now working as intended for the standard use case. As described in the introductory post, for a C project with a standard layout, adding unit testing with Scuttle requires the following steps:

  1. Install scuttle.h either locally to the project or in the system include path
  2. Install scuttle.sh either locally to the project or somewhere on your $PATH
  3. Add test suite source files under test/, each corresponding to a module of your project, named test_<module>.c, using Scuttle’s simple macros
  4. Add a test target to your main Makefile as follows:
test:
    bash scuttle.sh test
    $(MAKE) -C test

Scuttle will generate test/Makefile, test/test_<module>.h and test/test_<module>_gen.h for each test/test_<module>.c suite, and the test/test_<project>.c harness; and the generated Makefile’s test target will build and run the test harness and pipe the output to test/log/test_<project>.log.

There’s a lot of room to make this more flexible and add some convenience features, but in terms of functionality it’s at MVP level now.

Tomorrow I’ll do a quick cleanup pass, make a few small tweaks I’ve already thought of, write some basic documentation, and actually push the code up to a public repo so if anyone’s interested in trying it out, it’ll be available.

A Brief History of C

Over at Ars, Richard Jensen has a great article on how the C programming language came to be. I love dives like this into the various particulars and contingencies involved in the development of things we now think of as more-or-less having “always been there”. It’s easier to do with computer technology than many other things, too, because a lot of the people who were directly involved are still alive, and can talk about why they made one decision or another.

It’s a good reminder, too, that very little of how we generally think “the world is” was inevitable—or is immutable. On the other hand, of course, the longer particular arrangements are accepted as the default without examination of their roots, the more inertia they have, and the more effort it takes to make change.

Just think: we might have ended up with 10-, 12-, even 18-bit “bytes” as the basis for our computing technology; or even trinary logic circuitry, with a three-state “trit” as the smallest unit (after all, at the circuit level, a “0” just means there’s currently 0 volts on the line, and a “1” means there’s 5 volts, but there’s no rule that says other signal levels couldn’t exist).

New project: Scuttle

A basic principle of engineering, software or otherwise, is “don’t reinvent the wheel.” I’m gonna anyhow.

Last week I wrote about wanting a very lightweight C unit testing solution, and, in my bullheaded way, wanting to write it myself rather than learn an already-existing system. It’s a commonplace in software engineering that the impulse to start over from scratch is one of the worst habits of programmers; one way or another, reinventing the wheel means doing lots of work you didn’t have to, usually to get a less satisfactory result. Either you end up hand-rolling something you should have just used a library for; or you look at a mass of legacy code full of cryptic comments and weird edge-case handling, think “whew, what a mess, how hard to maintain! better to just scrap it all and start fresh, so it will be cleaner and more elegant,” only to discover along the way that all those weird edge cases really exist, and end up with just as patchwork a code base as the one you meant to improve.

All that said, I’m doing it anyway. It’s not like I’m busy right now, and this is what’s engaging my brain.

So, suppose you have a project projname, and you want to add unit testing. Your project layout looks like this:

~/projname$ ls
include/
Makefile
src/
~/projname$ ls include
include/foo.h
~/projname$ ls src
src/foo.c
src/main.c

You want to add unit tests for the foo module, which is sensible because it’s pretty complex and you want to be sure all of it works exactly right. The foo module looks like this:

foo.h

#ifndef _FOO_H
#define _FOO_H

int foo();

#endif /* _FOO_H */

foo.c

#include "foo.h"

int foo()
{
    return 42;
}

To add unit testing with Scuttle (let’s say it stands for “simple C unit testing tool, limited edition”), you just need to put scuttle.h in your include path and scuttle.sh in your executable path, create a test/ directory, and add test_projname_foo.c:

#include "foo.h"
#include "test_projname_foo.h"
#include "scuttle.h"
#include <stdio.h>

SSUITE_INIT(foo)
    printf("foo suite init\n");
SSUITE_READY

STEST_SETUP
    printf("foo test setup\n");
STEST_SETUP_END

STEST_TEARDOWN
    printf("foo test teardown\n");
STEST_TEARDOWN_END

STEST_START(foo_return_true)
    int i = foo();
    SASSERT_EQ(42, i)
STEST_END

STEST_START(foo_return_false)
    int i = foo();
    SREFUTE(i == 69)
STEST_END

You’ll have noticed that no test_projname_foo.h header exists: scuttle.sh will generate that, as well as a test/test_projname_foo_gen.c source file with some data structures, and test/Makefile, for you.

~/projname$ ls test/
test/test_projname_foo.c
~/projname$ scuttle.sh
This is Scuttle, v1.0.0.
Working...
    * found suite test/test_projname_foo.c
    * generated suite header test/test_projname_foo.h
    * generated suite data test/test_projname_foo_gen.c
    * generated harness test/test_projname.c
    * generated makefile test/Makefile
Done.
Type 'make -C test/ test' to build and run your test harness.
~/projname$ ls test/
test/bin/
test/log/
test/Makefile
test/obj/
test/test_projname.c
test/test_projname_foo.c
test/test_projname_foo.h
test/test_projname_foo_gen.c
~/projname$ make -C test/ test
[$(CC) output]
test/test_projname > test/log/test_projname.log
~/projname$ cat test/log/test_projname.log
This is Scuttle, v1.0.0.
Running test harness for: projname

Test suite projname_foo:
 *** Suite passed: 2 / 2 tests passed.
 *** 1 / 1 suites passed

Aside from the simple SASSERT(x) and SREFUTE(x), Scuttle provides convenience macros SASSERT_NULL(x), SASSERT_EQ(x,y), and SASSERT_STREQ(x,y), as well as SREFUTE versions of the same.

As of this writing, scuttle.h is at or near v1.0 completeness, targets for scuttle.sh‘s output are determined, and I’m beginning work on scuttle.sh itself. More on those soon.