#lisp on 2021-03-22 — irc logs at freenode.irclog.whitequark.org

00:12 <pillton> jasom: Do you plan on making nyaml a streaming parser?

01:52 <MrtnDk[m]> Xach https://adeht.org/dump/vid-2021-03-20T2217.mp4

02:10 <notzmv> quick question, how do I select a restart numbered from 10 on up?

02:51 <MrtnDk[m]> notzmv From ten to what? 30? (iota 30 :start 10)

02:55 <notzmv> I had an interrupt and the restart I wanted to select on SBCL was the 11, but it went to the 1 directly

03:04 <Nilby> notzmv: If you're in SLIME I think you can put the cursor on the restart and press enter, or you can press 'I' and pick the restart name with completion in the minibuffer.

03:07 <fiddlerwoaroof> I'm trying to figure out how to copy a generic sequence into a freshly allocated vector

03:07 <fiddlerwoaroof> is (map 'vector 'identity seq) guaranteed to copy? (I assume so, because MAP can't really make assumptions about the function passed)

03:12 <Nilby> fiddlerwoaroof: That makes a new vector, but the objects are likely eq.

03:14 <fiddlerwoaroof> That's fine with me, I'm just trying to write a simple shuffle that doesn't modify the input sequence

03:15 <fiddlerwoaroof> My favorite thing about LOOP is that it's basically the psuedocode people write algorithms in

03:15 <fiddlerwoaroof> Here's Wikipedia: https://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm

03:15 <fiddlerwoaroof> Here's the algorithm translated to LOOP: https://fwoar.co/pastebin/70e2d5427962a2015f33ef1484b5dff91bb3e7f4.lisp.html

03:16 <moon-child> weird they use an en dash

03:16 <moon-child> that's supposed to only be for numeric ranges afaik

03:17 <Nilby> Nice. It's like direct translation.

03:18 <fiddlerwoaroof> Yeah, I had this experience a while ago when I was doing an algorithms course on Coursera

03:18 <fiddlerwoaroof> I could basically copy the pseudocode and tweak it a bit and the result read more or less like the code in the text

03:20 <Nilby> I wonder if pseudocode like that was taken from a lisp version. the "downto" is

03:21 <Nilby> distinctive

03:22 <Nilby> I guess a "such that" in loop would be confusing.

03:23 <fiddlerwoaroof> Anyways, I realized once I parallelized my raytracer that randomizing the order in which I streamed the lines to the browser would give me a better sense of the whole picture more quickly

03:24 <Nilby> Nice. I like those raytracers where you can scribble where you want it work more :)

03:28 <Nilby> fiddlerwoaroof: I assume you know about alexandria:shuffle, optimizations of which were discussed here last week

03:28 <fiddlerwoaroof> Nilby: I do now :)

03:28 <fiddlerwoaroof> Fisher-yates is so simple, though

03:32 <jcowan> Does anyone understand why #.(values) returns nil rather than disappearing from the file being read? That would seem to be more useful.

03:36 <Nilby> I think it does disappear. Perhaps you're using it in place that defaults to nil?

03:37 <jcowan> Typing #.(values) to the REPL returns NIL.

03:38 <raeda> '(a b #.(values) c) => (A B C) in the SBCL REPL, as expected

03:38 <minion> raeda, memo from fiddlerwoaroof: there's also #abcl which isn't very active, but is more dedicated to developing ABCL

