mzan @mzan@qoto.org

@samim to be fair I like political content, but the sad truth is that now-days it is usually associated to propaganda, repeated slogans, cheering, etc...

In this form it is for sure "toxic shit", because it is an useless battle between people speaking, but not listening.

In real life and with Mastodon toots, it is nearly impossible to change the political idea of other people. But, at the same time, it should be nice to exchange different point of views, and/or reporting some fact, without the claim to change other people mind.

But now-days, if you are sincere, you risk to be labelled and cancelled. There can be a grain of truth in every different political idea, but politicians like irrational extremism: if you don't think exactly like me, you are an enemy. So they can spend in campaign and slogans, but less in real actions 🙂

@nobodyinperson section 13 of AGPL says that if users can interact with a modified version of an AGPL program, then you had to distribuite under AGPL also the modified code.

But then we must define "modified version of a (A)GPL program"...

Using git-anex inside a shell script or a bigger service, is usually freely permitted, because it is covered by " This License explicitly affirms your unlimited permission to run the unmodified Program.".

But if the shell script or the bigger service is adding more functionanilities to git-anex, that should be considered as part of git-anex? Are you still an user of git-anex program/service, or are you extending it, circumventing the (A)GPL? Problably only a judge can decide this.

Usually if you are using git-anex like a service, then you can use it freely, and the larger service is not obliged to be under AGPL, because you are only an user of git-anex. Every time you improve git-anex, for working better inside your larger service, then you had to release only these improvements to git-anex, under AGPL.

But the line between using a service, and extending it, can be blur in some cases.

Note that in some cases, you can also produce a larger service, compiling git-anex code inside your "aggregate code", without the need to relaese the full "aggregate code" under (A)GPL. It is in the final part of section 5, but these definitions are not so much clear, IMHO.

@hayley @larsbrinkhoff Clojure is a PoW Lisp, while Common Lisp is a PoS. CL code is forever.

@hayley ah, I found recently this #commonlisp DSL https://nikodemus.github.io/screamer/ and it supports both global compilation and interactive programming. It is doing many tricks: it redefines "defun"; it performs a code-walk on the entire loaded package; it maintains a data-structure at run-time with Screamer-compiled/managed functions and their dependencies, and so on.

@hayley after you read enough posts, you didn't notice anymore rants about the Lisp parens. They just disappear :-)

@jcastp @daviwil Thinking on this, probably it is reasonable mastering Emacs Lisp only if the majority of work and workflow is done inside Emacs (e.g. shell commands, DBMS administration, document search, email and so on). In this case, one can integrate and automatize various parts of his workflow. The Emacs experience will improve to a level unmatched to many other environments like GNOME/KDE and probably also the Web.

For the rest, Emacs is so powerful and rich of extensions, that one can spend years discovering new tricks, without the needing to write a line of Lisp, except configurations. So, for normal usage, I think that Emacs Lisp is not necessary at all.

@hayley yes, I agree. Obviously my "without the needing to add other things" was a partial hype.

JVM now supports virtual-threads, but in CL threads are a de-facto standard and there are also DSL in CL for green/cooperative-threads and maybe it is not so hard to add something at the compiler implementation level.

Global user-specified optimizations are outside the scope of CL macro, because they can walk only local code. But you can put all the DSL inside a grouping macro, like Coalton is doing. In this way you can abuse the macros, but you can support more declarative DSL, needing a lot of analysis, and not only "stupid" code expansion.

C-like global optimizations can be supported from CL compilers, if one has a way to tell which parts of the implementation is sealed. CLOS has already an API for this, IIRC. Some commercial compilers are already doing this on normal CL code, IIRC.

OCaml added recently a very complete and powerful effect system, well integrated in the language. But the venerable conditions system of CL is good enough in a lot of cases, and still years ahead respect other mainstream PL.

@hayley

regarding this https://erights.medium.com/the-tragedy-of-the-common-lisp-why-large-languages-explode-4e83096239b9 to be fair, C++ is a large and complex language but it keeps growing. Also Java has new features, and/or more dialects like Kotlin.

Common Lisp can grow as libraries, DSL and macros (because it is an extensible language), but its specification is stable and immutable. It is a mature and usable language, without the needing to add other things.

@calebdenman

"A photo is worth a thousand lies" -- CIA

@NanoRaptor

@cmconseils

We need to be realistic. In November, 48% will win Trump, 44% will win Biden, 8% UFO will reveal us that we are on Candid Camera!

@m3tti because it is fun to use. It is the most interactive of all Lisp. You can test immediately functions. In case of errors, you can see the stack, with the values passed to the functions. These values are fully inspectable: you can navigate in structures and objects and so on.

The effect is that you can easily enter into the zone, and play with your code.

#commonlisp is also an extremely rich language, full of features.

@aral Usually the meaning of "no politics" clause means "no off-topic politics", because it is usually: a waste of time; divisive; without beneficial effects on the real-world.

You cannot solve all the problems of the world in a project. So you had to decide what are on-topic business politic decisions that are worth to discuss and share, and what it is outside of project scope.

@hayley we can annoy you better... I'm suggesting to the blamer (in a private message, of course) a rant about Lisp (SBCL) GC!

@jesus
Common Lisp is very performant and for large code bases it is probably faster than many C++ projects, because you can customize a lot of things about the memory layout of objects.

CLOS with MOP is very efficient (the OOP part of Common Lisp), and Common Lisp macro can give you all the benefits of C++ STL, and probably more.

@simon_brooke

@jesus It is only the first impression. I thought the same. Now, it is one of my preferred syntax.

But we are offended because you missed to offend explicitly also Common Lisp in the list! We prefer to be offended than being ignored! 🙂

It is a shame that in 2024, 35 years after Richard Stallman created the GPL, there is no EU or USA or international treaties taking in account copyleft licenses rights.

If a company A violates the GPL license, using the source code of a product P in a closed source product, then only the original authors of the product P can sue the company A, and only for the parts for which they own the copyrights.

Users of P and normal citizens cannot sue A. They have no "rights" to defend.