Unconscious Inertia

software

My plan to update twice a week has, clearly, not borne fruit.

One big—essential, even—part of being a technically-oriented person who is trying to write is consciously ignoring all that technical stuff, because it’s solely a distraction. It’s incredibly easy to get bogged down in the weeds of getting the production pipeline exactly right in each jot and tittle. It’s like a car mechanic spending so much time trying to get optimum performance out of his engine that he never actually, y’know, drives anywhere. So on the one hand, switching from Technology A to Technology B for this blog has little value if it means posts don’t get published.

On the other hand, part of the reason I haven’t been writing posts anyway is because of my dissatisfaction at dealing with Technology A. It’s nice to have an application I can just put words in and hit Publish, but the price for that is a certain lack of flexibility and frustration (and also some bugs).

So, last weekend, I experimented with a Technology B, which would be greatly more flexible—but importantly also comes with some good defaults so I don’t have to reïnvent the wheel on everything. (When I first began this project, I considered writing my own blog software. I am strictly speaking capable of this, but decided against it, as, again, it would leave me no time to actually write posts.) In particular, I looked at how much of a pain it would be to lift-and-shift existing content. It turns out that, though a bit of manual work, it is not that difficult or time-consuming: essentially, copy-and-paste. This means I can easily and with a clear conscience continue to write in Technology A until Technology B is fully set up and running.

So:

  • Look for changes in the website coming Real Soon Now.
  • Those of you reading via email subscription can ignore all the above, because that’s handled separately, and in a way that it doesn’t even matter what is used to generate the site.
  • Not that anybody cares, but Technology A is WriteFreely and Technology B is Nikola.

#100DaysToOffload #meta #software

Here’s some things that came across my desk this week:

  • Fellow Mississippian Blake Watson presented a talk this week on home-cooked apps at MagnoliaJS.
  • MagnoliaJS is a—previously unknown to me, but been around since 2021—software development conference in Jackson, Mississippi.
  • Antoni Sawicki explored a niche of a niche: Windows NT 3.1 on DEC Alpha AXP.
  • Chris Siebenmann explains your email’s “Sent” folder and notes some potential issues.
  • Neil Clarke of Clarkesworld magazine notes some techniques for blocking AI bots.
  • Glad to see somebody’s put together a gateway for your Chaosnet Lisp Machine LAN to talk to these new-fangled systems using TCP/IP.

#software #retrocomputing #email #LLM #networking

Some things that came across my desk this week:

  • Harvey Matusow—quite an interesting character—was interviewed by the BBC in 1970, in his role as head of the International Society for the Abolition of Data-Processing Machines. Twitter has a clip.
  • Now you can run old Windows screensavers under XScreensaver. Because.
  • Daniel Berrangé has come out with exactly the sort of software tool I like: it’s simple and, strictly speaking, it’s unnecessary, but it’s still great because it makes things easier. It’s called Bye Bye BIOS. Its sole purpose is to be run against an OS image (say, for a VM) which is set up only to boot via EFI and, if you try to boot it via (legacy) BIOS, tell you that you need to use EFI.

#computers #software

  • I do not mind paying actual money for useful software.
  • I do not mind purchasing an ongoing subscription for software which which provides a useful service on an ongoing basis, or which continues to improve.
  • I very much mind paying actual money for software which then still tries to show me ads.
  • I flatly decline to purchase a subscription for an essentially static app.

Also, I don’t have strong feeling about this, I just think it’s kind of odd how many apps I’ve seen where the lure to the paid rather than free version of an app is…being able to change the app icon. I mean, if that’s important to you, I’m not criticizing. The little icon square is just not something I care about. (Okay, fine, I care a little; I’m not going to buy an app with a swastika for an icon, or whatever.)

#software #economics

Someone in a group of folks I want to chat with recently suggested using GroupMe.

At the bottom of GroupMe’s website, there's a link to their Terms. On that page, under “Your Privacy,” there’s a link to the Microsoft Privacy Statement. This Statement seems to cover multiple (all?) Microsoft products, including GroupMe. Some quotes:

Microsoft collects data from you, through our interactions with you and through our products

Okay, so what do they do with it once it’s collected?

In particular, we use data to:
  • Provide our products, which includes updating, securing, and troubleshooting, as well as providing support. It also includes sharing data, when it is required to provide the service or carry out the transactions you request.

Fair enough—they are providing a chat service, so they have to actually have your data (read: chat messages) to pass it on to whomever it’s going.

  • Improve and develop our products.

I.e., telemetry from the various apps. Some people are against this, but actually I think it’s mostly fine. At the very least, Microsoft has an argument to make that they have a legitimate interest in this data.

  • Personalize our products and make recommendations.

