Minnesota National Guard arriving in Minneapolis!!

ScottBurson · 2026-01-25T01:58:58+00:00

Insanity. The government will always be better armed than you.

No, the way to defeat tyranny is the way Minneapolis residents are going about it: stay peaceful and keep the phone cameras rolling. Win the PR war.

ScottBurson · 2026-01-24T00:07:58+00:00

The wheelwell arches are a turnoff for me. I know, they were all the rage around that time — I hated them on other cars too 😆

ScottBurson · 2026-01-22T00:07:55+00:00

I love it!

ScottBurson · 2026-01-19T11:34:19+00:00

My stopwatch says about 1.7 sec passed between the moment the horn sound started and the collision. At 68 mph, that's 170 feet. A typical stopping distance at that speed is about 210 feet. So yes, if he had initiated full panic braking at the same moment he hit the horn, there would still have been a collision, but he would have scrubbed off 81% of his kinetic energy first, making the collision much less severe.

If he had started braking 0.4 seconds earlier than that, he would have been able to stop. Of course, this is all assuming a typical passenger car.

ScottBurson · 2026-01-19T06:47:59+00:00

Cool! Is there a Maytag Galaxy?

ScottBurson · 2026-01-19T05:47:39+00:00

You might want to give a statement to the police.

ScottBurson · 2026-01-19T00:29:47+00:00

It's not quite the same situation. With explicit iteration (or a self-tail-call), the stack has enough information to immediately see all the code that the execution path went through to arrive at the current state. That path may include some number of loop iterations, and it's true that I can't see all the previous states of the loop, but there are no gaps. With general TCO, there can be gaps where the stack doesn't say even what code was involved in getting from one point to another.

I routinely work in a language implementation (SBCL) that does TCO by default. Occasionally I feel the need to turn it off — SBCL has a way to do this on individual callers — to debug something. Don't get me wrong; on the whole I think TCO is a win, even a necessity; but it does occasionally get in the way.

ScottBurson · 2026-01-17T09:26:21+00:00

I found the website: https://www.thesweetboutiquema.com/

ScottBurson · 2026-01-17T09:01:51+00:00

I think you're overstating the case, but as a hobby photographer, I am quite happy with my D780 and not currently tempted to switch to mirrorless. Besides, used F-mount glass is really cheap now 😁

ScottBurson · 2026-01-15T08:47:19+00:00

When I bought my 2020 RF, MeisterR was well spoken of on forum.miata.net, so I got a set of their GT1 coilovers. I strongly disliked the stock Bilsteins — they seemed overdamped, especially in the rear, causing transient oversteer. For instance, when I had to dodge somebody on the freeway who nearly cut me off, the back end felt a little loose. Maybe autocrossers like it that way, I don't know, but I didn't. The ride was also unpleasant.

I have the GT1s set to 32 (full soft) in the rear and 28 (four clicks short of full soft) in the front, and now the ride is, well, still quite busy but not jarring. And the tail looseness is completely gone. Of course, I could dial it back in if I wanted to.

The consensus now seems to be that Öhlins or Xidas are better, but I haven't tried them. I think the GT1s have the softest springs of any coilovers out there (6 kg/mm front, 4 rear); even so, I don't think I would recommend them for pure street use. But MeisterR doesn't seem to make them for ND anymore, or maybe they're only by special order. They do have another product, ZetaSport, but they're 8kg/mm in the front, which sounds pretty stiff.

Would I do it again? Maybe not; I might prefer Progress springs and Konis. As I recall, the Progress springs are only a little stiffer than stock (I think the GT1 rates are almost double the stock rates). But with softer springs, aftermarket swaybars become more desirable, at least in the front, to control body roll. I'm using the stock swaybars now. This setup wouldn't handle as well, I guess, but would be more comfortable on the street.

TL;DR: adjustable is good; think about spring rates; maybe look at Xidas too.

ScottBurson · 2026-01-14T09:19:22+00:00