03:38 <Nilby> Not for me :(

03:38 <jcowan> Okay, it's just a bug in CLISP

03:38 <Nilby> What REPL and implementation are you using?

03:39 <jcowan> I confirm it works in sbcl.

03:39 <Nilby> Ahh.. Yes. And probably just in the REPL not in code.

03:40 <Nilby> The CLISP repl has a few "quirks".

03:41 <jcowan> You can kind of see why: it thinks #. expects one value, and since there are none, it returns NIL. #.(values 1 2) however evaluates to 1.

03:42 <fiddlerwoaroof> It works like '(a b #.(values) c) => (A B C) in lispworks too

03:42 <fiddlerwoaroof> There's a nil in the output in ECL

03:43 <fiddlerwoaroof> no nil in CCL

03:43 <fiddlerwoaroof> no nil in abcl

03:44 <fiddlerwoaroof> So, it sounds like clisp/ecl produce '(A B NIL C) and all the others '(A B C)

03:44 <jcowan> The CLHS seems to be open. "#.foo is read as the object resulting from the evaluation of the object represented by foo" implies there is exactly one object, so what happens if there are no objects returned is unspecified.

03:44 <fiddlerwoaroof> (I don't have allegro, though)

03:44 <jcowan> http://clhs.lisp.se/Body/02_dhf.htm

03:44 <fiddlerwoaroof> I think every expression in lisp evaluates to some value, though

03:45 <fiddlerwoaroof> clhs values

03:45 <specbot> http://www.lispworks.com/reference/HyperSpec/Body/a_values.htm

03:46 <jcowan> If it returns no values, though, whether it becomes nil depends on the surrounding context.

03:47 <fiddlerwoaroof> "primary value n. (of values resulting from the evaluation of a form) the first value, if any, or else nil if there are no values. "

03:47 <fiddlerwoaroof> From the glossary

03:48 <fiddlerwoaroof> so (values) evaluates to NIL, by definition

03:48 <jcowan> So you think that sbcl is wrong?

03:48 <fiddlerwoaroof> I think so, #.foo should be replaced by the result of evaluating foo

03:49 <fiddlerwoaroof> Which is NIL

03:49 <fiddlerwoaroof> (eq (eval '(values)) nil) => NIL

03:49 <fiddlerwoaroof> Sorry => T

03:50 <jcowan> It's clear that the coercion from no values to nil happens when the expression is a function argument.

03:50 <jcowan> IMO it is more useful to make it disappear from the reader.

03:51 <Nilby> This is weirding me out. clisp is technically correct and sbcl is wrong?

03:54 <fiddlerwoaroof> I guess it's not strictly true that every form produces a value (go tag) doesn't, for example

03:54 <Alfr> clhs 3.1.7

03:54 <specbot> Return Values: http://www.lispworks.com/reference/HyperSpec/Body/03_ag.htm

03:58 <Nilby> go doesn't return, so it doens't return a value, but 3.1.7 is pretty specific "if the form produces zero values, then the caller receives nil as a value."

04:00 <Nilby> and in 2.4.8.6 is says: "#.foo is read as the object resulting from the evaluation of the object represented by foo."

04:01 <Nilby> so I guess old clisp is right.

04:01 <fiddlerwoaroof> The question is, though, is READ the caller?

04:02 <fiddlerwoaroof> There's a little bit of ambiguity in the phrasing "resulting from the evaluation of the object"

04:03 <beach> Good morning everyone!

04:03 <fiddlerwoaroof> hi beach !

04:03 <Nilby> Good morning.

04:03 <Alfr> Hello beach.

04:03 <raeda> I would say READ is the caller of read time expressions

04:05 <jcowan> I think there used to be a facility in MacLisp that let you splice things into an S-expression for read purposes.

04:06 <asarch> One stupid question: can a structure be inheritable?

04:06 <asarch> Just like the way a class is

04:08 <beach> clhs defstruct

04:08 <specbot> http://www.lispworks.com/reference/HyperSpec/Body/m_defstr.htm

04:08 <beach> asarch: See the INCLUDE-OPTION.

04:10 <asarch> Thank you!

04:10 <asarch> Thank you very much beach!

04:11 <jcowan> Ah, yes. CLtL1/2 says "The function may choose instead to return zero values (for example, by using (values) as the return expression). In this case, the macro character and whatever it may have read contribute nothing to the object being read."

04:13 <jcowan> This is used by an example definition for ;, which has to eat the comment and return nothing.

04:14 <Nilby> jcowan: Nice find. So sbcl does it the cltl2 way, which makes sense given it's pre-CL pedigree.

04:14 <jcowan> Does cmucl go back before ANSI too?

04:15 <Nilby> Yes, from spice lisp.

04:15 <jcowan> if so, that would explain why sbcl does it that way

04:15 <beach> I think they all do.

04:15 <asarch> Another stupid question: so what's the point of CLOS if defstruct could easily provide the same functionality (or ever better since it doesn't "contaminate" the name space with lots of functions made by :accessors)?

04:15 <jcowan> Flexibility

04:15 <beach> jcowan: And that's the reason there is so much innovation to be done. :)

04:15 <jcowan> "The ability to return either zero or one value is the closest Common Lisp macro characters come to the splicing macro characters of MacLisp or the splice macro characters of Interlisp. The Common Lisp definition does not allow the splicing of arbitrarily many values, but it does allow a macro-character function to decide after it is invoked whether or not to yield a value, an option not possible in MacLisp or Interlisp."

04:16 <notzmv> Nilby: I'm using sly, but thanks anyway, I think that might work as well. in any case I've already fixed the underlying problem so it's a bit moot for now haha

04:16 <beach> asarch: DEFSTRUCT is very limited. No multiple inheritance for instance. Plus, without CLOS you would not have generic functions.

04:16 <jcowan> (same place, CLtL2 22.1.5

04:16 <jcowan> )

04:17 <beach> asarch: And DEFSTRUCT does not specify the semantics of redefinition, which is why I never use it.

04:17 <asarch> "Semantics of redefinition"?

04:18 <jcowan> asarch: The effect of redefining a struct type is unspecified

04:18 <beach> asarch: You have an executing Common Lisp image. You load a DEFSTRUCT form, you work a bit, then you decide it wasn't right, so you add or remove something and you load it again. Now you have undefined behavior. Not so with DEFCLASS.

04:19 <asarch> If I do: (defclass taco () ((quantity))) isn't the same as (defstruct taco quantity)?

04:19 <fiddlerwoaroof> No, redefining taco invokes the instance update protocol

04:19 <beach> asarch: DEFCLASS has specified semantics when you redefine it.

04:19 <jcowan> No: structure types are not the same as class types (or built-in types)

04:20 <fiddlerwoaroof> Is the sequence (defstruct foo ...) (unintern 'foo) (defstruct foo ...) specified?

04:20 <fiddlerwoaroof> i.e. does it result in undefined behavior?

04:20 <beach> asarch: That's why Common Lisp is a "dynamic language" or an "interactive language". You can redefine things after the fact.

04:20 <beach> asarch: DEFSTRUCT ruins that completely, because the implementation can then do anything it sees fit.

04:20 <asarch> And for the class taco I could easily: (defun quantity ((instance taco)) ...) and (defun (setf quantity) ((instance taco) val) ...)

04:21 <jcowan> It gives you a tradeoff between efficient but inflexible types and less efficient but highly flexible types.

04:22 <beach> asarch: What does that mean? Did you mean defmethod?

04:22 <beach> asarch: If so, you are using a feature introduced by CLOS.

04:24 <fiddlerwoaroof> The thing that took me a while to realize is that CLOS is basically Java-style OOP turned inside-out

04:24 <fiddlerwoaroof> Instead of the emphasis being on classes, the emphasis is on the operations

04:24 <beach> That's an "interesting" way of describing it.

04:25 <aeth> asarch: Structures are for low-level efficient stuff. They have many downsides to allow implementations to optimize them. If you're not writing C in CL, then you probably don't need them. And you have it backwards. Structures contaminate the namespace with lots of functions because they're not generic functions. Defclass creates generic accessors so e.g. there's only one NAME, not a dozen FOO-NAMEs

04:25 <beach> I think of it as object-oriented programming done right.

04:25 <fiddlerwoaroof> Reading AMOP really made this clear: they don't describe CLOS by talking about the classes but by talking about hte protocols the classes implement

04:25 <jcowan> "Generic functions are the good parts of OO."

04:26 <fiddlerwoaroof> beach: I agree, but it took a while for me to relate CLOS to what I already knew

04:26 <beach> Ah, yes, I see.

04:26 <jcowan> the Smalltalk ANSI standard also talks about protocols (which do not exist in the language) that you must implement rather than classes you must implement (the exceptions being Object and Exception)

04:27 <fiddlerwoaroof> I think something got lost when the industry adopted OOP

04:27 <jcowan> Rather, when it adopted dumbed-down OOP

04:28 <asarch> (defstruct taco quantity) and then (setf (taco-quantity my-dish) 10)

04:28 <beach> asarch: What is your point?

04:29 <asarch> I mean, what if you don't to change things

04:29 <asarch> Like my HTML form generator, for example

04:29 <fiddlerwoaroof> jcowan: I think single-dispatch object systems tend to lead to a mental model where classes "own" methods, though

04:29 <beach> asarch: If you don't change things, you must be a wizard developer. Unique in fact.

04:29 <asarch> Just a way to keep things together (class, name, label, etc properties of the HTML element)

04:30 <fiddlerwoaroof> Alan Kay always said the point is messages, but it never seemed to really get through to people

04:30 <beach> fiddlerwoaroof: I totally agree, and he has explained it more later.

04:30 <beach> In fact, he imagined distributed computing, with messages being sent across a network.

04:31 <jcowan> I think it's unfortunate that defmethod implies defgeneric

04:31 <asarch> CLOS doesn't send messages, right?

04:31 <fiddlerwoaroof> I also think single-dispatch has the issue where there's a "special" function argument for no particularly good reason: if a function can dispatch on the "this" argument, why not all the others?

04:31 <beach> asarch: Correct.

04:31 <asarch> It uses generic dispatch instead

04:32 <beach> jcowan: Absolutely. We have changed the way we view "convenient defaults" over the decades.

04:32 <beach> fiddlerwoaroof: It does make sense if you need to send a message to an object on a remote computer, though.

04:33 <beach> Of course, once class-based object orientation was adopted by Java, there was no reason to keep it.

04:33 <jcowan> Eh. I think hiding the distinction between remote and local method calls is a mistake: there are so many more failure modes.

04:34 <beach> Well, I get the hives whenever there is talk about remote anything, because I don't understand how preserving identity and garbage collection could work then.

04:35 <Nilby> If you use CLX you're basically doing RPC.

04:35 <beach> Yes, and that's already problematic.

04:35 <beach> You have to delete your windows and graphics contexts for instance.

04:36 <Nilby> Actually you don't, and turns out there's a gc-like part of the X server.

04:36 <beach> Great, so it knows when the application is holding on to such an object?

04:36 <Nilby> But, it's not done right, so it's not very flexible.

04:37 <Nilby> Yes, or at least sometimes.

04:37 <beach> That is truly amazing. That means that the X server must know about the heap structure of every Common Lisp implementation.

04:38 <Nilby> Not exactly. You just get errors when things go away, but it does keep something of a mirror of the object structure.

04:40 <Nilby> The gc-like part could also be considered conservative. It only cleans up under certain circumstances.

04:42 <Nilby> But interestingly I think there was some thought about both sides being Lisp. It was just less feasible in those days.

04:43 <beach> That would be a good thing. The Xorg server on this computer definitely has memory leaks. An X server in Common Lisp would be a good thing.

04:43 <Nilby> I quite agree.

04:43 <beach> Now who was it that started such a thing (called clxs)? Was it gilberth?

04:43 <Nilby> If emacs was CL the whole SLIME/SWANK thing is like RPC too.

04:44 <beach> Yes, and I am working (though not very hard at the moment) to get rid of that.

04:45 <Nilby> Same. It's pretty long work.

04:46 <beach> It's just that I am busy with other things. But there might be some recent hope...

04:47 <beach> It is not terribly complicated. I imagine SWANK/SLIME is way more complicated because of the need to encode everything on a wire protocol.

04:47 <Nilby> Oh really. Activity in Climacs?

04:47 <beach> On Second Climacs, yes.

04:49 <Nilby> Sadly I think the complexity in SWANK is there even without the RPC.

04:50 <Nilby> Not to mention the parts that have been build into the implementations.

04:50 <beach> Nilby: Oh? Why is that?

04:51 <Nilby> Things like determining where some function/form/snippet really live in editing buffers, debugger breakpoints and stepping, etc.

04:53 <beach> I think this is public, since scymtym gave the link in #sicl: https://techfak.de/~jmoringe/second-climacs-1.ogv

04:53 <fiddlerwoaroof> beach: I really wonder what the "multiple dispatch" version of distributed computing is

04:54 <beach> fiddlerwoaroof: Yes, it makes my head hurt to think about it. Hence my reaction to "remote anything".

04:54 <fiddlerwoaroof> Like, I wish I could define a "generic function" and have the compiler decide what to run on which machine

04:55 <beach> Nilby: I see, yes. Part of the issue is the implementation of source tracking in the Common Lisp system.

04:55 <Nilby> beach: Nice. That does look like some improvements!

04:55 <beach> Nilby: It is a start.

04:55 <fiddlerwoaroof> There is already a programming system that is designed around the idea of "programming for the network": https://ballerina.io

04:55 <fiddlerwoaroof> But, it looks mostly like a typical new language, feature-wise

04:58 <fiddlerwoaroof> I've been working on distributed systems of one form or another for the last several years, and I'm still dislike that we don't have any way to program the system as a whole, including things like allocating tasks to nodes.

04:58 <beach> Nilby: The other main stumbling block (other than the fact that I am busy with SICL) to significant progress on Second Climacs is that I need to figure out a way to represent indentation rules, now that we have much better knowledge of the role of different expressions in the buffer.

04:58 <stylewarning> What's the simplest way to check that a symbol S is of a package named P? Anything simpler than (string= P (package-name (symbol-package S))) ?

04:59 <fiddlerwoaroof> Instead we have programs that run on each node and then things like Kubernetes manifests that describe how to run your program

04:59 <beach> (eq (symbol-package S) (find-package P))

05:00 <stylewarning> beach: that sounds better; thanks

05:00 <beach> Sure.

05:00 <stylewarning> (I don't know why I had my doubts that the packages wouldn't be EQ)

05:00 <beach> Moi non plus.

05:01 <Nilby> beach: That's certainly something that could use work. I'm not sure if any software anywere (maybe except Zmacs) does indentation right.

05:02 <beach> Exactly. I kind of know what to do, but so far my attempts have resulted in lots of code duplication.

05:04 <fiddlerwoaroof> For Javascript, I've been using a tool called prettier that basically parses your source code and then pretty prints it every time you save the buffer.

05:04 <fiddlerwoaroof> It'd be really nice to have something like that for CL

05:05 <beach> Sort of. Comments need to be preserved though.

05:06 <fiddlerwoaroof> Yeah, prettier only changes whitespace, basically (and incidental punctuation like translating " -> ' and adding semicolons)

05:06 <beach> The "parse result" feature of Eclector does that, so it's not a problem. But pretty-printing is too primitive. I don't see myself having an opinion on whether the programmers wants to insert newlines or not, for instance. So that needs to be preserved as well.

05:06 <fiddlerwoaroof> So, I've found that the biggest advantage is that I can just type my code out in a line and it'll look nice after I save i

05:06 <fiddlerwoaroof> it

05:07 <fiddlerwoaroof> So, things like adding new lines and spacing actually turn to be really useful

05:07 <beach> But, yeah, my "solution" is similar in that it would compute the indentation, given that comments and newlines are preserved, and then indicate the result to the programmer.

05:07 <fiddlerwoaroof> Also, having a policy for those things helps minimize accidental diffs in version control

05:07 <beach> Adding such a feature would then be almost trivial.

05:08 <fiddlerwoaroof> The tool would be useful if only to correct peoples pastebin code when they ask for help :)

05:08 <fiddlerwoaroof> You could have an IRC bot that automatically reformats pastes and then tells people to learn how to format their code

05:15 <beach> Heh, good point!

06:00 <asarch> "All classes defined by means of defstruct are instances of the class structure-class." <- !

06:01 <beach> So?

06:01 <asarch> So, structures are *also* classes?

06:01 <beach> Every Common Lisp object is an instance of a class.

06:01 <beach> Try (class-of 234)

06:02 <asarch> #<BUILT-IN-CLASS COMMON-LISP:FIXNUM>

06:02 <beach> See?

06:03 <beach> Now try (class-of (class-of 234))

06:04 <asarch> So, in theory, if I: (defclass point () ((x ... :accessor x))) and then (defstruct rect (p1 (make-instance 'point)) (p2 (make-instance 'point))) and then (defgeneric draw (instance)) (defmethod draw ((instance point)) ...) I could (let ((r (make-rect))) (draw r))?

06:04 <asarch> #<STANDARD-CLASS COMMON-LISP:BUILT-IN-CLASS>

06:06 <moon-child> asarch: yes, generics work for all types

06:06 <beach> Well, R is a RECT and not a point, and you have a method only for RECT.

06:06 <beach> But yes, a method can specialize to any class.

06:07 <beach> Er, you have a method only for POINT.

06:07 <asarch> (defmethod draw ((instance rect)) (format t "Hello, from rect's draw!~%"))

06:08 <beach> No problem.

06:08 <moon-child> asarch: you can even do this (defgeneric fac (x)) (defmethod fac ((x (eql 0))) 1) (defmethod fac (x) (* x (fac (1- x))))

06:09 <moon-child> (though you can't use arbitrary predicates, only eql)

06:13 <beach> asarch: A class is a Common Lisp object, and since every Common Lisp object is an instance of a class, so is the class BUILT-IN-CLASS, and it happens to be an instance of the class STANDARD-CLASS.

06:18 <asarch> Bingo! https://twitter.com/B_Galileo/status/1338248778365558786/photo/1

06:18 <asarch> Oops! That's not

06:18 <asarch> https://sellout.github.io/media/CL-type-hierarchy.png

06:19 <asarch> standard-class and structure-class are at the same level

06:30 <beach> asarch: What do you conclude from that fact?

06:32 <asarch> Well, you said is actually danger to use structures because you can't change them later

06:33 <beach> Yes, STRUCTURE-CLASS is defined so that modifications do not have defined semantics.

06:34 <asarch> But in terms of "comfort", I think is much faster just (point-x instance) than (slot-value instance 'x)

06:34 <beach> Nobody is stopping you.

06:35 <asarch> I had problems with the accessors of the classes of my HTML generator because I had some other auxiliary functions named like them

06:36 <beach> You started by asking why CLOS is needed at all, and it was explained to you. Without CLOS you could not have defined the generic functions and the methods in your example. And if you want to quit your Common Lisp image each time you redefine a struct, that's up to you.

06:36 <fiddlerwoaroof> I almost never use slot-value

06:36 <fiddlerwoaroof> explicitly, at least

06:36 <asarch> I had to rewrite them adding the suffix '-taco' so the code would work

06:36 <beach> asarch: That is your problem, not that of CLOS.

06:37 <asarch> (name-taco instance), (value-taco instance), (element-class-taco instance), etc

06:38 <asarch> (slot-value instance 'name), (slot-value instance 'value), (slot-value instance 'element-class), etc

06:38 <fiddlerwoaroof> Yeah, I just do (%slot-name :reader slot-name ...)

06:38 <beach> I recommend you use accessors rather than slot-value.

06:38 <fiddlerwoaroof> Then (slot-name instance)

06:40 <asarch> "I recommend you use accessors rather than slot-value." <- But what if you have "normal" functions named like those accessors?

06:40 <asarch> WARNING: redefining COMMON-LISP-USER::DRAW in DEFUN

06:41 <mfiano> By using slot-value you are bypassing any protocols put in place. It is therefor a good reason to use different symbols for slot names than accessors, (such as prefixing with % and not exporting as mentioned) so consumers of a package cannot veer far from the intended use.

06:42 <mfiano> If you are building up some object by calling slot-value, you are preventing users from extending the behavior with method qualifiers.

06:43 <asarch> I thought this was like C++: class point {public: void taco();}; and class rect {public: void taco();}; and even void taco();

06:44 <asarch> So the compiler knows what 'taco' I am actually using

06:45 <mfiano> I would suggest reading AMOP, or better, the HyperSpec. CLOS is an integral part of the language, and not understanding how to use it, is really hurting you in regard to the gestalt of the language.

06:46 <asarch> Yeah, you're right. I am in a blind point

06:49 <beach> asarch: Why on earth would you deliberately choose to have a slot accessor that has the same name as a function that you also named yourself?

06:51 <beach> ... and then complain about it.

06:51 <asarch> Well, for example, every HTML element has a 'value' property, so, the normal would be to have an accessor with that name so one could: (setf (value instance) "...")

06:51 <beach> That's fine.

06:52 <mfiano> I am not understanding the issue, really, but it sounds like a lesson in separation of concerns and packages.

06:53 <beach> asarch: Why on earth would you deliberately start by defining an ordinary function with a name that you know you will later want to use as the name of a slot accessor?

06:53 <beach> ... and then complain about it.

06:53 <asarch> And also, in the code I use and auxiliary function called 'value' written months before this idea called value that actually (cdr (assoc "..." (cdr (car _parse)) :test #'string=)) in the "POST" method controllers

06:54 <asarch> I am not complain about it, I'm just was asking

06:55 <beach> The answer is "don't do that".

06:55 <asarch> Packages, right. I thought packages was for very big code

06:55 <mfiano> No, they are a complement to good protocol design, which is a complement to good software design.

06:55 <beach> asarch: You should create a coherent interface known as a "protocol" to your data structures.

06:56 <asarch> Ok. structures, don't. classes, yes. If your accessors chokes with other functions, keep them in a package. Clear!

06:58 <beach> asarch: I tend to divide my programs into "modules" where each module has a separate directory, a separate ASDF system file, and a separate package.

06:58 <beach> That organization makes it easy then to define a protocol for each module.

06:58 <mfiano> Structures are fine to use in low-level code that won't be changing. It is usually done much later in development if one needs that though, as they hurt interactive development.

07:01 <asarch> And the HTML form generator is not big enough to use the sophisticated things like a protocol for it. It is just one function that concatenate lots of strings

07:01 <beach> That sounds like a lame excuse to avoid learning about modular programming.

07:01 <fiddlerwoaroof> This is the sort of thinking that leads to all the messes I have to deal with at work :)

07:02 <beach> fiddlerwoaroof: YES!!!!

07:02 <mfiano> Oh yes indeed.

07:03 <asarch> Following the three virtues of a programmer :-P

07:05 <fiddlerwoaroof> I don't think people really understand how much thinking like "I just need to get this done" ends up costing companies

07:06 <srandon111> hello all, i am new to lisp, and i still have to choose the lisp flavor i like, i tried different lisps/schemes, but now i would like some reccomendations to some lisp which is efficient and good to create command line apps, i need to generate standalone executables for different OS... what lisp would be better for these purposes ?

07:06 <fiddlerwoaroof> Partly because management has no choice but to trust the programmers they hire to act professionally and in the best interst of the company

07:06 <beach> fiddlerwoaroof: Certainly, CTOs don't, or they would do something about it.

07:07 <beach> srandon111: This channel is dedicated to Common Lisp, so that's the recommendation you would probably get.

07:07 <mfiano> srandon111: This channel is about Common Lisp specifically. If you are looking for a dialect to choose, we can only speak of that. You may find ##lisp more on-topic for discussing others

07:07 <srandon111> mfiano, ok so does common lisp satisfy my requirements ?

07:07 <beach> srandon111: SBCL is an implementation of Common Lisp that generates fast code.

07:07 <mfiano> Yes

07:07 <srandon111> i mean is it possible with common lisp to generate standalone executables ?

07:07 <mfiano> Yes

07:07 <srandon111> i mean is it possible with common lisp to generate standalone executables ?

07:08 <mfiano> Most Lisps fit your criteria

07:08 <beach> srandon111: But the executable is kind of big.

07:08 <srandon111> beach, how can i compile to a standalone executable with no external libraries need ?

07:08 <srandon111> like a sort of statically linked exe

07:08 <mfiano> It depends on which implementation of COmmon Lisp. That is not something the language itself provides.

07:08 <beach> srandon111: I never generate executables, so I don't know.

07:09 <flip214> srandon111: completely avoiding libpthread and libc etc. isn't really that practical...

07:09 <srandon111> mfiano, SBCL

07:09 <mfiano> save-lisp-and-die

07:09 <flip214> but there are patches floating around for SBCL, ISTR. And I guess you can also recompile ECL to a static binary.

07:09 <srandon111> mfiano, ?

07:09 <mfiano> That is the function to search for in the manual

07:10 <srandon111> mfiano, i mean i have this common lisp script, what sbcl command should i use ?

07:10 <mfiano> I just said!

07:10 <moon-child> (sb-ext:save-lisp-and-die "output-filename" :toplevel #'your-main-function :executable t)

07:10 <flip214> srandon111: https://www.timmons.dev/posts/static-executables-with-sbcl.html

07:11 <srandon111> thanks moon-child flip214

08:24 <flip214> does someone have a CBOR library for CL? https://en.wikipedia.org/wiki/CBOR

08:26 <moon-child> flip214: not sure, but there is for msgpack

08:37 <flip214> moon-child: that's not the same, is it?

10:44 <jmercouris> jackdaniel: are you able to load parenscript in ECL?

10:51 <jackdaniel> I don't know, I haven't tried.

10:52 <jackdaniel> are you able to load parenscript in ecl?

10:58 <jmercouris> jackdaniel: no it isn't working for me

10:59 <jmercouris> the documentation of parenscript indicates that it /should/work

11:00 <jmercouris> however it results in an error upon attempting to quickload it

11:03 <jackdaniel> it seems that parenscript uses a variable name tag₁ and ecl tries to coerce it to a base string (of course that is not possible)

11:04 <jackdaniel> as of whether ecl needs to coerce it is another story, if you feel that it doesn't need to then please fill an issue on gitlab

11:04 <jmercouris> I see

13:03 <MrtnDk[m]> How do I get the Lisp expansion, that contains "iota" in SBCL?

13:04 <MrtnDk[m]> (I forget the name of it, Allegra or something?)

13:08 <Bike> alexandria?

13:18 <MrtnDk[m]> beach beach yes, I think that's it!

13:19 <Bike> if you have quicklisp installed, should just be (ql:quickload :alexandria)

13:24 <MrtnDk[m]> Bike I get an error. Package ~A does not exist.

13:25 <Bike> package "QUICKLISP"?

13:25 <Bike> you probably don't have quicklisp installed.

13:27 <MrtnDk[m]> Bike I just installed it. cl-quicklisp. I even restarted Emacs.

13:28 <Bike> from debian? it's possible your lisp implementation hasn't gotten the memo

13:28 <Bike> if (find-package "QUICKLISP") => NIL, it's not hooked up correctly

13:28 <MrtnDk[m]> But thou are correct, it doesn't seem to acknowledge that quicklisp is installed.

13:29 <Bike> i have no idea how debian works with this stuff, but your lisp implementation needs to load the quicklisp setup file

13:29 <Bike> which is probably lurking in your system somewhere

13:29 <MrtnDk[m]> Bike Yup, it returns nil.

13:29 <MrtnDk[m]> Art thou on red hat / centos?

13:30 <flip214> MrtnDk[m]: https://packages.debian.org/sid/all/cl-quicklisp/filelist tells me no files at all

13:30 <Bike> flip214: it seems to be in other releases?

13:30 <Bike> https://packages.debian.org/jessie/all/cl-quicklisp/filelist

13:31 <Bike> i suppose you might want to look at README.Debian there, mrtndk

13:31 <MrtnDk[m]> Right

13:31 <Bike> i've never used lisp through a package manager, so i'm afraid i'm not much help here

13:40 <etimmons> Mrtn Dk: debian's Quicklisp package only includes the Quicklisp installer. You need to load /usr/share/cl-quicklisp/quicklisp.lisp and follow the instructions

13:41 <flip214> and a version from 2015 at that

13:41 <Xach> flip214: the newest version is from 2015

13:41 <Xach> the installer does not change often

13:45 <jackdaniel> I stick to an advice presented by Xach at els in london (I think): curl … | sh # :)

13:45 <flip214> jackdaniel: "sudo sh" is the canonical way

13:45 <flip214> or pipe directly into ansible or so...

13:47 <jackdaniel> sounds like fun

13:49 <MrtnDk[m]> eric You're right. I did that. I think it's finally installed.

13:50 <MrtnDk[m]> Thank you everyone.

13:51 <MrtnDk[m]> Now, my next problem. I can load Alexandra, it seems; however (iota 5) still gives me "Undefined function".

13:52 <jackdaniel> try (alexandria:iota 5)

13:56 <MrtnDk[m]> jackdaniel That works! Thanks. However, please tell me, that there is a way to avoid typing alexandria each time ...

13:56 <jackdaniel> (import 'alexandria:iota)

13:56 <jackdaniel> then (iota 5)

13:56 <jackdaniel> that's for a repl

13:57 <flip214> MrtnDk[m]: define your own package that uses alexandria. (defpackage :mrtndk (:use :cl :alexandria)) (in-package :mrtndk) (print (iota 4))

13:57 <jackdaniel> but when you define a package, you could a) put the USE clause in it [not very good, because the library you depend on may break your own system in the future when it adds a conflicting symbol to its export] b) add a package local nickname to alexandria

13:58 <jackdaniel> b) is an extension (as in -not part of the standard) but it allows you to refer alexandria symbols like (a:iota 5))

13:58 <MrtnDk[m]> Can I add it to the startup file like ql? That would be even easier I guess.

14:00 <jackdaniel> adding some repl utilities to a startup file is fine, however that will work only for that use case (repl that is, when you are in the appropriate package), when you write software you usually want to define your own package

14:07 <MrtnDk[m]> Thanks.

14:33 <jcowan> Someone should write a HOWTO for scripting in Common Lisp that minimizes boilerplate.

14:33 <Josh_2> Good afternoon

14:34 <Josh_2> jcowan: seems the tutorial I used is no longer online :(

14:34 <Josh_2> http://web.archive.org/web/20201107230350/https://ebzzry.io/en/script-lisp/

14:35 <jackdaniel> jcowan: lately sjl published a blog post on the topic

14:36 <jackdaniel> there it is: https://stevelosh.com/blog/2021/03/small-common-lisp-cli-programs/

14:36 <jackdaniel> I'm personally using net.didierverna.clon for cli programs

14:46 <splittist> Style question: (if condition (progn ...) (progn ...)) or (cond (condition ...) (t ...)) ? The former, presumably, using the normal reasoning about being explicit.

14:47 <splittist> (and taking into account that a couple of raw progns is unusual)

14:47 <beach> I do the former, but I agree it's not ideal.

14:48 <splittist> Or if** (:

14:48 <beach> Heh.

14:48 <beach> The latter saves a few characters of indentation unless you stick a newline after PROGN in the former.

14:49 <beach> But then you lose two lines instead.

14:50 <beach> Frequently, there is a LET or a SETF in the branches, so you can remove the PROGN.

14:50 <Josh_2> I also do the former

14:51 <splittist> Yes. It's just really for the unusual case that some serial operation is being done that doesn't deserve its own function and doesn't introduce some branch-local state.

14:52 <beach> Right, and I agree that the argument is the "most specific construct".

14:52 <jcowan> I on the other hand always use cond when either the then-expr or the else-expr is at all complex.

15:17 <jcowan> I came up with the idea of making safe readtable changes that affect the file they are in by putting calls to set-[dispatching]-macro-character into #. Is that a standard idea? Or is there some reason why it won't work?

15:18 <Xach> jcowan: that is not an uncommon idea.

15:18 <jcowan> Thanks. Is it a bad idea?

15:19 <Xach> jcowan: I don't think so - unconstrained read-time evaluation is not something you always want. But I haven't solicited other opinions on the topic, either, so there may be some drawback of which I'm unaware.

15:19 <Xach> I last used it to trap #. when processing asdf files with READ.

15:19 <Xach> It used to be quite common to use #. to load files to populate system metadata

15:19 <Xach> I don't think it's as common now but maybe my sampling is off

15:20 <jcowan> Well, I think a #. form should have as few effects as possible on principle.

15:21 <jcowan> Which is not to say zero.

15:21 <semz> Is that guaranteed to only affect the current file?

15:22 <jcowan> Do you have a view on the #.(values) case? Returning NIL is strictly ANSI conformant, but many Lisps return nothing at all, which is clearly useful.

15:22 <Xach> semz: *READTABLE* is bound around LOAD, and you can use that to build some guarantees (it doesn't guarantee it by itself)

15:23 <Xach> jcowan: i do not have an opinion

15:23 <semz> Ah, as usual I looked in the wrong place.

15:30 <anon9002> Is there a standard function for converting a list of characters to string? Something like list->string in Scheme.

15:31 <flip214> anon9002: (concatenate 'string #\f #\o #\o), potentially using apply. Or FORMAT with an iteration.

15:31 <Shinmera> (map 'string #'identity list)

15:32 <Shinmera> or (coerce list 'string)

15:32 <flip214> or WITH-OUTPUT-TO-STRING and print everything into it.

15:32 <flip214> CONCATENATE and the MAP and COERCE only work with pure lists of characters; FORMAT would also take numbers, strings, etc. and concatenate them up.

15:33 <jcowan> anon9002: Coerce is magic, except that it's pre-CLOS and not extensible to any other types than are specifically allowed. But it's the first place to look for Scheme foo->bar procedures.

15:34 <anon9002> flip214, Shinmera, jcowan: Thanks!

15:34 <jcowan> It would have been nice if the ANSI WG had redefined coerce (and several others) as GFs.

15:37 <Bike> it gets a little awkward with general types, unfortunately. the sequences extension has to do stuff with prototype instances to make GFs make sense

16:04 <Josh_2> Gnuxie[m]: You worked with no-defun on the decentralized hash table? I don't remember the library name, but was it based on Matrix?

16:10 <beach> Josh_2: no-defun-allowed hangs out in #sicl mostly in case you have questions.

16:11 <beach> But it is 3am in Melbourne so you may have to wait a few hours.

16:20 <jcowan> coerce can be done with instance types, so the method for doing list->string would have a signature of ((list list) (((eql string) _).

16:22 <beach> By "instance type", do you mean "EQL specializer"?

16:22 <Bike> that wouldn't cover other specialized arrays that don't have types that are symbols

16:23 <Bike> or ones with lengths, though that's kind of a stupid feature anyway

16:24 <Gnuxie[m]> Josh_2: you mean cl-decentralise2? It's not based on matrix but there is an experiment program called 'Catfood' on the gitlab that's like matrix

16:25 <Gnuxie[m]> https://gitlab.com/cal-coop/netfarm/experiments/catfood

16:27 <Gnuxie[m]> But no-defun-allowed is the person to talk to about it, I'm mostly just credited for ideas and discussion, she does all the real work

16:28 <jcowan> beach: yes, (a designator for) a type that includes a single instance.

16:29 <Gnuxie[m]> Josh_2: i'm curious why you are asking, I assume you want something 'built on matrix' rather than based on?

16:30 <Gnuxie[m]> Maybe we should take this to #matrix-dev

16:30 <MrtnDk[m]> Given a list of strings, how do you get the index of a given string? It seems that "position" more or less exclusively deals with integers and/or chars.

16:30 <Josh_2> MrtnDk[m]: (position <string> <seq> :test #'string=)

16:31 <Josh_2> Gnuxie[m]: I was basically looking for a hash table implementation that uses Matrx for storage

16:31 <Josh_2> I was just curious if that is what you two had done

16:31 <Josh_2> I suppose I can implement my own version if needed

16:32 <Gnuxie[m]> Josh_2: ok nope, that's pretty much what state events are for anyways

16:33 <Josh_2> yeh, if needed I will just make my own means of storing data in a nice way on Matrix

16:34 <MrtnDk[m]> Josh_2 Ah, I think I finally get it! Thank thee.

16:34 <Josh_2> MrtnDk[m]: :test and :key are very very useful :P

16:34 <MrtnDk[m]> Key?

16:36 <Josh_2> Yes, say you have a list of objects and the objects have an accessor like "user-id" then you could do (position <user-id-string> <list-of-objects> :test #'string= :key #'user-id )

16:37 <jasom> minion: memo for pillton: I *can* make nyaml a streaming parser (it would mean dumping esrap, but the parts of esrap I use aren't terribly hard to copy). It would still process an entire document at a time though, as I don't really care to find all the places where backtracking can't happen

16:37 <minion> Remembered. I'll tell pillton when he/she/it next speaks.

16:37 <Josh_2> and then each element in <list-of-objects> would make its comparison against (user-id <element>)

16:53 <Alfr> jcowan, if you take 2.4.8.6's first sentence and the glossary entry for evaluate, you get a justification for #.(values) expanding to nothing. The problem here is that it contradicts the definite article in "the object resulting from". OTOH, 3.1.7 could justify nil, if you assume implementations are prohibited to use e.g. multiple-value-list to explicitly distinguish between the two cases of "returning zero or more values" (cf. glossary evaluate).

16:54 <Alfr> I think 2.4.8.6 isn't specific enough to prescribe what #.FOO should read to, in case FOO evaluates to no values. Maybe just chalk it up as just an other UB?

17:03 <jcowan> It all hangs on the first "the" in "#.foo is read as the object resulting from the evaluation of the object represented by foo." Normally there is an implicature there which means a single object is required. But that is a very thin argument, especially when CLtL1 said otherwise and there is no issue that changed this AFAICT.

17:04 <jcowan> (Still, it's better than the fate of Roger Casement, who was hanged on a comma.)

17:06 <splittist> The dictionary entry for VALUES (the function/accessor) describes it as returning "the objects" (which can be no values); the glossary entry for 'multiple values' includes none, obviously. It seems justifiable (if not, perhaps, compulsory?) to read "the object" as "the object (if any)", at least.

17:07 <jcowan> wut, nobody wants to know about Roger Casement?

17:08 <beach> jcowan: Wikipedia.

17:08 <jcowan> Sure.

17:44 <Alfr> jcowan, and obviously allowing #.(values) to be read to nothing is the more useful, but as it's only a opinion, we'll have to wait for the next iteration of the spec to codify it. ;)

18:39 <fuzzypixelz> hello. I want to see for myself what makes Lisp different than C and Haskell. But I'm not sure which Lisp I should go with! I'm torn between Clojure, CL and Scheme (of course I'm open to others)

18:42 <gabc> fuzzypixelz: depends on what type of stuff you want to do, Scheme is quite easy to learn and has easy to setup implementation (racket for instance), and Common Lisp is 'better' for 'bigger' projects

18:42 <Xach> This channel is for common lisp

18:43 <contrapunctus> fuzzypixelz: try ##lisp for all dialects.

18:43 <fuzzypixelz> thank you contrapunctus

18:48 <Josh_2> Obviously you should try Common Lisp

18:50 <fuzzypixelz> Josh_2: may I ask why?

18:50 <Xach> It is the greatest and best Lisp

18:51 <White_Flame> clojure = lisp + java, with heavily opinionated design on immutability; scheme = academically simplified lisp; common lisp = the one used in industry when lisp was hottest

18:54 <fiddlerwoaroof> When I want to make sure certain systems are loaded in one-off scripts, I do something like #.(progn (ql:quickload ...) nil)

18:54 <Xach> fiddlerwoaroof: i would use eval-when instead of that.

18:55 <fiddlerwoaroof> eval-when is loooong ;)

18:55 <Xach> yes.

18:55 <fiddlerwoaroof> I would use (serapeum:eval-always ...) but there's a chicken-and-egg problem here

18:56 <White_Flame> you could skip the #. and do it toplevel, assuming script-only usage

18:56 <fiddlerwoaroof> Also, the semantics of read vs. eval-when aren't always obvious to me: #. forces evaluation by READ which makes the order more explicit

18:57 <Josh_2> fuzzypixelz: what Xach said

18:59 <White_Flame> fiddlerwoaroof: except READ isn't called when reloading from fasl

18:59 <fiddlerwoaroof> White_Flame: by "script", I mean "something I run with C-c C-k in emacs"

19:00 <fiddlerwoaroof> And, I wouldn't recommend this generally, I have a folder of little proofs of concepts, and I get tired tracking down all the systems I need to load to make it work

19:02 <aeth> White_Flame: top-level in a script without #. (or EVAL-WHEN, I guess) won't work because the symbol won't be available. You could use multiple files, or you could use UIOP:SYMBOL-CALL to get around that.

19:04 <aeth> White_Flame: With a script entry point, you aren't reloading from FASL. It's often just used on CI, where you won't even have anything cached.

19:04 <White_Flame> assuming LOAD from a non-compiled .lisp file, is it guaranteed that each form is individually evaluated before the next one is READ? tends to wokr that way

19:05 <aeth> The file is run in stages.

19:05 <aeth> So if you just naively put the QL at the start, it wouldn't run until run time, making the symbol unavailable at read time

19:06 <aeth> In fact, I think you might need #. because EVAL-WHEN isn't doing it at read time either, is it?

19:10 <White_Flame> yeah, pretty sure this will work with LOAD

19:10 <White_Flame> as per the spec

19:11 <White_Flame> in fact, the presence of IN-PACKAGE demands handling the form before any further symbols are even READ

19:12 <aeth> "Everything in-package does is also performed at compile time if the call appears as a top level form."

19:12 <aeth> IN-PACKAGE is special.

19:12 <White_Flame> now, while that can be done before execution time, LOAD does work with this specific example

19:13 <White_Flame> it obviously wouldn't with C-c C-k because of the separate compilation step

19:14 <White_Flame> and "If the file is a source file and the implementation chooses to perform implicit compilation, load must recognize top level forms as described in Section 3.2.3.1 (Processing of Top Level Forms) and arrange for each top level form to be executed before beginning implicit compilation of the next."

19:14 <White_Flame> still not 100% solid proof, but again, runtime seems to have always worked that way

19:16 <White_Flame> "load sequentially executes each form it encounters in the file named by filespec." what's the definition of "encounter"? probably more related to READ than the post-compilation step

19:22 <jcowan> https://www.cliki.net/Proposed%20ANSI%20Changes shows that Clozure and Allegro have the pre-ANSI rule where #.(values) => nothing at all.

19:24 <jcowan> I also note that it is still true that a reader macro can return 0 or 1 values.

19:25 <White_Flame> #+ and #- return nothing at all as well, so this would be symmetric with that

19:26 <White_Flame> *can return

19:43 <fiddlerwoaroof> It just occurred to me that I could add to my "repl utils" system a reader macro for the macro-characters reserved for users in the standard readtable

19:43 <fiddlerwoaroof> I think I'd use #{}, probably, that expands to (eval-when (...) )

19:44 <fiddlerwoaroof> Doesn't help with the --no-userinit case, but I only really do that when I'm doing things "for real" anyways

19:47 <fiddlerwoaroof> Maybe #? and force it to be a single form

20:47 <Kingsy> anyone in here use vlime with neovim nightly?

20:47 <Kingsy> I am having a strange problem with the autocomplete flashes under the cursor but vanishes straight away.

20:51 <fiddlerwoaroof> Kingsy: when I used vim, I always used slimv + vanilla vim

20:51 <fiddlerwoaroof> neovim had a bunch of issues with slimv

20:52 <fiddlerwoaroof> If the developers of vlime don't use neovim, there might be something similar going on

20:52 <Kingsy> tbh I have a few questions about vlime. if anyone is about and fancies answering some. like for example. to offer autocomplete on a function that is included via asdf / quicklisp do you need to run ql:quickload into the REPL first? if not how else will it know about the function?

20:52 <Kingsy> fiddlerwoaroof: yeah. I am hoping not because I really like nightly.

20:52 <Kingsy> yeah I was using slimv but I didnt like a few things about it

20:53 <fiddlerwoaroof> Kingsy: yes, swank can only offer completions for loaded systems

20:53 <Kingsy> makes sense.

20:53 <fiddlerwoaroof> Although, in theory, one could extend it to somehow cache completions and attempt to load the system that contains a particular symbol

20:53 <Kingsy> I don't mind running the quickloads just understanding that I need to. it does make sense.

20:54 <fiddlerwoaroof> So, fwiw, I translated my vim config to evil-mode over the course of a couple days and have used emacs ever since

20:54 <Kingsy> yeah I have been using vim too long to move to emacs.

20:54 <Kingsy> I am sure emacs is better.. much better for lisp. but I just cant make the switch at this point.

20:54 <fiddlerwoaroof> I thought that too :)

20:55 <Kingsy> haha

20:55 <Kingsy> flip214: you about? I know your a vlime user!! :D

20:58 <Kingsy> I'll strip back ALL my plugins and see if I still get the issue.

20:58 <Kingsy> need to do that before I can raise a bug on vlime anyway

21:06 <Kingsy> lol I don't even get autocomplete by default.

21:20 <Kingsy> so its compe that breaks vlime autocomplete.

21:26 <mfiano> vlime works fine with neovim, even nightly. this issue might be with compe

21:31 <Kingsy> mfiano: I have just disabled everything and the flashing has stopped BUT I am not seeing proper autocomplete. for example if I type (ql: I don't see anything on quicklisp...

21:31 <Kingsy> mfiano: do you have anything special in your compe config?

21:32 <Kingsy> yeah its just autocompleting from the buffer.

21:32 <mfiano> Despite how much more I like vi than Emacs, it doesn't make a whole lot of sense for me to restrict the language that much, so I can't offer much help.

21:35 <mfiano> sjl's config would be the one to look at though. He's been a vlime user for years on neovim.

21:46 <Kingsy> sjl: you about by chance?

21:47 <Kingsy> its 100% compe, if you enable source.omni you get autocomplete but it vanishes as soon as it appears. it like "flashes" on the screen

22:04 <SAL9000> There was this nice CL library which provided an improved DESCRIBE -- what was it? can't remember the name, and Google is not helping...

22:17 <jasom> Is it required that one do a load-op before a program-op in ECL? If I don't do that I get bizarre errors about packages not existing...

22:18 <jasom> nevermind; user-headspace error plus quicklisp

22:30 <jasom> okay, reduced test-case; the output of program-op on the following gives an error about a missing SPLIT-SEQUENCE package: (asdf:defsystem #:empty.big :depends-on ("drakma") :entry-point uiop:quit :components nil)

22:31 <jasom> *running* the output of program-op that is

22:31 <phoe> I think this is an ECL-specific issue, I remember it being mentioned earlier

22:32 <jasom> I agree it's ECL-specific since I have no problems on sbcl or ccl

22:48 <MrtnDk[m]> It's quick lisp slime to be preferred over regular slime?

22:48 <phoe> MrtnDk[m]: depends; many people use quicklisp-slime-helper exclusively to ensure that their slime/swank autoupdates with quicklisp

22:48 <jmercouris> jackdaniel: are there security considerations for running version of ECL 16?

22:49 <phoe> this avoids collisions with elpa or melpa or wherever which can cause the slime/swank versions to mismatch

22:49 <fiddlerwoaroof> MrtnDk[m]: yeah quicklisp-slime-helper is really useful

22:50 <jmercouris> the only thing I can discern from the release notes is that random was buggy

23:05 <alanz> which is most widely used: slime or sly?

23:06 <moon-child> slime

23:06 <alanz> That is the impression I am coming to. I currently have sly set up

23:09 <Xach> I like using sly, it has some very nice features.

23:09 <Xach> I have also used slime for a long time

23:10 <alanz> and what would you recommend for someone reasonably fresh to the ecosystem?

23:10 <mfiano> I prefer the added features and bugfixes of Sly myself

23:16 <Xach> alanz: i think it's somewhat easier to find someone to help with slime problems

23:16 <alanz> thanks

23:42 <Kingsy> any vim lisp users here yet?