If your security relies on a password, you will always be anxious that somebody, somewhere, has somehow figured out what it is and already has access to your bank account.

No I won’t. All my passwords are something like I0!2b6KJ!eA04WiJ&&MFToCQ7CN*4mvb and each is used for only one thing because I’ve been using a password manager for over a decade.

I see 2FA as mostly a mitigation for users reusing passwords between services, which users of password mangers usually don’t. Of course, the password manger itself can be a single point of failure.

That gets you sued.

Saying that your moderation team determined private messages sent from the account constituted a serious violation of the acceptable use policy does not. They should have said that much.

Mine just says I might like brands I’ve bought repeatedly and might own items I’ve bought accessories for.

The company said it regretted the impact and was offering affected nonprofits a free “concierge service,” a meeting with a Microsoft specialist to help set up a new Microsoft 365 environment and answer questions.

After that experience they’re going to do business with Microsoft again?

Mine doesn’t have anything of a particularly personal nature, just obvious stuff from purchase history like:

• Likely favors Merrell brand for outdoor footwear (I have purchased the same model of Merrell shoe several times)
• Hikes frequently (a reasonable guess about someone who repeatedly buys hiking boots)
• Likely has a ThinkPad laptop (I bought trackpoint caps)
• Likely owns an Olympus camera (I bought a battery for an Olympus camera)

Ctrl should be on the key that says “CapsLock”, and for me, it is.

You can swap Ctrl and Fn in the BIOS.

My newer model can kernel panic as well as any model!

I had a T470 previously, and the mechanical build quality and materials of the P14s III are superior.

There’s a reason Linux on a Thinkpad is a meme.

You haven’t said much concrete about your requirements, use case, or budget, so I don’t have a recommendation much beyond whatever Thinkpad meets your requirements. The “serious” models in the T, P, and X series tend to be preferable to the others.

I love mine!

Macs have a hardware secure enclave that apps can use to store keys where other apps can’t access them. Apple itself does not seem to be making adequate use of it here.

It’s not clear exactly what Apple is going to impose here. In principle, trying to ensure users understand the implications of a permission is good. In practice, Apple is famous for keeping users from making decisions they might reasonably want to make on phones, and it’s starting to creep into the Mac; installing an app Apple hasn’t signed requires the command line, for example.

I read the article, and I think DickHertz’s comment is pretty much right. The article’s example illustrates the point:

For example, Inc. columnist Jason Aten recently discovered that Meta’s Muse AI assistant somehow had synced his entire local Messages database and was using those messages as context for its tasks.

Aten did not understand that the Messages database is stored on the disk (presumably) unencrypted and readable by anything with full disk access. He got a result he didn’t want because he did not understand the implications of granting that permission, and Apple seeks to add more friction to the process to protect users from making that mistake.

ActivityPub doesn’t work that way, but you can follow public Mastodon accounts using RSS.

This seems to be a common position, and I share much of it. I usually don’t want to do anything all that fancy on my phone, but once in a while, some edge case comes up where what I want and what the manufacturer or OS vendor has decided to approve differ.

In those situations, I insist on having the last word.

I’m surprised that so many technically-adept people find this acceptable.

Not necessarily the bit about compiling software directly on the phone; I can do that and I don’t, but the part where Apple has the last word on what apps can exist (yes, I know there are some very narrow escape hatches).

I was tempted, but nobody learns anything from that.

I have the impression the author of the article has dabbled with Lisp but hasn’t actually set up a reasonable development environment and written something non-trivial. That’s not a great position from which to write critiques of a language.

To add to the point about homoiconicity, both the article and my toplevel comment mention thread macros. The article talks about them being equivalent (syntactically at least) to method chaining, which I agree with.

The thing is, to get method chaining, the language has to have an object system, and the functionality you want to use has to be written in an object-oriented style. To get a thread macro, you need ten lines of code (aside from the docstring and metadata).

Yes. Well, sort of.

The actual quality is homoiconicity, meaning that code in the language is represented in the language’s own data structures (beyond the entire source file being a string). This enables structural macros - using the language to manipulate code before execution.

Some languages have tried to do this without the language syntax actually being data structure literals. Rust does it, but a typical Lisp macro looks like a simple template where some things are marked to happen at compile-time and others get spliced in at runtime. Rust macros don’t beyond the most trivial examples.

The first example actually has more bracket pairs (7) for Javascript than for Lisp (6). Rainbow bracket modes for editors can help when bracket matching is an issue.

This example which suggests counting parens is also solved by rainbow brackets, and/or editor tooling like paredit-mode that won’t even let you type mismatched brackets:

(f (g (h (i (j)))))

And in most modern Lisps, one might use a thread/pipeline macro instead:

(-> (j) i h g f)

With mixed nesting, Lisp programmers often use newlines to improve clarity:

(aap noot ((mies wim) zus) (jet teun vuur))

becomes

(aap noot
     ((mies wim) zus)
     (jet teun vuur))

A later example in the post does that:

(sum
  (filter
    (split (read (open "input.txt")
                 ",")
    (lambda (it) (> it 0)))

Which makes one of the errors it contains clear: “,” should be an argument to split, but here it is an argument to read. It is aligned with the start of the first argument to read, so that’s very visible. There are also two levels of unclosed parens. Pasting it into an editor made that clear instantly.

This version is correct:

(sum
 (filter
  (split (read (open "input.txt"))
         ","))
  (lambda (it) (> it 0)))

But I’d probably write this with a thread macro:

(-> (open "input.txt")
    read
    (split ",")
    (filter (lambda (it) (> it 0))))

It’s possible to write unreadable Lisp, but people who are good at Lisp don’t. This is true of most languages.

If it supported infix notation (outside of reader macros), it wouldn’t be Lisp.