lispm

However, the point of all this discussion is that Lisp doesn't provide good enough language servers for modern editors,

They use the "language server" model since a long time, before Microsoft's LSP existed. Thus the need isn't really there, unless one wants to develop with Microsoft products (or similar) and get the needed extensions for Lisp into those Microsoft driven standards. If there were a real need and a real benefit, there would be some better adoption on the Lisp side.

That's exactly what I get out of the IDEs I've used for decades. This whole argument is so weird, disingenuous, and full of vague strawmen. Just because I don't see the value in investing the time that you have doesn't mean that I'm for giving up control or whatever you were trying frame me as.

I used IDEs also all the time. Makes sense to me.

Anyway, I'm done here. This site is full of toxic people who are offended that someone doesn't choose the same editor and habits that they do, and any dissent is to be punished.

Yeah, that's weird. You can use all kinds of editors you like. In the case of Lisp, there are arguments that good support for editing Lisp and for interaction with a Lisp runtime is useful (since Lisp is often used interactively). But several IDEs and editors can do that.

Just wanted to give you the impression that are others, who like IDEs and similar tools. ;-)

Can't say what and Interlisp did, but the MIT Lisp Machine and here the commercial variant Genera.

Files are versioned. The Lisp machine file system has versions (same for DEC VMS and a few other file systems). Nowadays the file version is attached to the name&type. Thus editing a file and saving it creates a new file with the same name&type and an updated version number. I can edit/load/compile/open/... files by specifying its version number. If there is no version number specified, the newest file version is used.

A site shared a namespace server with system registry and several file servers.

Code, documentation, etc. is defined as a system, similar to what ASDF does. A system has major and minor version numbers and other attributes (like being experimental or being released). Each time one does a full compile on a system, its major version gets updated and it tracks which file versions it used for that compilation. Whenever one creates a patch (a change of the sources) to a system, the minor version gets updated. After 12 full compiles and 30 patches to the latest version we have system FOOBAR 12.30. This data is recorded in the system directory, thus outside of an image (called a World in Genera) in the file system.

Now I can use that system FOOBAR in another Lisp and "Load System FOOBAR :version Newest" -> This will load system FOOBAR 12.30 into its runtime. Then new patches may appear in the system. I can then in a Lisp say "Load Patches FOOBAR" and it will look into the system directory for new patches to the current loaded major version and load those patches one by one. This changes the running Lisp. It then knows that it has loaded, say, FOOBAR 12.45, what files it has loaded and in which files the respective code (functions, ...) are located.

If I want to ship a system to the customer or someone else, I might tag it as released and create a distribution (with sources, documentation or not). The distribution is a file (also possibly a tape, a bunch of floppy disks, a CDROM, or similar). A distribution can contain one or more systems and its files (in several versions). On another Lisp I can later restore the distribution or parts of it. The restored systems then can be loaded for a specific version. For example I can load a released system version and then load patches for it.

A saved image knows which versions of what systems it includes. It also knows which functions sources are where. It may also have corresponding documentation versions loaded.

Later a source versioning system (called VC) was added, but I haven't used that.

That has been done in the past and was never widely supported. But the landscape is now slightly different. One approach might be to use ASDF (the most popular systems management tool), which then would need to be upgraded to use versions (and ideally have it integrated into a repository mechanism -> Git or similar... Also what are versions in a decentralized world?). ASDF operations then would need to be able deal with version numbers.

A Lisp image would then know/track which versions of what code it has loaded/compiled/... Version information would be stored with the other source files.

There is already confusion. Things are different and the same words (executable, native, image, ...) mean slightly different things.

In the CL world it is usually relatively easy to create an executable. For example in SBCL I would just run SBCL and then save an image and say that it should be an executable. That's basically it. The resulting executable

* is already native compiled, since SBCL always compiles native -> all code is AOT compiled to machine code

* includes all code and data, thus there is nothing special to do, to change code for it -> the code runs without changes

