epony has quit [Read error: Connection reset by peer]
epony has joined #lisp
tfeb has joined #lisp
dxtr has quit [Ping timeout: 248 seconds]
markong has joined #lisp
SlowJimmy has quit [Ping timeout: 265 seconds]
<_death>
too bad I didn't have time for this last game jam
EvW has joined #lisp
epony has quit [Ping timeout: 268 seconds]
lnostdal has quit [Ping timeout: 240 seconds]
himmAllRight has joined #lisp
makomo has quit [Ping timeout: 248 seconds]
makomo has joined #lisp
yoel has joined #lisp
lnostdal has joined #lisp
Cymew has joined #lisp
yoel has quit [Ping timeout: 264 seconds]
jmercouris has joined #lisp
nika has quit [Quit: Leaving...]
varjag has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
orestarod has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
python476 has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
epony has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
amerlyq has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
hhdave has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
epony has quit [Ping timeout: 248 seconds]
amerlyq has quit [Quit: Quit]
Cymew has joined #lisp
jmercouris has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 240 seconds]
epony has joined #lisp
Cymew has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
xrash has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
damke_ has joined #lisp
quazimodo has joined #lisp
brandonz has quit [Quit: WeeChat 2.0.1]
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 260 seconds]
Einwq has joined #lisp
Cymew has joined #lisp
brendyn has joined #lisp
BitPuffin has joined #lisp
MasouDa has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
epony has quit [Read error: Connection reset by peer]
epony has joined #lisp
<Xach>
Wow!
Cymew has joined #lisp
ebrasca has quit [Remote host closed the connection]
pjb has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
ukari has joined #lisp
Cymew has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
tfeb has quit [Remote host closed the connection]
ebrasca has joined #lisp
jmercouris has joined #lisp
Bike has joined #lisp
yoel has joined #lisp
yoel has quit [Ping timeout: 268 seconds]
ukari has quit [Ping timeout: 256 seconds]
<beach>
In a Cartesian product S1 X S2 X ... X Sn, what is the name of n?
<beach>
Arity? Rank?
<dlowe>
upper bound
<beach>
Nah.
<_death>
wikipedia says n-fold
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
Hmm.
_berke_ has joined #lisp
<TMA>
beach: I would say dimension.
<beach>
That sounds better.
orivej has joined #lisp
<TMA>
But then, I am not a native speaker.
<dlowe>
"set count" :D
<TMA>
It is related to vector space dimension ... n-tuples of (real) numbers make a vector space of dimension n
<beach>
Not quite. If you compare to Common Lisp arrays, then the number of dimensions is called the rank.
SlowJimmy has joined #lisp
<beach>
Anyway, thanks for the help everyone.
dddddd has joined #lisp
<TMA>
rank is a higher level concept. a matrix is has rank 2, because it is a m-tuple of n-tuples, with tensors having even higher ranks; in Common Lisp a vector is a tuple (and vice versa) and a vector has rank one regardles of the dimension thereof
<beach>
Right.
<_berke_>
hi guys, I get a "This is probably a bug in SBCL itself." from maxima under imaxima, see https://pastebin.com/p7n7BSa2 - any tips?
orivej has quit [Ping timeout: 264 seconds]
<pfdietz>
Stack trace would be useful.
<pfdietz>
Where is the maxima repo?
<_berke_>
how do I get that?
<_berke_>
gdb?
<pfdietz>
No, the lisp stack trace.
<_berke_>
sorry I'm a bit of a CL noob
<pfdietz>
If errors are not caught in SBCL, a stack trace gets printed showing where the error was signalled.
<pfdietz>
This helps nail down where the bug is happening.
<pfdietz>
The other thing to do is find the function it could not compile and prune off as much of it as you can while still getting the error. Put a copy of it into its own file and edit that down.
<_berke_>
I setf'd *debugger-hook* to nil, now I'm in the debugger. can I request a bt from there?
<_berke_>
thanks, the thing is when I run maxima from the shell (ie not under imaxima from emacs) it works fine.
<pfdietz>
Not sure why you're not getting the stack track. Try aborting to the top level REPL and manually loading that file with (load "/usr/local/share/maxima/5.41.0/share/pdiff/pdiff.lisp")
<pfdietz>
Or perhaps (compile-file <that string>)
warweasle has joined #lisp
<_berke_>
I think the emacs maxima init file does things to catch debugger output
<pfdietz>
If you put that function in its own file, be sure to include a (in-package ...) form so it's read in the correct package.
elderK has quit [Ping timeout: 265 seconds]
<_berke_>
done, I isolated the bit that causes the error
<_berke_>
is cat foo.lisp bar.lisp >baz.lisp and then (load "baz.lisp") equivalent to (load "foo.lisp") (load "bar.lisp") ?
<jmercouris>
_berke_: no
<jmercouris>
also you generally want to avoid manually loading lisp files, instead you should use a system
<jmercouris>
so the de-facto system is "ASDF" which stands for "another system definition facility"
<_berke_>
jmercouris: I understand but I'm chasing a bug that involves two files, is there a way to place them in a single file for an easier-to-use bug case?
<jmercouris>
_berke_: it will not be the same thing, but you might try what you are suggesting, and the bug might still appear
<Bike>
that's a pretty primitive way to do things, but i don't see why the concatenated file would be much different
<Bike>
it would only effect, like, *load-truename* and stuff, as far as i can think of
<_berke_>
jmercouris: it indeed did
<jmercouris>
I'd be pretty skeptical that it is a bug in SBCL
<jmercouris>
it's most likely a user bug
<jmercouris>
at least statistically speaking, but it is easy to blame the implementation
ukari has joined #lisp
<ukari>
i saw a code `(as:delay lambda time)`, i try to quickload 'as' but fail
<_berke_>
I hope so. how can I check if any native code (e.g. shared libraries compiled from unsafe languages) were loaded?
pdv` has joined #lisp
Kundry_Wag has joined #lisp
HellKey has quit [Ping timeout: 268 seconds]
tfeb has joined #lisp
pdv has quit [Ping timeout: 265 seconds]
EvW has quit [Ping timeout: 240 seconds]
<pjb>
ukari: "AS" is the name of a package (probably a short nickname actually). quickload loads systems. It expects a system name, not a package name.
<pjb>
System names may be unrelated to and very different from package names.
<pjb>
ukari: also, not all systems are on quicklisp, and not all packages are defined in systems.
Kundry_Wag has quit [Ping timeout: 264 seconds]
<pjb>
ukari: so you have 1- locate the name of the system where this package is defined. Then you may try quickload on it. If it doesn't work: 2- locate the source of that system (perhaps a git repository, perhaps a tarball somewhere). Then you can clone it or untar it in ~/quicklisp/local-projects/ and try quickload again. If not a system, then locate the sources, download them, and either use a load script provided to compile and lo
<pjb>
sources, or write a asd system yourself.
<pjb>
Be sure to contribute the asd system if you write it, so it may eventually be integrated in quicklisp.
<ukari>
thanks you, pjb. i found this package in system cl-async
comborico1611 has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
pierpal has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
pierpal has quit [Ping timeout: 256 seconds]
Anthaas has quit [Ping timeout: 268 seconds]
<light2yellow>
I was reading LISP 1.5 manual, appendix H ( https://books.google.com/books?id=68j6lEJjMQwC&pg=PA91 ) talks about recursion implementation. is this the first occurrence of a programming language implementing recursive functions? from what I can understand, it doesn't differ much from call stacks we have now
<Bike>
i believe so, yes.
<tfb>
light2yellow: that's interesting: it might be the first implementation
<Bike>
i think i've heard lisp was the first thing with a stack with local variables, but i dunno
<Bike>
might have been IPL something
SaganMan has quit [Ping timeout: 256 seconds]
sjl has joined #lisp
<tfb>
Bike: yes, I think IPL if that counts as not being just a special assembler
<jmercouris>
is Fernando Boretti ever on this channel?
<jackdaniel>
yes, he comes with nick eudoxia
<jmercouris>
I thought the name looked familiar, thanks
pierpal has joined #lisp
* Xach
got eudoxia and eugenia confused :(
equwal has joined #lisp
<light2yellow>
right, so, a paper called "A brief history of stack" says that IPL had the stack, but "its usage had to be explicitly described when a subroutine was called". McCarthy made it being handled automatically. at this point the paper references his "History of LISP" which says a few sentences about SAVE and UNSAVE, on which the manual elaborates
kuwze_ has joined #lisp
eli_oat has joined #lisp
rumbler31 has joined #lisp
<equwal>
Hello, I have a question: Is ther a way to have a generic function with polyarity without hand-writing dispatching code? I want to have a function like (x 1) do something, while (x 1 1) does something else. Defgeneric doesn't really seem to do the job. I was able to hand-write some dispatching code, but I feel like this is already a feature somewhere that I am not aware of.
josemanuel has joined #lisp
<Xach>
equwal: no, it is a feature not to have variable arity. the name and argument count & names are the interface. if the argument count & names are different, it must be a new function with different behavior.
quazimodo has quit [Ping timeout: 256 seconds]
<Xach>
equwal: i can imagine some ways you might reach your desire - what is your specific circumstance?
SaganMan has joined #lisp
<equwal>
My ad-hoc way of doing this was to define a hash table with (make-hash-table :test #'equalp) which is searched for by a list of the function name and the arguments, like (gethash (list func spec-list)). I used some macros to abstract this away a bit.
<Xach>
equwal: i mean, why do you want what you want? what is the operation you want to perform on a variable number of arguments?
<equwal>
I can't use &optional in this case either. My circumstance is I want apl functions like RHO ⍴ to accept one argument (⍴ 2) which is an empty array, or (⍴ 2 2) which is the array #(2 2) for example.
EvW has joined #lisp
<tfb>
equwal: a terrible solution I used was to write a wrapper which has an &rest arg, which calls into an implementation GF passing the length of the &rest arg as the first argument which is dispatched on with eql methods.
<tfb>
(I told you it was terrible)
<Xach>
at any rate, no, CLOS does not work like that.
<Xach>
there is no hidden thing you are missing
yoel has joined #lisp
<equwal>
Okay thank you, I will keep hand-writing the dispatch code so I can this.
yoel has quit [Read error: No route to host]
yoel has joined #lisp
aleamb has joined #lisp
Kundry_Wag has joined #lisp
Einwq has quit [Quit: Leaving]
wheelsucker has joined #lisp
equwal has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 268 seconds]
Intensity has quit [Ping timeout: 260 seconds]
swflint has quit [Ping timeout: 268 seconds]
tfeb has joined #lisp
<Xach>
Hmm, I don't think I've seen this error in SBCL before: "<variable> is read-only in this environment"
Ven`` has joined #lisp
charh has joined #lisp
Ven`` has quit [Client Quit]
tfeb has quit [Ping timeout: 256 seconds]
swflint has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
swflint has quit [Ping timeout: 256 seconds]
cyberlard has joined #lisp
ealfonso has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
SlowJimmy has quit [Ping timeout: 256 seconds]
Intensity has joined #lisp
swflint has joined #lisp
Firedancer has quit [Ping timeout: 248 seconds]
<ealfonso>
is there a good way to turn an alist into the arguments of a function whose argument list only defines a proper subset of the alist keys as &key arguments, without writing a macro myself? e.g alist: ((:var1 val1) (:var2 val2) (:var3 val3)) function: (defun my-fun (&rest args &key var1 var2) ...)
pankracy has quit [Ping timeout: 264 seconds]
<beach>
clhs :allow-other-keys
<specbot>
Couldn't find anything for :allow-other-keys.
<beach>
Bah.
<mfiano>
add &allow-other-keys and apply the converted plist?
<beach>
ealfonso: You can pass :allow-other-keys t in addition to your keyword arguments.
<beach>
ealfonso: That will suppress the check for valid keyword arguments.
cpape` has joined #lisp
borodust has quit [Ping timeout: 245 seconds]
Mon_Ouie has quit [Ping timeout: 248 seconds]
Firedancer has joined #lisp
Mon_Ouie has joined #lisp
cpape has quit [Read error: Connection reset by peer]
knobo has quit [Ping timeout: 256 seconds]
knobo has joined #lisp
Josh_2 has joined #lisp
<beach>
I.e. (apply #'my-fun (list* :allow-other-keys t (reduce #'append alist :from-end t)))
<ealfonso>
beach thanks
borodust has joined #lisp
pfdietz2 has joined #lisp
pankracy has joined #lisp
<pfdietz2>
Failed AVER in the sbcl compiler is always a sbcl bug, even if the user code is bad.
pdv` has quit [Ping timeout: 265 seconds]
charh has quit [Changing host]
charh has joined #lisp
<beach>
ealfonso: Anytime.
dieggsy has joined #lisp
dieggsy has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<ealfonso>
beach how about binding only unknown keys instead of all keys? I'm using (progn (defun my-fun (&rest args &key var1 var2 &allow-other-keys) ...) (my-fun :var1 1 :var3 3)) but this binds all args. I guess I would need to do this myself?
<beach>
ealfonso: You didn't tell us that you were allowed to modify my-fun.
dieggsy has joined #lisp
brendyn has quit [Ping timeout: 276 seconds]
<ealfonso>
beach I see, you meant I could add :allow-other-keys t from the caller, which I didn't know about. but I had forgotten about &allow-other-keys, which I can use since I'm defining the function
<beach>
I see.
Kundry_Wag has quit [Ping timeout: 256 seconds]
<beach>
Then, instead of &rest args, why don't you just build the list of the explicit keyword parameters, i.e. (list :var1 val1 var2 val2).
<ealfonso>
beach I'm basically trying to extract a command-line argument list, by cherry picking some and handling them in functoin A, then proxy all other arguments to another function B. this way, if I add more arguments to function B, I can simply pass them from the command line without the overhead of defining it explictly as a keyword argument in A
rumbler3_ has joined #lisp
<ealfonso>
s/it/them
SlowJimmy has joined #lisp
<beach>
Sure, that's a standard trick.
LiamH has joined #lisp
<ealfonso>
beach but function B will crash if it gets unexpected keyword arguments... I guess I can just add :allow-other-keys t to the call to B
<beach>
Yes.
<ealfonso>
beach mfiano that worked. thanks
<beach>
Anytime.
rumbler3_ has quit [Ping timeout: 248 seconds]
dxtr has joined #lisp
jlarocco has joined #lisp
tfeb has joined #lisp
Ven`` has joined #lisp
omilu has quit [Remote host closed the connection]
tfeb has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 248 seconds]
loke` has quit [Remote host closed the connection]
<shka>
sadly, as for now there is no reasonable set in cl-ds
jsjolen` has joined #lisp
<shka>
just functional vector (radix tree), functional dictionary (hamt) and metric space set (egnat)
<jsjolen`>
Hi, just out of curiosity: Why can't SBCL compile (let ((x 0)) (dotimes (i 1000) (incf x))) this down to (setf x 1000) (off-by-1 mistakes excluded)?
<shka>
plus bunch of algorithms, ranges and stuff
igemnace has quit [Quit: WeeChat 2.1]
sauvin has quit [Remote host closed the connection]
<shka>
jsjolen`: because nobody implemented such optimization in compiler i guess!
yoel has quit [Ping timeout: 276 seconds]
<jsjolen`>
shka: Meh :-).
<MichaelRaskin>
If you need that optimisation, maybe you should use Maxima first to simplify your calculations, then write Lisp code for SBCL…
cezary has quit [Remote host closed the connection]
<shka>
jsjolen`: honestly though, code for that needs to be maintained and feature does not look whole lot useful
orivej has joined #lisp
<shka>
anyway, do we have recordings from esl somewhere already?
<White_Flame>
well, you never know what macros might generate in terms of degenerately collapsable code
<jsjolen`>
I don't need it, I'm just legit curious as to why it doesn't do that. Whether it's because it's actually deviously difficult to solve for the general case (heck, what would the general case be tehre?) for all languages or for CL in particular
tfeb has quit [Ping timeout: 248 seconds]
<jsjolen`>
Also nah, no ESL vids soon as far as I know shka :-/
<MichaelRaskin>
Well, if you have macros known to generate arithmetic expressions, feeding the output to Maxima is feasible… Maintaining a computer algebra system inside compiler sounds like a duplication of work.
<White_Flame>
an incf loop isn't an arithmetic expression
<MichaelRaskin>
Although cycles are even worse…
<Bike>
people don't usually write code like that
al-damiri has joined #lisp
<jsjolen`>
White_Flame: Looks like \sum_{i=1}^{1000} 1 to me :-P
<White_Flame>
while it's functionally equivalent, it's not actually that formula
<White_Flame>
as there's no 'sum' operation concept in lisp, besides (+ ,@rest)
ChrisOei has joined #lisp
<jsjolen`>
Sure. Also, if you do think of it as 'that formula' then it's easy to see that it's a bit silly to implement that specific kind of optimization in the compiler, it'd be more apt to fit it into a sum-function along with compiler macros (for example)
<White_Flame>
ah, I guess LOOP does have sum
<White_Flame>
and that compiles down to an iteration still
<Bike>
intuitively i'd say it's rare for people to write code like "do this n times" if it could be "do this once, n times as much"
<White_Flame>
in any case, SBCL's most effective optimizations are around type inference
<White_Flame>
they're quite aware that there are many other optimizations not implemented
<White_Flame>
the difficulty in this particular case is proving the scope of the variable being mutated, as being fully owned by the loop
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<White_Flame>
although this should be a lot easier in Lisp than something like C
<Bike>
you'd also have to reconstruct that it's "do this n times" from the macroexpansion.
<White_Flame>
as well has knowing which operations have which side effects, and being able to execute them safely at compile-time
<White_Flame>
Bike: yes
<aeth>
Bike: But the more optimizations the compiler has, the more people's idiomatic styles can change.
<Bike>
i don't think that general idea is applicable here
<aeth>
e.g. if you're writing very fast CL, you're probably only going to use type declarations for sequences and numbers because the type inference is probably going to solve the rest.
<Bike>
okay but i'm talking about this particular optimization
<aeth>
But if the compiler didn't do any of that you'd say that idiomatic high-performance CL types everything
matijja has joined #lisp
Guest28051 has quit [Ping timeout: 268 seconds]
Ven`` has joined #lisp
karswell has joined #lisp
comborico1611 has quit [Ping timeout: 240 seconds]
comborico1611 has joined #lisp
<Xach>
762222
swflint has quit [Ping timeout: 256 seconds]
shmup has joined #lisp
Kundry_Wag has joined #lisp
<MichaelRaskin>
Short numeric PINs for online banking are bad, and someone should feel bad
shmup has left #lisp [#lisp]
<Xach>
TOTP
<aeth>
MichaelRaskin: but then someone would have to update the size and type of a field in an old COBOL or mainframe assembly program from the 1980s or earlier.
<MichaelRaskin>
Ah OK then.
swflint has joined #lisp
<MichaelRaskin>
aeth: 6-digit PINs in 1980s? What were they used for? I thought card PINs are 4-digit (for physical presence case)
orivej has quit [Ping timeout: 240 seconds]
<aeth>
MichaelRaskin: 6-digit would be extra secure, I guess
Kundry_Wag has quit [Ping timeout: 240 seconds]
yoel has joined #lisp
<Xof>
Bike: would you like to see something horrible?
<Xof>
needs a typep check for (and symbol (not null))
<Xof>
ok, this is clearly the way forward
<Xof>
all my lisp programming from now on will be done in method combinations
<pjb>
Method combinations are monads. You're switching to functional programming :-)
<Xach>
i think there's a galaxy brain to be made here
<random-nick>
Xof: needs more change-class
DemolitionMan has joined #lisp
MasouDa has quit [Ping timeout: 256 seconds]
MasouDa_ has joined #lisp
bjorkint0sh has quit [Ping timeout: 265 seconds]
yoel has quit [Remote host closed the connection]
aindilis has quit [Remote host closed the connection]
eli_oat has quit [Remote host closed the connection]
<Xof>
haha
<Xof>
googling for method combination uses, what do I find?
<Xof>
I find an article from 2014 about a fancy method combination for HTTP requests
<Xof>
punchline: I wrote it
<Xof>
extra punchline: it uses :arguments
<MichaelRaskin>
Here we expect third punchline: methods combined are PUT and GET
sz0 has joined #lisp
vlatkoB has quit [Remote host closed the connection]
EvW1 has quit [Ping timeout: 260 seconds]
<White_Flame>
methods are overdoses on meth
dieggsy has quit [Ping timeout: 255 seconds]
<_death>
Xof: I remember Costanza's BETA method combination
orivej has joined #lisp
d4ryus1 is now known as d4ryus
aindilis has joined #lisp
<random-nick>
hm, why is the standard method combination called STANDARD and not CAR?
<Bike>
why would it be called car
<Petit_Dejeuner>
better question
dddddd has quit [Remote host closed the connection]
<Petit_Dejeuner>
why is #'car called #'car?
<Bike>
some old machine's instruction mnemonics
<LiamH>
"contents of the address register" IIRC
<White_Flame>
a register had 2 fields it could be broken up into, the "address" part, and "decrement" part
<White_Flame>
so they used that for the cons cell
<p_l>
it was a bit more than that ;)
<p_l>
but IIRC it wasn't instruction mnemonics, but standard macros in assembler
<White_Flame>
yeah, more bits than that ;)
<p_l>
CPR, CAR, CDR, CTR
<p_l>
for total of 36bits
<_death>
what if HUNKs replaced CONSes
<White_Flame>
then you get an Amiga
<p_l>
_death: then the language would be probably much less usable
DemolitionMan has quit [Ping timeout: 260 seconds]
<p_l>
what do you put into a HUNK when programming, for example?
<p_l>
White_Flame: MACLISP had HUNK data type, iirc
orivej has quit [Ping timeout: 268 seconds]
<White_Flame>
yeah, sort of like a fixed-length tuple
<_death>
p_l: not sure what you mean..
Mutex7 has joined #lisp
angavrilov has quit [Remote host closed the connection]
<p_l>
_death: CONS cells build source of Lisp programs
<jmercouris>
Petit_Dejeuner: Nobody knows the origin of car, it has been lost to time
<_death>
and what is the big difference between CONS and HUNK2?
Cymew has joined #lisp
tfeb has joined #lisp
energizer has joined #lisp
himmAllRight has quit [Quit: WeeChat 2.0.1]
himmAllRight has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
DemolitionMan has joined #lisp
fikka has joined #lisp
<p_l>
_death: I'd say the built-in semantics of list handling
tfeb has quit [Ping timeout: 240 seconds]
<phoe>
Xof: what in the holy hell
foom2 has joined #lisp
<phoe>
is this a method combination that sets state based on method calls and then uses restarts to find its next state?
<jasom>
phoe: that's the obvious way to implement a state machine in common lisp, isn't it?
<p_l>
:D
<rme>
"First – and understand this, Harry, 'cause it's very important – not all wizards are good."
<jasom>
restarts are *so* close to being continuations :(
shrdlu68 has joined #lisp
<MichaelRaskin>
Close enough for an ELS lightning talk about that
foom has quit [Ping timeout: 265 seconds]
<phoe>
hint: there already was one
<MichaelRaskin>
Yes, that's what I meant
<MichaelRaskin>
Thanks
elderK has joined #lisp
<jasom>
I happen to like cooperatively scheduled lightweight threads as a programming model, so the lack of them (or continuations which are nearly isomorphic to that) in CL has always bothered me a bit. cl-cont works, but code walkers tend to bitrot.
pierpal has quit [Ping timeout: 240 seconds]
<phoe>
...I still cannot understand this code after staring at it for ten minutes
<White_Flame>
yeah, I'd love to have lightweight threads that share the dynamic bindings of their launchers
<MichaelRaskin>
Trust the Lizard: Agnostic Lizard is a codewalker written in a way that has a chance not to bitrot
<White_Flame>
as in sharing the actual bindings, not just the current value at launch
zxcvz_ has quit [Quit: zxcvz_]
aeth has quit [Ping timeout: 256 seconds]
<Bike>
cooperative green threads sounds easier than continuations
aeth has joined #lisp
<Bike>
phoe: like xof said, you can just think of restart-bind as dynamic function bindings.
* shrdlu68
thinks he has seen this exact discussion here before
<Bike>
nothing is new under the sun
<phoe>
Bike: yes, I know that one
<phoe>
I'm just munching on the mapcar lambda now
<Bike>
so what don't you get then
<Bike>
"it's pretty straightforward"
<phoe>
well shit, three years of doing Lisp and I can't understand a simple d-m-c
<phoe>
time to retire
<shrdlu68>
phoe: What's d-m-c?
<jmercouris>
shrdlu68: have you heard that one song "it's all just a bunch of history repeating" I want to say it is by propellerheads
<phoe>
shrdlu68: define-method-combination
<Bike>
define method combination, the lisp operator with the highest complication/usedness ratio
<Bike>
phoe: you can always compute-effective-method to look at the expansion
<fe[nl]ix>
jasom: green threads have to be integrated deeply with the runtime for them to be efficient
<phoe>
Bike: thanks, I'll do that tomorrow
* phoe
goes to sleep for now
<Xof>
now, I hope that all implementors use this as a challenge to implement invoke-restart efficiently
<fe[nl]ix>
jasom: and the efficiency considerations end up affecting the language semantics, as in Erlang and Go
<Xof>
wouldn't do to do a linear search over restart bindings now
<MichaelRaskin>
Xof: extrapolating from the fact that remove-duplicates is sometimes quadratic…
<Bike>
so, what, a hash table?
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
dxtr has quit [Quit: leaving]
<phoe>
a hash table from restart names to restarts? sounds much better
* phoe
goes to sleep, take two
<jmercouris>
can we go deeper?
<Xof>
we should be able to build a perfect hash
warweasle has quit [Quit: gotta go.]
<shrdlu68>
jmercouris: I had never, but it's the glorious 21st century so now it's playing.
<Xof>
or stuff things onto the symbol-plists
<Xof>
so many choices
<jmercouris>
Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should
<Xof>
shrdlu68: I apologise for your déja vu. I've been here, on and off, for ~18 years; there's a decent chance I've said the same things once or twice
<Bike>
well, i mean, it's dynamic
<Bike>
guess you could have like a sequence of hash tables
<jmercouris>
perhaps you could just jump the pc to a random location and begin execution, hope that you are in the right place, I mean, sometimes you will be
<Mutex7>
18 years? D:
<jmercouris>
with that, I'm done :D
python476 has quit [Ping timeout: 240 seconds]
<shrdlu68>
Almost as long as the standard itself.
<Xof>
now I feel properly old
<jmercouris>
age is just a number :)
<jmercouris>
there's that whole business with the telomeres, but try not to think about that ;)
pierpa has joined #lisp
<p_l>
... I think I've been here ... 10~13 years?
<Mutex7>
Sounds like forever to me. Am only a recent CS grad. New to lispy things as well. Kinda hard to imagine coding for that long.
<shrdlu68>
p_l: Half as long as the lifetime of a queen in an anthill.
<Bike>
depends on the species
<Xof>
luckily I have been coding for 0 of those 18 years
<Xof>
maybe some day I will get a programming job
<jmercouris>
Xof: are you only involved in language design?
<jmercouris>
theoretical computer science?
<Xof>
no, mostly I do music computing / machine listening / teaching
<Xof>
lisp is a hobby
<Xof>
sort of
<Mutex7>
Even if you get a job programming, it's really hard to convince people to use lisp :(
zachk has joined #lisp
<Mutex7>
People seem allergic to it for some odd reason.
zachk has quit [Changing host]
zachk has joined #lisp
<shrdlu68>
Heh, "Odd reason".
<jmercouris>
people are afraid of it, foreign syntax, lots of industry promises in AI, none fulfilled
<jmercouris>
it just fell out of fashion
<jmercouris>
people do what they know, and most do not know lisp
<_death>
speaking of déja vu..
moei has quit [Quit: Leaving...]
<jmercouris>
yes, sorry for beating the dead horse
<jmercouris>
I am going to sleep now, goodnight everyone!
josemanuel has quit [Quit: leaving]
Oladon1 has joined #lisp
Oladon has quit [Ping timeout: 248 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Karl_Dscc has quit [Remote host closed the connection]
yoel has joined #lisp
Rawriful has joined #lisp
yoel has quit [Ping timeout: 240 seconds]
python47` has joined #lisp
k-hos has quit [Ping timeout: 256 seconds]
ealfonso has quit [Ping timeout: 240 seconds]
hhdave has joined #lisp
ealfonso has joined #lisp
hhdave has quit [Quit: hhdave]
wheelsucker has quit [Remote host closed the connection]
rumbler31 has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
Trystam has joined #lisp
pfdietz2 has quit [Ping timeout: 248 seconds]
<White_Flame>
Xach: if I deploy an image, built with quicklisp, then at runtime on another box I want to dynamically load through QL more stuff.. is the ability to install QL only in the quicklisp:quickstart stuff from the initial file, or can I test & install from inside the "normal" ql package running on a foreign machine?
Tristam has quit [Ping timeout: 256 seconds]
Trystam is now known as Tristam
rumbler31 has quit [Ping timeout: 264 seconds]
jmercouris has quit [Ping timeout: 240 seconds]
dxtr has joined #lisp
asarch_ has joined #lisp
asarch has quit [Ping timeout: 260 seconds]
<White_Flame>
(I know I asked something similar a long time ago, but given the complexity we never went down that path. It's become more necessary now)
Ven`` has joined #lisp
asarch_ is now known as asarch
himmAllRight has quit [Quit: WeeChat 2.0.1]
energizer has quit [Disconnected by services]
energizer has joined #lisp
energizer has quit [Remote host closed the connection]
energizer has joined #lisp
shka has quit [Ping timeout: 264 seconds]
LiamH has quit [Read error: Connection reset by peer]
Bike has joined #lisp
python47` has quit [Ping timeout: 240 seconds]
light2yellow has quit [Quit: light2yellow]
tfeb has joined #lisp
tfeb has quit [Ping timeout: 248 seconds]
dilated_dinosaur has quit [Remote host closed the connection]
eli_oat has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
eli_oat has quit [Client Quit]
dilated_dinosaur has joined #lisp
elderK has quit [Ping timeout: 240 seconds]
random-nick has quit [Read error: Connection reset by peer]
Quetzal2 has quit [Read error: Connection reset by peer]