Dustycloud

Yes! But it's still valuable. How am I understanding your argument at all? I think my friend Jonathan Rees put it best: "Language is a continuous reverse engineering effort, where both sides are trying to figure out what the other side means." More on that: https://dustycloud.org/blog/identity-is-a-katamari/ This reverse engineering effort is important between you and me, in this exchange right here. It is a battle that can never be won, but the fight of it is how we make progress in most things.

Bluesky is neither decentralised nor federated. I wouldn't let that stop you from signing up for bluesky -- in my experience it is definitely the best of the options for a twitter alternative -- but you should know exactly what it is you're getting into before you get into it. And if you want to know exactly what you're getting into with bluesky, you should read this, which tells you more than you really want to know: https://dustycloud.org/blog/how-decentralized-is-bluesky/

Recommend this deep dive article to understand some of these issues: https://dustycloud.org/blog/re-re-bluesky-decentralization/

This piece by Christine Lemmer-Webber mentions Christine's very positive experiences working with Jay Graber. I consider CLW to be a reliable and trustworthy source of information, so I think it's relevant here. (Also it's really a very, very good analysis of Bluesky, by the co-author of ActivityPub, so if you're into that kind of thing...) https://dustycloud.org/blog/how-decentralized-is-bluesky/

No judgement (I think great puns bring great minds together so namespace clashes are inevitable), but this was similar to the thinking behind a name for "Guile Steel", the low-level Scheme being plotted about by some of the Guile Scheme folks here: https://dustycloud.org/blog/guile-steel-proposal/

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/

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.

> 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/

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.

Also called the AI bobsled https://dustycloud.org/blog/faulty-towers-vibe-sickness-and-the-vibe-b…

Credible exit was popularized by the co-author of ActivityPub. https://dustycloud.org/blog/how-decentralized-is-bluesky/ https://dustycloud.org/blog/re-re-bluesky-decentralization/

> [Bluesky] can't easily be taken over by an authoritarian billionaire creep It definitely can. Bluesky is not as decentralised as you think. https://dustycloud.org/blog/how-decentralized-is-bluesky/

Relevant post by Christine Lemmer-Webber (Co-creator of ActivityPub) https://dustycloud.org/blog/how-decentralized-is-bluesky/

https://pluralistic.net/2024/11/02/ulysses-pact/#tie-yourself-to-a-fed… https://dustycloud.org/blog/how-decentralized-is-bluesky/

As I understand it, there's an argument that while in theory you can, in practice you cannot so easily, e.g. you needed 5 terabyte of storage for a relay already some months ago. I think this[0] was on HN some time ago with good reasoning about bluesky offering a "potentially decentralized enough" while not actually being so. 0: https://dustycloud.org/blog/how-decentralized-is-bluesky/

> 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 got the impression from Christine Webber that the Blue sky protocol could not practically be federated, there's a bottleneck (relays iirc) that can only be properly implemented with huge resources, and which scales quadratically https://dustycloud.org/blog/how-decentralized-is-bluesky/

It's a "shared heap". There are relays that collect and pass the entire firehose of events through themselves to interested parties, there are PDSes that store each user's data, and there are AppViews that users interact with. It's not very decentralized and not at all self-hosting-friendly. In-depth article: https://dustycloud.org/blog/how-decentralized-is-bluesky/

For anybody else coming across this, a reply was made here: https://whtwnd.com/bnewbold.net/3lbvbtqrg5t2t Bit of a side note for my fellow protocol enjoyers: this site is WhiteWind which is another app on the atproto network. Bluesky is a microblogging app on atproto while WhiteWind is a long form blogging app on the same network. It's pretty neat. And Christine replied to the reply here which I believe is the terminus of this conversation: https://dustycloud.org/blog/re-re-bluesky-decentralization/

Regarding Bluesky's decentralization: https://dustycloud.org/blog/how-decentralized-is-bluesky/ (hint: not that decentralized after all)

That's why (A)GPL is so handy, it discourages value-extraction. As cwebber says: https://dustycloud.org/blog/why-i-am-pro-gpl/

Christine Lemmer-Webber (https://dustycloud.org/contact/) may be able to put you in touch with Ian's surviving partner.

> Node packages work much better Are you sure about that? I haven't seen a node app built from source on nixpkgs yet. That includes Electron apps like Signal Desktop, which is a bit disappointing. There is this article about trying to package jQuery on Guix: http://dustycloud.org/blog/javascript-packaging-dystopia/

Sorry but, Wisp already exists, twice! It's Lisp without parentheses: http://dustycloud.org/blog/wisp-lisp-alternative/ and a little Clojure-like LISP in JavaScript: https://github.com/Gozala/wisp

Here's a Lisp that's whitespace sensitive to avoid parens: http://dustycloud.org/blog/wisp-lisp-alternative/ Other techniques to make them less prominent is to use a text face or syntax highlighting to make them less prominent, e.g: https://github.com/tarsius/paren-face/ It's not that Lisp has many more parens as that it's simplicity mandates only 1 block structure is used to define s-expressions (lisp's AST), whereas other languages adopt multiple syntaxes for defining their different blocks structures, e.g. () {} [] <>, lisp only uses ().

Python: sure. JS: ... it's complicated. See this article for an introduction to the problems of attempting to match npm with principled package management: https://dustycloud.org/blog/javascript-packaging-dystopia/

The orig PhD thesis paper is what you want http://www.st.ewi.tudelft.nl/~dolstra/pubs/phd-thesis.pdf I use GuixSD, just because it's init system is in Scheme(guile) and the declarative syntax of system config and pkg definitions seem more straight forward to me and I prefer free software. You can easily run a GuixSD system with a mainline kernel if you want proprietary firmware blobs but so far I haven't had any issues with the default Libre kernel. There's a GuixSD presentation here http://dustycloud.org/misc/talks/guix/chicagolug_2015/guix_talk.html

> ETNs are very much like Lisp, except it removes the AST parse step (and the parentheses!), leaving the resulting programs simpler than their Lisp equivalents I don't see how this is different from: Sweet Expressions: - https://www.dwheeler.com/readable/ Wisp: - http://dustycloud.org/blog/wisp-lisp-alternative/ and some others.

Have a look at WISP, which I just found out about from this thread: http://dustycloud.org/blog/wisp-lisp-alternative/ LISP without parentheses.

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)