7 ms·
I know I am going to write an unpopular opinion and get downvoted for it, but here it goes... I am still not convinced by the general "we don't need to upgrade
by znpy 8y ago
I know I am going to write an unpopular opinion and get downvoted for it, but here it goes...
I am still not convinced by the general "we don't need to upgrade the Common Lisp specification" attitude.
It surely is remarkable as a specification, encompassing so many aspects of the language, yet it leaves so many other aspects to the particular implementation. Multi-threading for example is supported by most major implementations yet their syntax (and often, semantics) are very different from each other. Same goes for cooperative multitasking (corutines etc). Someone else could come up with other examples.
In my opinion a new committee should be formed, to standardize the syntax and semantics of these so common functionalities.
In this sense, the various C++ language working groups are doing a remarkable job. I wish something similar would happen in the Common Lisp world.
- blue1 8y agoa large part of the CL community treats the spec a bit like a sacred text, in the sense that it is both very good and impossible to change. The most important reason apparently is that there are no more the resources to do it. Maybe also the struggling commercial vendors do not want to standardize their offer to become too similar to open source implementations?
- znpy 8y ago> a large part of the CL community treats the spec a bit like a sacred text Amen!
- junke 8y ago> a large part of the CL community treats the spec a bit like a sacred text That's not my experience. I'd say that people know what the CL spec currently is, love its stability, and might fear what it could become after an "upgrade". Anybody can write something like CL21, for example, with one's own style and notations. That's why it is frowned upon to do so and to claim that "this" library is how "the" new Lisp should be. Part of growing in Lisp (and programming) is to learn how to work with a language, not against it, and avoid fixing what is not broken. However, I trust Common Lisp compiler developers and vendors to know how to make backward-compatible, useful changes: current common lisp environments have way more facilities and building blocks than the bare minimum required. They also know the pain points that currently exist in the standard in a way that goes beyond aesthetic things.
- blue1 8y agoIt seems to me that this is a case of making a virtue of necessity: since the language does not evolve, many have learned to love the fact that it does not. To me it looks a lot like a form of Stockholm Syndrome. I find interesting your remark that "anybody can write something like CL21". (Though, not all problems can be solved with a library, but let's stick to this side). In most language, you can't do this kind of customization. In Lisp you can, but anyone else can too, and the result is that after 25 years there is still no standard way to write a hash literal, for example, or to concatenate strings in a non-verbose way. It is difficult to claim that these are good things.
- phoe-krk 8y agoor to concatenate strings in a non-verbose way UIOP:STRCAT. UIOP is present on every contemporary Lisp image as a part of ASDF.
- blue1 8y agoI know it is easy. In this particular example, it is also trivial to write it from scratch. But, if UIOP:STRCAT is such a "standardized" solution as you claim, then I believe it should become part of a (hypothetical updated) Standard, not a second-class citizen behind a member of the ancient aristocracy like Lord CONCATENATE. What I mean is that I think there should be some kind of mechanism so that standardized solutions emerge (from widely used libraries for example) and become part of the Standard. Like it happily happens in many other domains.
- phoe-krk 8y agoI never said that the updated standard should not happen - quite the contrary. I'm saying only that a string contatenation function is already available on every modern Lisp image that has ASDF loaded, and is therefore usable from user code.
- junke 8y agoIn Go, in Javascript, in Python, in C++, you have the luxury of having thousands of people who just implement things for you while you sleep. See the list of "gold members" for the Standard C++ Foundation: https://isocpp.org/about https://isocpp.org/about. See the list for Python: https://www.python.org/psf/sponsorship/sponsors/ https://www.python.org/psf/sponsorship/sponsors/ There are people whose jobs is to work on that. When you write "it should become part of a standard", you use the passive voice: who is going to do it? In CL, the effort is focused on things that matter to each individual, or each company that uses it, and sometimes a (de-facto) standard library comes to life.
- throwaway487548 8y ago> treats the spec a bit like a sacred text, This is not necessarily bad, especially in the context of education. It is well known for ages that a bit of mystery and sacredness makes rather boring moral education much more emotionally charged. There are no active Common Lisp based courses, as far as I know, the last one was that one of the Alegro team, but it was rather an attempt of promotion and has been done without "religious vigor" unlike the famous CS61A by prof. Brian Harvey, which could be viewed as almost sectarian, especially the very first version from 2008. Similar course could be easily made based on Common Lisp, which includes more advanced concepts in CLOS. At least some zeal is good for education. CS61A and the original SICP course by the Wizards are good and still relevant examples.
- bitwize 8y agoIndeed. Common Lisp should be more like C++, where the right way to write Hello World changes every few years. If your language isn't moving fast and breaking things, it means it's abandoned and probably shouldn't be used for real work.
- blue1 8y agoI know you're being sarcastic, but even in the ANSI CL spec the word "deprecated" appears in some places. It's just that since nothing followed to it, the deprecation had no practical effect: the fixedness of the CL spec is just an accidental result of history. As an aging developer I also detest environments that break things every other day, but I have realized that on the other hand system that never move have indeed a tendency to wither, usually in comfortable niches, while the flow of things moves elsewhere.
- eschaton 8y agoMy main beef with treating the Common Lisp spec as a sacred text is simple: 1. There were things at the time that were not quite standardizable that are now. Examples: Some degree of concurrency, system definition, the CLOS meta-object protocol, networking. 2. There are things that were created or became important in the meantime that should be standardizable now: Unicode and localization, concurrency building blocks like threads and locks and queues and atomic operations, cryptography, compression, higher level networking (URLs, HTTP, etc.). 3. There are just bugs and holes and incompleteness in the standard due mostly to compromise from the then current vendors. For example, not everything fits the sequence protocols, the language isn’t CLOS all the way down, streams, etc. All this argues that there’s room for continued progress. The only good argument I’ve heard for why it hasn’t been pursued is “Who’d fund it?”
- blue1 8y agoI think it's evident now that a purely community-based effort to advance CL cannot realistically happen; even the CDR[1] is unmantained, and in the course of the last years many knowledgeable people have been progressively leaving the community, CL, or both. I am wondering how the "other" languages obtain funding for such things. For example, Julia raised $4M one year ago. Or should we acknowledge that no one cares about Lisp anymore? :( [1] https://common-lisp.net/project/cdr/ https://common-lisp.net/project/cdr/
- vindarel 8y agoJust to counterbalance and give some hope: projects like CLASP (CL on LLVM) got university funds to development it (and the ecosystem on the way: LSP library,…). https://github.com/clasp-developers/clasp https://github.com/clasp-developers/clasp CL is still adopted by universities (for bioinformatics it seems), or innovative firms (Emotiq (blockchain), Rigetti quantum computing,…), and is still used by big ones (https://github.com/azzamsa/awesome-lisp-companies https://github.com/azzamsa/awesome-lisp-companies), so why not see fundings in the future…
- deleted 8y ago[deleted]
- mdhughes 8y agoScheme moves forward because it's not a rotting corpse as LISP is pictured in that cartoon, it's a still-living language. Scheme's not admired for its purity and historic role, but because it's useful and fast. The R6RS/R7RS arguments are annoying (R6RS is right) but show that someone cares.
- blue1 8y agoI don't think Common Lisp can be called "pure": it's a language full of compromises (not in the bad sense of the word). Scheme was considered the pure sibling in the lisp family, at least initially.
- znpy 8y agoPlease let's not get into the Scheme vs Common Lisp flame, it's pointless. The discussion should be about how to keep the language alive and on par with the currently used technologies.
- blue1 8y agoIt was not my intention, it just sounded strange. I am not even sure whether being "pure" is a good thing or not :)
- mclehman 8y agoI think they meant even though Scheme is pure, that's not the reason people admire it. Rather, its speed and usefulness engender that admiration.
- mdhughes 8y agoRight, Scheme is used and those uses are reflected in the spec(s). The minimalism of Scheme is what makes it easier to optimize, but that's not why it's alive. If LISP users want their variant to stay alive as well, they need to follow that model of actually using it and documenting how it's used. Vengeful LISP zombies gonna downvote, of course, because they're bad people.
- vnorilo 8y agoThis. I was involved in a painful port of a large MCL codebase to LispWorks, and many of these platform and implementation specific behaviors are bound to pop up in any practical application. Threading, networking and FFI were the fundamental problems.
- varjag 8y agoThey all have portability layers for a long while now.
- znpy 8y agoOn a side note, I see that this post is actually generating some mixed response: can see it's vote count went up and down since I posted it. It has cumulatively gathered more upvotes+downvotes than the total of its comment (and comments to comments etc).
- olavk 8y agoI think the "I'm going to get downvoted for this..."-baiting leads to a lot of reflexive upvotes and downvotes regardless of the actual content of the comment.
- phoe-krk 8y agoIt surely is remarkable as a specification, encompassing so many aspects of the language, yet it leaves so many other aspects to the particular implementation. Multi-threading for example is supported by most major implementations yet their syntax (and often, semantics) are very different from each other. Same goes for cooperative multitasking (corutines etc). Someone else could come up with other examples. One of the arguments towards the "we don't need to upgrade the Common Lisp specification" attitude is that if we have multiple different implementations, each with its own interface to implementation-defined functionality, then we can successfully unify that interface as the language's users, without changing the underlying language. Portability libraries that offer uniform syntax for features that implementations define differently are the de facto standards in the Lisp community. To name some examples, networking (USOCKET), multithreading (BORDEAUX-THREADS), accessing the metaobject protocol (CLOSER-MOP), GC and weak data structures (TRIVIAL-GARBAGE), accessing the filesystem and operating system functionalities (UIOP). There are many others. -------------------- At the same time, I agree that the specification needs an upgrade. As soon as I find some time, I'll try to think of means of organizing such a committee and, if required, securing the funding for it.
- blue1 8y ago> As soon as I find some time, I'll try to think of means of organizing such a committee and, if required, securing the funding for it. That would be great!
- kazinator 8y agoFrom a just purely internal POV, ANSI CL has documented unresolved issues that could be nailed down. Example: When a dynamic control takes place to a targeted exit point, when are the intermediate exit points (the ones scoped within that one) torn down? The spec says they could be torn down gradually as the control transfer unwinds, or they could be torn down before the control transfer initiates. The difference is visible to the program: in an unwind-protect cleanup form, the intermediate exit points are still visible in the former implementation, but no longer visible in the latter implementation. I'm generally in favor of everything being as late as possible; the points should stay visible while their scope has not been traversed yet. That way the intercepting handler has the maximum choice: though it intercepted a distant control transfer, less distant control transfers are still available to it. In any case, 24 years is enough time to pick one behavior or the other and codify it. That's the proper job of a standard.
- cestith 8y agoI agree that perhaps a newer CL standard is called for. On the other hand, there's more to the Lisp family than Common Lisp. The Scheme folks have updated their standard a few times. Maybe it would be nice to see threading, Unicode, coroutines, and some other things put into a standard library with as little change to the core language as possible.
- flavio81 8y ago>In this sense, the various C++ language working groups are doing a remarkable job Really? Ask a big amount of C++ users... >I am still not convinced by the general "we don't need to upgrade the Common Lisp specification" attitude. I am, fully. The language can be extended by using the language.
- pfdietz 8y agoWell, some upgrades to the CL spec could be nice, but I'm not sure how essential they are. Package local nicknames would be nice, and perhaps some tighter specification of undefined behaviors. Because of how CL works, libraries are closer to language extensions that they would be in other languages. That may reduce the need for actual language changes. And libraries can be "standardized" by just maintaining a list of de facto standard ones. We're already seeing that. Changes for the sake of tidiness seem like a waste of time. I'd rather see the effort devoted to enriching the CL library ecosystem, adding more things to quicklisp, curating what is there, and keeping CL implementations up to date with changes in hardware.
- e40 8y agoThe original specification was extremely expensive to create, from the POV of a Lisp vendor. Today, there are few vendors left. In the early 00's, a bunch of users got together to create the next version of the specification, and only Franz and Lispworks were there (because they were the only ones left standing). It was a complete shitshow. The users were very enthusiastic about piling work on the two remaining vendors, and the vendors walked away from the table. I was there as a vendor, and it was frustrating. At the time, the users wanted to standardize multiprocessing APIs, yet no vendor had an SMP version of their API! For the decade after this aborted attempt, at least one vendor had to make lots of changes to their API. It would have been horrible to standardize the APIs of the time. None of the users wanted to hear this. This leads me to two main points: * Users not are the right crowd to standardize a language, because they do not have to implement the things they dream up. This is an important point. * Standardizing a multiple-source language when most of the sources are OSS, and the non-OSS sources are vendors do not derive much revenue from the language, is doomed to fail. It's economics. The best thing for Common Lisp: users make and support packages that work across many CLs, and users get the package via quicklisp.
- pfdietz 8y ago> The best thing for Common Lisp: users make and support packages that work across many CLs, and users get the package via quicklisp. This is why I'm hot for implementations to support package local nicknames. This extension will largely solve a problem that QL has: package name collisions.
- e40 8y agoCan you give me a pointer to some spec for them? It seems mostly obvious, but if there is an implementation out there, I'd like to check it out. Thanks.
- klibertp 8y agoI've been using this: https://github.com/avodonosov/local-package-aliases https://github.com/avodonosov/local-package-aliases in my StumpWM config and it works ok for me.