akater

> Is there an Interlisp echo in today’s development culture?

Emacs not mentioned. It better have been.

The question posed is, “With agents, does it become practical to have large codebases that can be read like a narrative, whose prose is kept in sync with changes to the code by tireless machines?”

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.

There is a difference. I write a Lisp program, and it runs everywhere Emacs does, including my Android device. I wouldn't do that with Java, as thaw would be extremely impractical. (I might be biased: I probably wouldn't be programming at all if Lisp didn't exist.)

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.

Could you provide an example of a Lisp program where macros are overused?

> Bolting packages (module system) on top of symbols leads to some problems in practice.

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.

An ordered pair is a useful data structure, and it's beneficial to have special short names for accessors to its elements. Humanity got very lucky with the names “car” and “cdr”. Naggum does point that out.

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.

Note that the value returned by cons is guaranteed to have type cons, and it is guaranteed that a fresh cons is created. Neither is true for list*; note that its return type is t.

If by “abstract” linear algebra you mean “course that starts with the definition of vector space”, then it is geometric enough in the sense Artin talks about.

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.

There may be different aspects to programs like this. They may provide calls, they may provide some other features that are significant to understand their influence on users but non-obvious to non-users.

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.

Another evidence that linear algebra concepts are terribly confusing when layed out without geometric background.

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.

For a non-technical text about a basic, broadly-appealing topic, this has disappointingly high level of mentions of something called “FaceTime”.

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.

So-called “anti-piracy” measures are futile. As long as something can be played back, it can be recorded, copied, re-played.

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.

> even if he was openly anti-Putin and supported opposition in any way

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.

Works fine now, thanks! Sorry I made noise like this, I tried to find alternative channels of communication that presumably should work when someone cannot login via web for any reason, and failed.

It looks like it's now impossible to login to gitlab.com web interface via Tor. I only post it here because it was a recent sudden silent change that made gitlab.com unavailable to some, and there does not seem to be a response.

> Live cheaply

> Be indepenedently wealthy

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

There's a fairly well-known 2018 book on why education (higher and lower) is the way it is now:

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

1. Everyone (except maybe for murderers and insane people) is a master of their body, so other people have no right at all to decide whether a sane non-murderer should be able to end his or her own life. This has nothing to do with any illness.

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 want to admin a server.

• 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.

Unless you go with commercial Lisps, you likely won't get far without Emacs.

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.

I believe it's important to find a community which would offer quality real-time help. I've seen some, and the really good one was not in English so I can't recommend it, I guess. Freenode emacs chat is said to be filled with offtopic; that's not my cup of tea but you might find it useful.

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)

I'm sorry but your comment will be grossly misleading to people unfamiliar with the language. There's absolutely nothing painful about If and Function. However, I must note that in a rule-based language both are used far more sparingly than they would be in an imperative, or even functional language. I found myself moving from If to Replace, for example.

Everything should be S-expressions, not just HTML.

> Repeated can sometimes be replaced by postfix ..

Always, not sometimes. ;-)

Indeed, you can just type “Hello world” in a text editor!

A non-programmer, I'm sure making it a welcome checkpoint at a programming language is an incredibly stupid tradition. It should always be an one-liner that does something no app in the world can do, with clearly identified spots that a newcomer can tweak for their individual needs.

Bravo, RMS.

I wish I could work on an OS written in Lisp, or in an equivalently expressive language. It's so damn important to have a really user-friendly system easily customizable by non-programmers. Actually, programmers should be routinely put out of their jobs, essentially the same way programmers put others out of theirs. :-)

> It's a lot easier to write Mathematica than it is to read it.

+1. And it gets even more easier to read (“read”? :-) when you can select pieces in FrontEnd, with multiple mouse clicks or a corresponding hotkey. I got so used to it that I actually developed phantom pains in my editing of Html or TeX (or whatever, for that matter).

I'm sorry but your links lead to the same continuity example that has nothing to do with real world (and real mathematics, as well).

Can you prove (0^0 = 1) -> (1 = 2), as you claimed above?

And no, we don't need “temporary definitions”. For any combinatorial investigation imaginable leads unambiguously to 0^0 = 1:

https://en.wikipedia.org/wiki/0%5E0#Zero_to_the_power_of_zer...

The only concept a general expression of the form x^y could possibly represent is the space of mappings y -> x. There's one and only one such mapping when x and y represent empty set. Arguing this to be wrong as in “but it can't be 1 because there are no mappings to empty space from non-empty sets!” ( = “0^x = 0”) is plain ridiculous. This definition simply does not fall apart. 0^0 is not a special case for it in any way.

Enumerating numbers one can represent with 0 digits put in a string of length 0 leads to the same conclusion. It's clear that there is one and only one string of length 0, unless you demand it to contain more than 0 digits, in which case there are none. [However, this combinatorial problem is not an independent one: it's equivalent to enumerating mappings from space of strings to space of chars.]

In other words, not only there are definitions that work well for all cases, including 0^0, there's actually only one such definition.

> "There is no one definition that always works well for 0^0"

Yes there is. :-) 0^0 = 1.

Actually, the only case for claiming it to be an “indeterminate”, comes from so-called “continuous exponents”. Which, arguably, something that never occurs in reality — only in exam sheets by lazy calculus teachers.

Whenever you meet an algebraic equation with sum over 0 <= k <= n… and there's some m^n or m^k in it, it's always only true when 0^0 = 1. I don't claim I've seen them all but really, try to find a counterexample. What exactly was that argument for indeterminacy you were talking about?

Those equations come from reasoning about meaningful entities, not chimeras of “x^x”, or “x^y”, or worse. Again, try to find, say, a physics paper with x^y in it. I haven't read much physics papers but I'm pretty sure you'll find precisely 0.

As one mathematician I knew put it, “hard analysis is the primary source of all obscurantism in mathematics out there”. ;-)