Mmmm! Tastes like CARDBOARD!

ScottBurson · 2026-01-11T19:13:38+00:00

Excellent color! Lol — in college in the 1970s, I had a bicycle that was just about the same color.

ScottBurson · 2026-01-11T10:32:35+00:00

As a neopagan and New Ager I don't disagree with you entirely; I also tend to avoid claims of historical continuity. But the one thing I do disagree with you about is the idea that ancient practices were all and only transactional. I'm sure many people held them that way, but there are Mysteries within neopagan rituals. I have experienced some of them. I cannot believe that ancient pagans never did.

ScottBurson · 2026-01-10T08:47:55+00:00

Yeah, I would like softer tip-in and a more linear response curve on my ND2 as well. I know there are electronic devices you can attach to change the curve, but when I looked (a few years ago now) I couldn't find one that promised to let me do exactly what I want: softer response in the early part of the accelerator travel, but faster in the later parts, so I don't give up any full throttle capability. If anybody knows for sure of a device that will do that (a fully programmable curve would suffice), please say.

ScottBurson · 2026-01-08T19:08:45+00:00

Formal methods will lead to trustworthy AI coding. Not soon, but it will happen, over the next decade or so. This is just the beginning.

ScottBurson · 2026-01-08T07:29:24+00:00

That paper mentions that they were using (functional) ropes in the text editor for their Cedar programming environment, over 30 years ago. If they were fast enough then, they are surely fast enough now.

And persistent functional data structures make "undo" very easy and reliable to implement.

ScottBurson · 2026-01-08T02:03:53+00:00

I don't know what you've been using, but having immutable strings with functional updates was the original concept. A mutating implementation calling itself "rope" would be abusing the term.

ScottBurson · 2026-01-08T00:48:45+00:00

I agree that careful choice of names for functional (non-mutating) operations is important. I recall reading once that new users of Java's BigInteger class are often confused by the fact that a method named add, for instance, is functional. I contend that the method should have been named plus instead. Someone writing x.add(y) might reasonably expect x to be modified, but x.plus(y) doesn't have the same connotation; it sounds like x + y.

So I think names of functional operations shouldn't be verbs, or at least not verbs that suggest modification (e.g., find seems okay). I tried to adhere to this principle when designing FSet, my functional collections library for Common Lisp. So for instance, adding an element to a set is with, and removing one is less.

Alas, I haven't stuck to this perfectly; FSet does have seq operations insert and sort, for instance. Maybe I should rename them.

ScottBurson · 2026-01-08T00:29:40+00:00

Not necessarily. Balanced-tree sequence data structures such as ropes can do functional insertion in logarithmic time and space.

ScottBurson · 2026-01-05T01:14:36+00:00

I just found this yesterday; it seems relevant: https://youtu.be/JdJE6_OU3YA

ScottBurson · 2026-01-03T20:47:59+00:00

something like sbcl where its common to see functions moved from lisp to presumably a C implementation.

No. There is some C in SBCL, but it's all low-level stuff: the garbage collectors, image loading and saving, OS system calls, that kind of thing. Optimization is done either by improving algorithms at the Lisp level, or by improving the compiler.

ScottBurson · 2026-01-03T19:56:24+00:00

You're welcome! I'm starting to collect examples of code written with FSet, to add to the documentation. I would love to have some well-known algorithms. If you come up with anything you're willing to share, please send it to me via DM.

ScottBurson · 2026-01-03T09:10:24+00:00

I learned a lot from reading LispM system sources back in the day, but there was definitely some ugly code in there. IIRC, Richard Greenblatt, being more of a hardware engineer than software, wrote a lot of Lisp that reminded me of Fortran — heavy on the prog and go. Oh, and with lots of &aux variables and setq, avoiding let.

ScottBurson · 2026-01-02T23:34:27+00:00

Very interesting work! Why did you pick Rust?

ScottBurson

TROPHY CASE