Uh, what? What sort of personalization and recommendations are we talking about here? To whom are these recommendations being made? It is, at least, unclear.

  • Advertise and market to you, which includes sending promotional communications, targeting advertising, and presenting you with relevant offers.

I have no desire to receive any of these things. But I bet Microsoft itself has lots of ways to invite you to spend more money, and plenty of its partners (i.e., anyone who gives Microsoft a cut of revenue thereby generated) does too. It's cliché because it's true: if you’re receiving a service for free, you’re the product.

So far, not terribly awesome, but pretty standard fare. And in some cases, it’s even acceptable, but for a chat app, well, there are lots of alternatives that don’t insist on selling me to the highest bidder.

Then we get to this:

We also use the data to operate our business, which includes analyzing our performance, meeting our legal obligations, developing our workforce, and doing research.

So…this is vague enough that I’d say it means whatever Microsoft wants it to mean, which does raise the question of why this Privacy Statement is so long, if Microsoft is granting itself permission to do whatever they want with your data. Oh, right, it's so long so you won’t read it and notice this is in there.

And now, the kicker:

Our processing of personal data for these purposes includes both automated and manual (human) methods of processing. Our automated methods often are related to and supported by our manual methods. For example, our automated methods include artificial intelligence (AI), which we think of as a set of technologies that enable computers to perceive, learn, reason, and assist in decision-making to solve problems in ways that are similar to what people do. To build, train, and improve the accuracy of our automated methods of processing (including AI), we manually review some of the predictions and inferences produced by the automated methods against the underlying data from which the predictions and inferences were made. For example, we manually review short snippets of voice data that we have taken steps to de-identify to improve our speech recognition technologies. This manual review may be conducted by Microsoft employees or vendors who are working on Microsoft’s behalf.

TL;DR, you have no privacy in your communications on GroupMe. Microsoft is going to use it to train their AI and their employees. I'm not sure if GroupMe has voice capabilities, but if it does, Microsoft employees can listen in on your conversations (and “taken steps to de-identify” does not mean “de-identify”).

I prefer my private conversations to be private, and not used to train AI. That's all.

#privacy #GroupMe #Microsoft #software

One of the great things about using to-do lists is that it lets you separate planning from doing. You make a list of what stuff needs to be done and when it's due, and then you turn that part of your brain off. Tomorrow you look at the part of the list you labeled “TOMORROW,” and you just do those things. As long as you make time often enough to turn your Planning Brain back on and make a new list, you're mostly golden.

The thing about computers, though, is that they should be able to automate your planning (and therefore doing) in a way that makes things even easier for you; computers are good at automation—which is why it's so disappointing that most to-do apps are just digital equivalents of pencil and paper, maybe with notifications to remind you as the value-add. I have pencils and paper, and the lists I make with them at least have the benefit that I can give them to someone else if I need to, which I'm probably not going to do with my phone or laptop.

Here's a list of ideas to-do apps could do to help out planning, but mostly don't. They're in no particular order, and I've tried to give some reasonable examples of each.

Dependencies

Make tasks depend on other tasks. Don't even show me tasks whose dependencies haven't been met. For instance, don't show my “Dry laundry” at least until I've marked “Wash laundry” done.

You could even make a configurable delay, so that “Dry laundry” wouldn't show up until 30 minutes or so after “Wash laundry” was done, i.e., right about when the washer would be finished.

I'm not talking project management here, just some obvious clutter removal.

Smarter Repeating Tasks

Some to-do apps don't even allow repeating tasks at all! But most of those which do could stand to be smarter about it. Repeating tasks fall into four groups:

  • The task really has to be done as many times as it repeats for. If I skip paying my mortgage in January, I can't just pay for February and be done: I really have to pay it twice.
  • One time doing a task makes up for previous times. If I don't bother to get the mail today, I don't have to check it twice tomorrow; I just get the old mail and the new mail.
  • The task should be done some period after the last time it was completed. Haircuts, health checkups, oil changes, change your contacts, whatever.
  • The task should be done on the next available day. My garbage gets picked up Mondays and Thursdays, so my “Take the garbage to the curb” task should recur on the next available day. You can kinda fake ones like this by having multiple tasks on weekly occurrences.

Apps should allow for all these use cases.

The only thing I'm aware of that gets this pretty right is Org Mode, but Org is less a to-do list and more an information organizer—and you have to know Emacs to begin with.

Automatic Task Disposal

Some tasks if left undone, it makes no sense either to keep them or to mark them overdue. If I don't get around to taking the garbage out Monday, don't show me an overdue task on Tuesday—I literally can't do anything about it! Just delete it or mark it Not Done or whatever status sounds right, and remove it from view.

