Dustycloud

> that the power of lisp macros comes from this questionable, but distinctively lispy, syntax

No. It comes from homoiconicity. In this case, everything is a list. Because Lisp has great support for modifying lists, you can do some wonderful things with it. Wisp [1] comes without parentheses, but still has the same macro system, and the same power.

> If there were some better known examples of what lisp macros were good for

When the language gets in your way. That's it. Everything else can be a lambda. Lisp macros only start to seem pointless, because Lisp itself is a flexible language.

But, some real world macro examples?

Mutating functions. (setf and the like.)

Compile-time contracts. [0]

You have a key-value list that you dynamically constructed, and want to bind it. Let can't just take a list, but a macro can handle it.

Killing boilerplate, that involves bound values. (This one spoils you. Other languages become infuriatingly inflexible about it.)

[0] Can't find the paper right now, but it relied on compile-time macros to validate types at compile time in a (large) subset of Common Lisp.

[1] http://dustycloud.org/blog/wisp-lisp-alternative/

Guix, apt, yum, etc. are effectively language-independent package managers. They can and do provide large numbers of Python, Rust, Go, R, etc. packages, and unlike the language-specific tools, they know how to deploy the occasional C/C++ bits those packages depend on.

The problem is not so much technical but rather social in my view. For one, it's quite "natural" for language developers to try to grow their community around its very own tools, even if those tools effectively "cut corners".

The other "social issue" has to do with practices: packagers and users of the generic GNU/Linux tools I mentioned have different expectations in terms of having a curated package set, ensuring common conventions are followed, building software from source, and so on. This is at odds with the practices encouraged by some of the language-specific package managers.

Npm does not try to manage complexity, as explained at https://dustycloud.org/blog/javascript-packaging-dystopia/, Java packages often come with opaque jars that nobody builds from source, sometimes due to circular dependencies, and so forth.

I feel like there's a lot of appealing to prevailing HN sentiment in this post. So much so that there's little substance. What actual things are you worried about or unhappy regarding with Bluesky? It's not perfect, and if you have problems with its decentralization posture, Christine Lemmer-Webber has a fantastic post [1] detailing her problems with the protocol. Bluesky has the AT Protocol underneath it and has infrastructural components that can allow other entities to run Bluesky.

So my problem with this post, and general griping like this, is that by leaning so heavily on a shared boogeyman (that of "enshittification" or whatever) that there stops being concrete actionable complaints and more just general anger. Solutions can only come when we discuss problems.

At times a cynical portion of me even thinks this sort of posting is just low-key karma farming too, but I know that's too uncharitable a take, and I realize venting to the in-group can be therapeutic.

[1]: https://dustycloud.org/blog/re-re-bluesky-decentralization/

He expressed something similar to what he had said in the forementioned talk, that conventional mathematical notation is unhelpful, and that we ought to be able to express things more clearly as programs. I agreed that I find conventional mathematical notation unhelpful; when I try to read papers there are concepts I easily understand as code but I can't parse the symbolic math of. "There's too much operator overloading", I said, "and that makes it hard for me to understand in which way a symbol is being used, and papers never seem to clarify." Sussman replied, "And it's not only the operator overloading! What's that 'x' doing there! That's why we put 'let' in Scheme!"

https://dustycloud.org/blog/tag/sussman/

Looks like you are not the only great mind to think of this (although I do also think that a diagram with some text can lead to the clearest explanations)

There is a link to a video in that where Sussman explains the notation although there may be better ones also.

> which would make migration between instances seamless.

Which instances? :)

If you're referring to "Personal Data Stores", sure. However, it's the "Relay" (i.e. the aggregator that generates timelines) that everyone relies on is centralized. In contrast, with Mastodon for example, both "Personal Data Store" and "Relay" functionalities are decentralised, offering a complete solution with no centralised choke-points. At least that's my non-authoritative understanding.

There is this lengthy blog post, _How decentralized is Bluesky really?_ [0], if you want to read more about the differences between Bluesky and ActivityPub (e.g. Mastodon).

[0] https://dustycloud.org/blog/how-decentralized-is-bluesky/

I wouldn't say "dumb down" but it definitely needs to explain why it took some lines of reasoning. With deep learning, you need to rebuild the whole system with different test-cases to change a minor behavior.. but imagine if we could just say "Why did you do that? XYZ. And adjust it: "Oh, gotcha. You can't because of ABC", and then the AI has that problem solved. I guess that would be the next step in AI. I think it's called symbolic reasoning.

Here's a very good article: http://dustycloud.org/blog/sussman-on-ai/ (A conversation with Sussman on AI and asynchronous programming)