It's not practical to have codebases that can be read like a narrative, because that's not how we want to read them when we deal with the source code. We jump to definitions, arriving at different pieces of code in different paths, for different reasons, and presuming there is one universal, linear, book-style way to read that code, is frankly just absurd from this perspective. A programming language should be expressive enough to make code read easily, and tools should make it easy to navigate.

I believe my opinion on this matters more than an opinion of an average admirer of LP. By their own admission, they still mostly write code in boring plain text files. I write programs in org-mode all the time. Literally (no pun intended) all my libraries, outside of those written for a day job, are written in Org. I think it's important to note that they are all Lisp libraries, as my workflow might not be as great for something like C. The documentation in my Org files is mostly reduced to examples — I do like docstrings but I appreciate an exhaustive (or at least a rich enough) set of examples more, and writing them is much easier: I write them naturally as tests while I'm implementing a function. The examples are writen in Org blocks, and when I install a library of push an important commit, I run all tests, of which examples are but special cases. The effect is, this part of the documentation is always in sync with the code (of course, some tests fail, and they are marked as such when tests run). I know how to sync this with docstrings, too, if necessary; I haven't: it takes time to implement and I'm not sure the benefit will be that great.

My (limited, so far) experience with LLMs in this setting is nice: a set of pre-written examples provides a good entry point, and an LLM is often capable of producing a very satisfactory solution, immediately testable, of course. The general structure of my Org files with code is also quite strict.

I don't call this “literate programming”, however — I think LP is a mess of mostly wrong ideas — my approach is just a “notebook interface” to a program, inspired by Mathematica Notebooks, popularly (but not in a representative way) imitated by the now-famous Jupyter notebooks. The terminology doesn't matter much: what I'm describing is what the silly.business blogpost is largerly about. The author of nbdev is in the comments here; we're basically implementing the same idea.

silly.business mentions tangling which is a fundamental concept in LP and is a good example of what I dislike about LP: tangling, like several concepts behing LP, is only a thing due to limitations of the programming systems that Donald Knuth was using. When I write Common Lisp in Org, I do not need to tangle, because Common Lisp does not have many of the limitations that apparently influenced the concepts of LP. Much like “reading like a narrative” idea is misguided, for reasons I outlined in the beginning. Lisp is expressive enough to read like prose (or like anything else) to as large a degree as required, and, more generally, to have code organized as non-linearly as required. This argument, however, is irrelevant if we want LLMs, rather than us, read codebases like a book; but that's a different topic.

Lisp is the №1 enabler of Stallman's “Freedom 1”. Smalltalk might be close but I can't really say, and it doesn't look like I can install Pharo on my Android device. Nothing else even comes close.

Packages are namespaces, unrelated to modules. They are not used to organize dependencies but to remove ambiguity of naming and to provide encapsulation.

> The progress in CL development is severely hampered by the set-in-stone standard, small pool of users

The language is extensible, compilers do get new features added, sometimes in a coordinated manner. Standard being stable is not that significant an obstacle to moving forward; pool of users being small is much more noticeable. Yet more noticeable is that community is less healthy than the Emacs one. This comparison is valid because development in Emacs Lisp is attractive for the same reasons, unique to it and CL; they also happen to have extremely similar syntax. Elisp is moving forward steadily, and in recent years quite rapidly. CL would progress forward similarly, or better, had it had something like Emacs that provided that synergetic effect.

Any rule about any language could be labeled a barrier to its success because any such rule contributes to the cognitive load, making learning the language slightly more difficult than it would be without that rule. What matters more is how much cognitive load is there after you learn the rules. Common Lisp is very successful at it.

It is pedagogically a problem for people who ask questions like the one in topic. But it can also be a problem when one encounters bilinear form and linear operator in practice but can't distingish between the two. I can't think of a specific example but I was asked once about some problem (in electrical engineering, iirc) where the source of confusion was this; some transformations of a (square) matrix were natural while others were not.

Some people feel strongly about the topic—mostly those with “pure math” inclinations.