TickTick allows tasks to be removed as “Not Done,” but as far as I can tell it's purely manual.

Paused “Overdue”

Say there's a task I want to get to today if I can, but it's not actually due until next week—maybe a report my boss asked for. Show it as due “Today”; if I don't get to it to today, tomorrow again show it as due “Today.” Don't show it as overdue until it's actually overdue.

Always Due

Similar to the above, but slightly distinct, allow for tasks that are simply always due “Today.” Some apps do have some similar functionality, but call it “Habits” or something like that (TickTick again, and some specialized habit apps). I personally don't have trouble drinking enough water, but judging by the number of apps available for that alone, some people do.

Granular Priority

Most apps allow you to sort tasks by priority, but they generally only let you select High, Normal (or Medium), and Low. Keep these groupings, but within each group allow an optional numeric score for ranking when tasks are listed by priority (most people work from the top down).

This probably isn't useful for most people, as such, but could be for someone with a very large list of tasks. Mostly I mention it because of the next item.

Variable Priority

Say on Monday you add a Normal priority task with a due date two weeks in the future, so it gets a Granular Priority of 1.0. On Monday of next week, the GP goes to 1.1, Tuesday to 1.2, and so forth. Maybe on Thursday you pop it from Normal to High, too. Most people work from the top down of a list, so the closer something is to the top, the more likely it is to be accomplished.

Use Extra Knowledge

My iPhone knows when I get in the car because Bluetooth. Allow me to set a notification like “Remind me to do X when I'm out and about” triggered by that.

Or a shopping list that hides all its items until GPS shows I'm actually at the store. Again, reducing clutter.

Allow for Multiple Modes

Having a smartphone app is great. Having apps for major desktop platforms is even better. But making the app just available on the web is a winner. Everything has a web browser.

Needless to say, these should all sync with no fuss.

Task Assignment

Sometimes one person has to manage other people's tasks: parents making lists for their children, roommates sharing out chores, whatever. There are lots of ways this could work, but here's what I see as ideal:

  • Every person has an account. They can add their own tasks to their account.
  • Anyone can create a shared list with anybody else with an account. The person who creates it owns the shared list.
  • Tasks on a shared list may either be unassigned or assigned to one or more list members.
  • In general, anyone on a shared list can mark that a task is done.
  • Shared lists can optionally be locked down so that only the list owner or designated list members can add tasks, or must approve a task being marked Done.
  • Anyone on the shared list can signup for a notification that a particular task is done regardless of whose task it is.
  • For repeating tasks on a shared list, allow randomized (or weighted, the way Chorebuster does it) automatic assignment, optionally excluding some list members.

Don't Assume I'm Only Going to Use Your App

TL;DR, let me print things!

And no, the browser's “print this webpage” capability is not sufficient. Take the data and turn it into a nice PDF that actually looks like a to-do list. Have reasonable defaults, but let me specify a subset of tasks with a filter, let me specify a paper size; if it's out of a native app, let me specify a font if I want.

If I'm printing a shared list, let me print both tasks on individual pages by assigned person and a page with the full list. Let me do this at the same time; don't make me print one, go toggle options, and then print the other.

Automatically add a task for “Go to the app and mark these done” at the bottom of any printed list (but not in the app itself, that would be redundant).

Programmatic Access

At the very base level, give me a way to add tasks automatically. TickTick lets you send email to a special email address; I think I vaguely recall that Remember the Milk does too, or at least did.

Better yet, have an API.

Conclusion

Probably nobody's going to write a to-do app that satisfies me. But at least now I can tell them why I don't like theirs.

#software

I mentioned a while back that what we mean by “personal computer” could be very different had DEC made a different decision in 1973.

I discovered today that Leonard Tramiel, son of the late founder of Commodore Jack Tramiel, shared a similar anecdote on the software side of things:

After my first academic year in graduate school, I came home for the summer where I returned to the PET program at Commodore. One of the tasks I was given was to review a box of software that been submitted so that Commodore would sell the software. I didn't recommend that Commodore take any of the software. One piece of software deserves special attention.

I said that this piece of software wasn't worth selling because there was nothing that it could do that couldn't also be done by a nearly trivial BASIC program. One reason for having this view was that nearly all of the discussions that I had had with the people involved in producing the first personal computers centered around the primary use being to learn programming. So I was biased to think that everyone that used a PET would be able to write simple programs. The program I'm talking about was VisiCalc.

(emphasis in original)

VisiCalc, of course, was the first “killer app”.

#Commodore #history #computing #software

WriteFreely, the software this blog runs on, has a configuration option to also serve the site via Gopher. So I turned it on.