* includes all the SBCL tools (compiler, repl, disassembler, code loader, ...) thus it can be used to develop with it -> the code can be still "dynamic" for further changes

* it starts fast

Thus I don't need a special VM or special tool to create an executable and/or AOT compiled code. It's built-in in SBCL.

The first drawback: the resulting executable is as large as the original SBCL was plus any additional code.

But for many use cases that's what we want: a fast starting Lisp, which includes everything precompiled.

Now it gets messy:

In the real world (TM) things might be more complicated:

* we want the executable to be smaller

* we want to get rid of debug information

* we need to include libraries written in other languages

* we want faster / more efficient execution at runtime

* we need to deliver the Lisp code&data as a shared library

* we need an executable with tuned garbage collector or without GC

* the delivery structure can be more complex (-> macOS application bundles for multiple architectures)

* we want to deliver for platforms which provide restrictions (-> iOS/Apple for example doesn't let us include a native code compiler in the executable, if we want to ship it via the Appstore)

* we want the code&data be delivered for an embedded application

That's in the CL world usually called delivery -> creating an delivered application that can be shipped to the customer (whoever that is).

This was (and is) typically where commercial CL implementations (nowadays Allegro CL and LispWorks) have extensive tooling for. A delivered LispWorks application may start at around 7MB size, depending on the platform. But there are also special capabilities of ECL (Embeddable Common Lisp). Additionally there were (and still are) specialized CL implementations, embedded in applications or which are used as a special purpose compiler. For example some of the PTC Creo CAD systems use their own CL implementation (based on a ancestor implementation of ECL), run several million lines of Lisp code and expose it to the user as an extension language.

The way it's integrated with the host platform makes it better for most use cases IMHO.

That may be. ABCL is running on the host system and can reuse it, but it aims to be a full implementation of Common Lisp, not a blend of a subset of Lisp plus the host runtime. For example one would expect the full Common Lisp numerics.

One of its purposes is to be able to run portable Common Lisp code on the JVM. Like Maxima or like bootstrapping the SBCL system.

There is a bit more about the interop in the repository and in the manual:

https://abcl.org/releases/1.9.2/abcl-1.9.2.pdf

I didn't say "type declarations can lead to a messy middle ground in Common Lisp" - obviously they exist there for a reason, but, maybe they DON'T exist in Clojure, also for good reasons, no?

What were those reasons?

ABCL does exist, sure,

Would that count as a hosted implementation?

And yet UCSD Pascal was using a P-machine. So, the problem was the implementation and not the concept. Which was exactly my point.

My point is that implementations don't come from nothing. You can't just demand them to be there. They have to be invented/implemented/improved/... Companies at that time did not invest any money in micro implementations of Lisp. I also believe that there was a reason for that: it would have been mostly useless.

Temporarily. But then it died when the big money went away and left Lisp all but dead. All the while all the people using languages on those "toys" kept right on going.

Lot's of toys and languages for them died.

not to include type declarations because they can lead to a messy middle ground?

What? Type declarations in CL (which came from prior Lisp dialects) were added, so that optimizing Lisp compilers can use those to create fast machine code on typical CPUs (various CISC and RISC processors). Several optimizing compilers have been written, taking advantage of that feature. The compiler of SBCL would be an example. SBCL (and CMUCL before that) also uses type declarations as assertions. So, both the SBCL runtime and the SBCL compiler use type declarations.

why then it can't be 'hosted' like Clojure?

ABCL does not exist?

https://abcl.org

Lisp would have been really good relative to BASIC interpreters at the time

I see no evidence for that. Lisp was a pain on tiny machines with bad user interface.

64K is solid for a Lisp if you own the whole machine.

I had a Lisp on an Apple II. It was a useless toy. I was using UCSD Pascal and Modula 2 on it. Much better.

I had Cambridge Lisp on an Atari with 68k CPU. It was next to unusable due to frequent crashes on calling FFI functions.

The first good Lisp implementation I got was MacScheme on the Mac and then the breakthrough was Macintosh Common Lisp from Coral Software.

Had one of the Lisperati evangelized Lisp on micros

There were articles for example in the Byte magazine. Lisp simply was a bad fit to tiny machines. Lisp wasn't very efficient for small memory. Maybe with lots of work implementing a tiny Lisp in assembler. But who would have paid for it? People need to eat. The tiny Lisp for the Apple II was not usable, due to the lack of useful programming environment.

Alas, they were off charging a gazillion bucks to government contracts.

At least there were people willing to pay for it.

Lots of us hated doing assembly language programming but had no real alternative.

I kind of fail to see Lisp as an alternative to assembler on mid 80s micros.

Though, there were several cheap Lisps for PCs...

The OP has a good criticism of why this is a bad idea. It's an old idea, mostly from LISP land, where early systems saved the whole LISP environment state. Source control? What's that?

Symbolics Genera can save (incremental and complete) images (-> "Worlds"). The image tracks all the sources loaded into it. The sources/files/docs/... of the software is stored on a central (or local) file server.

I can for example start an initial world and load it with all the wanted software in the various versions I want. Maybe I save a new world from that.

I can also start an pre-loaded world and incrementally update the software: write patches, create new minor/major versions, load patches and updates from the central server, install updates from distributions, ... Maybe save new worlds.

The "System Construction Tool" tracks what code is loaded in what version from where.

A bunch of things work in implementations, while but are not standard conforming.

actually, according to the LOOP syntax, the REPEAT clause has to follow the FOR clause...

So I can replace my #3 above to wrap something with quotes instead of parentheses.

That's M-" .

if he was using Clojure he wouldn't be having the problems with nconc that he talks about"

Yeah, one would write the implementation in Java.

Common Lisp (and Lisp in general) often aspires to be written in itself, efficiently. Thus it has all the operations, which a hosted language may get from the imperative/mutable/object-oriented language underneath. That's why CL implementations may have type declarations, type inference, various optimizations, stack allocation, TCO and other features - directly in the language implementation. See for example the SBCL manual. https://sbcl.org/manual/index.html

For example the SBCL implementation is largely written in itself, whereas Clojure runs on top of a virtual machine written in a few zillion lines of C/C++ and Java. Even the core compiler is written in 10KLOC of Java code. https://github.com/clojure/clojure/blob/master/src/jvm/cloju...

Where the SBCL compiler is largely written Common Lisp, incl. the machine code backends for various platforms. https://github.com/sbcl/sbcl/tree/master/src/compiler

The original Clojure developer made the conscious decision to inherit the JIT compiler from the JVM, write the Clojure compiler in Java and reuse the JVM in general -> this reuses a lot of technology maintained by others and makes integration into the Java ecosystem easier.

The language implementations differ: Lots of CL + C and Assembler compared to a much smaller amount of Clojure with lots of Java and C/C++.

CL has for a reason a lot of low-level, mutable and imperative features. It was designed for that, so that people code write efficient software largely in Lisp itself.

upto 4tb storage

all four now use lexical scope. Scheme also supports dynamic scope.

1-lisp or 2-lisp is also a difference, though all support lexical closures and function objects.

Racket now has a variant without s-expressions. That's also a huge difference.

common lisp, emacs lisp, racket and scheme are different languages with exact same syntax

Far from it. On the s-expression level there are already differences. On the actual language level, Common Lisp for example provides function definitions with named arguments, declarations, documention strings, etc.

For example the syntax for function parameter definition in CL is:

    lambda-list::= (var* 
                    [&optional {var | (var [init-form [supplied-p-parameter]])}*] 
                    [&rest var] 
                    [&key {var |
                           ({var | (keyword-name var)} [init-form [supplied-p-parameter]])}*
                    [&allow-other-keys]] 
                    [&aux {var | (var [init-form])}*]) 

yeah, what you say makes no sense, since it has nothing to do with reality.

A reputation has to be earned again and again.

I would trust a company more if their random features sending data are opt-in.

A non-advertized feature, which is not independently verified, which about image contents? I would be prefer independent verification of their claims.

Could you motivate someone to do those fixes?

The CDU is a large party, not a particular large "organization" in terms of full-time CDU employees. The bureaucracy of the CDU is in no way responsible for nominating/selecting the EU President of the Commission.

Ursula on der Leyen was 2019 supported by Angela Merkel (Chancellor of Germany) as the future president of the EU commission. That's no secret. Macron also supported her. The European Council then nominated Ursula on der Leyen and she was accepted by the European Parliament. The Parliament is directly elected the citizens of the European Union.

The election of her was kind of unfortunate, since it was signalled by parties that the election to the parliament will also find the proposed EU commission president. But that was not the case. Since a candidate was not found (various parties and governments were not happy with the proposed candidates), the European Council finally proposed Ursula von der Leyen, which then also got a majority in the parliament.

The "CDU bureaucracy" ? What is that? The CDU is a political party.

Generally about the appointment of the commission:

https://commission.europa.eu/about/organisation/how-commissi...

Look at the thousands of years of Europe. People were moving in Europe, to Europe and from Europe. If they did not had the freedom to do so, it was often done by force. Wars, slave trade, migrations, ... that has been in our history for thousands of years.

Now EU citizens can do it peacefully.

Freedom of movement in the EU also does not mean "people can move freely in Europe". It's a right for EU citizens. Not for all people. It's also for people who can actually afford to live at a new place.

Preserving a cultural heritage does not mean regions are suddenly cultural museums. Cultural regions also are not by single nations, they span across several nations or nations have several cultural regions.

For example in Germany there wasn't a 'Nation' for much of the history. Much of the culture came out of changing regions. Visit Munich, Aachen, Lübeck, Danzig (not even a part of Germany today) and look at their history. Different. Look at their cultural history: different. They are now living in a FEDERAL republic of states (Danzig is even in Poland, now). A Bundesrepublik of Bundesländer. This FEDERAL republic is also a member of the EU. People from German regions can move freely in the German states. They also can move freely in the EU.

Cultures in Europe developed and mixed since the beginning of human settlement on this continent. Now it still happens, peacefully.

I live in Northern Germany. There was an intense cultural exchange for hundreds of years, spanning several regions. Do you think that this is suddenly not a part of my cultural heritage?

Don't you think that modern transportation, modern communication, change things? Don't you think we need to find answers to changes? That we cope with changes? This platform here is international in English, from the US, spreading innovations and discussions about it. Don't you think that this has effects? Deep cultural effects??? Freedom of Movement in the EU is one of the answers to these changes we see.

Currently 20 of 27 EU members have the Euro adopted.

an EU member state (present or future) cannot be forced to adopt the Euro

Future members can be forced. They won't become EU members, without a clear will to adopt the policies which lead to the Euro.

The Swedish government has said repeatedly they don't plan to join despite being legally obliged to do so.

Sweden is long in the EU. CURRENTLY the expectation to new member states to join the Euro when joining the EU is different -> much higher.

Sweden was also long not in NATO. Now it is. Similar, support in polls for Euro introduction is rising.

I preferred the culture and diversity that came from each country having its own national identity.

We still have or national identity. I live in Hamburg/Germany. Our identity is largely European since hundreds of years (see for example our history in the Hanse), before the German nation existed. We have a strong Regional and European identity.

Why would we celebrate the EU's efforts to homogenise our national cultures?

The EU doesn't do that. In many ways it actually preserves local (and also regional) cultures. It sets a framework for democracy and law in Europe.

I preferred the EU when it was a trading union as opposed to a utopian political experiment.

A trading union doesn't influence culture and politics?

The EU was never thought as just a trading union. It was set up as a process to get a peaceful Union for the European Countries after hundreds of years of wars. After the WWII which made clear that lasting peace can be achieved by deep cooperation.

Usage of mines for example...