I never encountered FaceTime and I have avoided Facebook since I firnt saw it. Also, curiously, I've recently observed a group of like-minded people divided, in a fairly confrontational manner, unable to listen to each other, with one side being, according to my observanions, overrepresented on Facebook, compared to another, and the other overrepresented on Twitter.

This can be attributed to “echo chamber” phenomenon, or to platform preference by leaders of opinions. But my null hypothesis now is, Facebook actually changes its users to being worse communicators, unlike Twitter, and it contributes to users' feelings of isolation, significantly. I'm sure details of means of communication matter.

This had been criticised for decades. Competently and popularly presented criticism goes back to at least as far as 1957 (Artin's Geometric Algebra; see discussion of determinants somewhere near the beginning) but linear algebra is still often presented decoupled from geometry.

I wonder though if there's purely algebraic approach to matrices that explains as much (or more) as geometric one. Maybe approaching algebra of matrices consistently as an example of category algebra could be illuminating.

I have not yet read it all but I already have doubts it's worth reading further after second mention if author just expects all readers to be on Facebook or be familiar with a particular program to connect to others, or with an experience of usage thereof.

If watermarks become an issue, people will develop methods to mangle watermarks and make them unreliable in figuring out the source of the leak.

Any attempts to prevent copying by technical means are at odds with public ownership and use of general-purpose computers. The only reliable way to prevent people from making and sharing copies of data is to ban such computers or restrict their usage.

This implies he does not support opposition in any way. This is not true. He does support opposition rallies—when they are held to support his cause, true, but such is political climate in Russia that publically supporting those who vocally oppose the state policy is a domain for very few and quite brave.

When Libertarian Party of Russia was organizing a rally in 2017 to protest Telegram ban, Durov contacted the Party himself. (I'm a member of LP RU.)

I don't count on Telegram security but Durov's public image and actions are certainly noticeable and appreciated by opposition.

> Be indepenedently wealthy

Both are very good suggestions. And I don't think there are better ones around.

Bryan Caplan, “The Case against Education: Why the Education System Is a Waste of Time and Money”

2. See 1.

3. When cognitive function is damaged severely, the person cannot make decisions on their own, including decisions on whether they should live or die.

4. All voluntary interactions are fine.

• I don't understand what does it mean “to own a domain name”, what kind of ID is it tied to.

• I'd have to write a spam-resilient js-free https-free comments system. It'd take time, it'd have to be based on PGP, and in the end nobody would use it.

So I just worship my Fediverse Instance Admin Deity instead, for now.

Thus, one option to consider (esp. if you're not fond of learning by the book) is to just start learning Emacs since you will need it anyway, use Emacs Lisp to configure it and learn the basics hands-on way. That will likely feel “different” enough already to change the way you think about programming, if that's one of the goals.

No need for books, no need to setup anything, you're simply dropped into a huge introspection-enabled sandbox that is about to become your main tool.

Members of said lovely community thoroughly recommended Mastering Emacs to newcomers as a number one introductory text which I since do as well—mostly because they did. I also recommend built-in tutorial.

As for packages,

• helm or some other fuzzy completion thing; make sure your M-x, C-h f, C-h v do offer fuzzy completion, it improves discoverability greatly. Recent (27?) Emacsen may have something like this out of the box.

• avy: jump to positions on screen

• there are several packages that offer insert/command mode including the famous evil-mode but it's a good idea to get used to defaults. “Mastering Emacs” has something on this. I've heard macOS supports default Emacs keys everywhere (not true for other systems)

• which-key can display keys and commands available at the moment, quite helpful from the start. You can actually find some of this information with context menu but it is less convenient. The issue with which-key is, you need to configure it to actually see its stuff. A config for it may be found in the link below

• https://github.com/a13/emacs.d/blob/master/README.org is a cleanly written init file; if you want a starter config for package x, try searching there for (use-package x ..) expression, copy it to your init file, press C-M-x and it's applied (note: it will often download the package, too). Many popular packages and built-in features are covered. Tweak some parameters, C-M-x, observe the changes immediately.

• last but not least, to make use of many existing configurations out there, you will need use-package. So install it early and learn to load it on startup (see the very config above as a reference)