The experience isn't great: it appears to be just grabbing the Markdown-styled text from the database and presenting it. So links look messy, and there are no linebreaks inserted. But hey, it works!

As I write this, there are 330 other known Gopher servers online. Apparently I'm not the only one stuck in the Nineties.

#Gopher #software

I have enough machines running Fedora at home that I decided I'd like a local mirror. I don't actually need one, really, but I have the disk space and thought it'd be a nice quick project.

Fedora has a script called quick-fedora-mirror that they strongly suggest you use instead of using bare rsync. The script, unsurprisingly, assumes you're running it on Linux; but the particular machine I wanted to put the mirror on runs OmniOS. I could probably have simply used an LX branded zone, so it would get the “Linux” it expects. But where's the fun in that? Instead I decided to use a native Linked-Image, or lipkg, zone. I quickly ran into problems.

Getting flock(1)

While flock(2), i.e., the system call, is part of POSIX, Linux also has flock(1), a command-line tool to “manage locks from shell scripts.” The quick-fedora-mirror script uses this tool, which is part of the util-linux package (maybe the name should have been a clue). I grabbed the source for util-linux and unpacked it.

To begin, I needed tools, so after zlogin mirror to get in the zone, I ran pkg install build-essential.

I'm not a programmer, but being a Linux and Unix user since 1996, I'm familiar with the compilation dance, so I ran ./configure. It failed, but helpfully informed me that it required GNU make (illumos make is the default on OmniOS). The build-essential package includes it, so I tried again with MAKE=gmake ./configure. This worked. Well, it completed successfully, with warnings that it detected a non-Linux system and so several of the included utilities would be disabled. None of them were flock, so whatever.

Fortunately, the included Makefile doesn't make you compile everything; you can choose the utilities you want. Unfortunately, gmake flock failed almost immediately, with an error:

root@mirror:~/util-linux-2.37.2# gmake flock
  CC       sys-utils/flock.o
  CC       lib/monotonic.o
lib/monotonic.c: In function 'get_boot_time':
lib/monotonic.c:40:13: warning: implicit declaration of function 'sysinfo' [-Wimplicit-function-declaration]
   40 |         if (sysinfo(&info) != 0)
      |             ^~~~~~~
lib/monotonic.c:40:13: warning: nested extern declaration of 'sysinfo' [-Wnested-externs]
lib/monotonic.c:43:46: error: 'struct sysinfo' has no member named 'uptime'
   43 |         boot_time->tv_sec = now.tv_sec - info.uptime;
      |                                              ^
gmake: *** [Makefile:9483: lib/monotonic.o] Error 1

Now, again, I am not really a programmer, and definitely not in C; but lib/monotonic.c here is quite short, and I can read error messages. Looking at the lines the compiler complained about, I immediately saw they were in areas which had something on the order of:

#ifdef HAVE_SYSINFO
        (do something)
#else
        (do something else)
#endif

After searching some more around the web, I realized that the problem was here at the very beginning of lib/monotonic.c:

#ifdef HAVE_SYSINFO
#include <sys/sysinfo.h>
#endif

Long story short, it appears that while both Linux and illumos have a sys/sysinfo.h, the information they make available is not the same, nor in the same format. The man page for sysinfo(2), the function a programmer would use to get the information presented, outright says, “This function is Linux-specific, and should not be used in programs intended to be portable.” So the code in lib/monotonic.c was getting information back, but it wasn't what it expected; and therefore, failing.

I didn't see a reason for a file-locking tool to know my system's uptime (presumably that library is linked into others of the utilities where it would make more sense), so I just added #undef HAVE_SYSINFO directly above the check for it.

#undef HAVE_SYSINFO
#ifdef HAVE_SYSINFO
#include <sys/sysinfo.h>
#endif

That allowed flock(1) to compile (and run, which of course was not necessarily guaranteed) successfully.

I edited any reference to flock in the quick-fedora-mirror script to point to my binary.

Other Issues

The other issues were much shorter.

mktemp

Apparently, there are differences in how Linux/OmniOS mktemp handles the given filename “template” when creating the temporary files and directories. The script gave these nice, descriptive names. I didn't care about that, and didn't feel like digging into it; so I just replaced all the invocations with a plain mktemp or mktemp -d.

GNUisms

As above with make, the script appears to assume that all the system utilities are their GNU versions. So I replaced any invocation of awk, diff, or find with gawk, gdiff, and gfind.

Conclusion

I'm hesitant to say “And that's it!” because the script hasn't completed its first run.

But it is running, and does seem to be doing its thing. I'm done for now. If I run into any other problems, I'll write another post.

Many thanks to Dianna White and two other colleagues who prefer to remain anonymous for reading through this post and offering feedback and criticism.

#software #omnios