red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<p_l>
I do wonder how much the mistake of trying for CLtL2 before ANSI led to it
<p_l>
akkad: XEmacs never got as dead as GCL
<Xach>
gcl is still alive
<Xach>
i'll box the ears of anyone who says otherwise!
<p_l>
akkad: when GCL was making doornails look lively, XEmacs was still something I would suggest over Emacs :)
<p_l>
(partially because of better MULE and unicode)
<aeth>
akkad: It's not good for the image of CL (a dead implementation that's barely supported by the ecosystem does not make a good first impression) or for the security of CL programmers (SBCL or CCL would patch a security issue next month... GCL would patch it in 5 years maybe?) to recommend inactive implementations.
* p_l
ponders if Genera might not have actually wider usage than GCL now
<aeth>
It's a lot harder to determine things about commercial implementations. It's likely they're not in the ASDF+Quicklisp ecosystem with the rest of us and if there's some issue it *could* still be patched quickly through a commercial support contract even if there's one user.
<akkad>
Franz patches weekly. LW not so much
<aeth>
I'm talking about obscure commercial implementations.
<aeth>
Everyone knows LW and Allegro are alive
<aeth>
aeth-lisp is also alive if someone is willing to pay $500,000 a year or whatever. Even if it has basically 0 presence anywhere else.
<Josh_2>
nope not giffing you that moneys bad aeth
m00natic has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
<aeth>
Josh_2: It's a lot harder than it looks. I can't just "git clone https://github.com/sbcl/sbcl.git" because I also have to find-and-replace all instances of the strings "SBCL", "sbcl", "Steel Bank Common Lisp", etc., except on the relevant copyright/contributor pages, etc.
krrrcks has quit [Ping timeout: 240 seconds]
brettgilio has quit [Remote host closed the connection]
krrrcks has joined #lisp
<aeth>
(That's obvious satire, but soemone *did* make a commercial fork of CMUCL.)
<Josh_2>
bad aeth
<Josh_2>
xD
<akkad>
it's unfree so, typical.
pierpal has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
patlv has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
skapata has quit [Remote host closed the connection]
BitPuffin has quit [Remote host closed the connection]
brettgilio has joined #lisp
red-dot has joined #lisp
<pfdietz>
acl2 was keeping gcl alive, wasn't it? But they moved on.
playful-owl has quit [Quit: leaving]
<Xach>
maxima
rumbler31 has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 268 seconds]
<p_l>
aeth: SCL is kinda dead, moxcl is probably alive but isn't a full implementation, Liquid, Franz and Genera are in similar state of undead (you can still get support), I actually don't know about Interlisp because it feels at times that the owners forgot there was a language implementation under the program they were selling
light2yellow has quit [Quit: light2yellow]
<p_l>
Corman died to be reborn opensourced, MCL died in the OSX transition iirc
patlv has quit [Ping timeout: 240 seconds]
<p_l>
anything else from the CL world?
pjb has quit [Ping timeout: 256 seconds]
<p_l>
(I'm ignoring implementations that died back on DOS or were so obscure good luck finding mentions, let alone software or parts)
warweasle has joined #lisp
fikka has joined #lisp
gjvc has joined #lisp
Beep-Lord has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
equwal has joined #lisp
pjb has joined #lisp
pjb is now known as Guest12397
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 244 seconds]
brettgilio has quit [Remote host closed the connection]
Guest12397 has quit [Ping timeout: 276 seconds]
Beep-Lord has quit [Ping timeout: 265 seconds]
Kundry_Wag_ has quit [Ping timeout: 264 seconds]
Guest12397 has joined #lisp
subr has quit [Quit: Leaving]
subroot has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
phenoble has quit [Ping timeout: 265 seconds]
wheelsucker has quit [Ping timeout: 256 seconds]
Guest12397 has quit [Ping timeout: 240 seconds]
Guest12397 has joined #lisp
Guest12397 has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
Guest12397 has joined #lisp
Kundry_W_ has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
nickenchuggets has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
Kundry_W_ has quit [Ping timeout: 264 seconds]
Guest12397 has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<aeth>
Is there a way to define a function with a defclass given some custom metaclass? It's very trivial with a defclass* macro, but I'm not sure how it can be done in the MOP. (setf (fdefinition foo) (lambda (...) ...)) in ensure-class-using-class :before?
dddddd has quit [Ping timeout: 256 seconds]
Guest12397 has joined #lisp
Guest12397 has quit [Remote host closed the connection]
red-dot has joined #lisp
dddddd has joined #lisp
Oladon has quit [Quit: Leaving.]
Guest12397 has joined #lisp
gousuto has joined #lisp
gousuto has quit [Changing host]
gousuto has joined #lisp
nickenchuggets has quit [Ping timeout: 265 seconds]
Guest12397 has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Guest12397 has joined #lisp
rumbler31 has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
warweasle has quit [Remote host closed the connection]
warweasle has joined #lisp
robotoad has joined #lisp
Guest12397 has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
rumbler31 has quit [Remote host closed the connection]
cgay_ has joined #lisp
cmatei has quit [Ping timeout: 244 seconds]
pierpal has joined #lisp
cmatei has joined #lisp
EvW has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
Guest12397 has joined #lisp
<Bike>
oh, you mean, during the course of a defclass, define a function
AetherWind has joined #lisp
<Bike>
:before method sounds right to me. you don't get to control the macroexpansion to put a defun in there, if that's what you're hoping for.
cornett has left #lisp ["WeeChat 1.9.1"]
<equwal>
I'm not sure I understand what aeth means either. Are you talking about polymorphism?
pierpa has quit [Quit: Page closed]
Oladon has joined #lisp
fikka has joined #lisp
Guest12397 has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
<LdBeth>
aeth: you mean funcallable instance?
<Bike>
i think aeth just wants a defclass of their custom metaclass to define more functions than just accessors.
dddddd has quit [Remote host closed the connection]
<aeth>
Bike: right
terpri has quit [Ping timeout: 264 seconds]
<aeth>
I have it, but it's not particularly pretty. I can't just (setf (fdefinition foo) (lambda (...) ...)) because I have macroish things I want to do so I have to (setf (fdefinition foo) (eval `(lambda (...) ...)))
fikka has quit [Ping timeout: 244 seconds]
<LdBeth>
I think defined initialize method for the metaclass can do that
<aeth>
And I also have to wrap it in an eval-when in CCL because of course CCL is picky about things and wants extra eval-whens
<Bike>
whoa, whoa, what
<Bike>
oh by "macroish things" you mean the source will be different
<aeth>
I guess the next step is seeing if I can generate the check-types in the setter automatically and perhaps doing the constructor type checks (via the generated function) automatically
<aeth>
s/the setter/the setters/
DataLinkDroid has quit [Read error: Connection reset by peer]
<Bike>
yeah i have no idea why eval-when would be necessary here.
<Bike>
but let me see if i have this right- you define a global function for every slot that takes an instance and checks that slot?
<Bike>
or just one check- for the class that does all of them
sjl has quit [Quit: WeeChat 2.2-dev]
<aeth>
Bike: I define a check-foo that checks the type of every slot that has a reader. This can be called separately since CLOS objects can't really be trusted even with the constructor and setters having type checks.
karlosz has joined #lisp
<aeth>
I also add :before to every writer to ensure that the types are checked. Atm, I do this manually, but it probably won't be that hard to do it automatically now that I have everything set up.
<Bike>
you could just define a :before on (setf slot-value-using-class) since you have your own slotd class anyway.
Guest12397 has quit [Ping timeout: 256 seconds]
<aeth>
Bike: And that would cover with-accessors, with-slots, and the constructor all together?
<Bike>
everything goes through (setf slot-value-using-class), yes.
<aeth>
great
<aeth>
That simplifies things a lot
itruslove has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
sjl has joined #lisp
giraffe has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Guest12397 has joined #lisp
Guest12397 has quit [Ping timeout: 276 seconds]
<equwal>
After several years of lisping this CLOS stuff still confuses me a great deal. In one ear and out the other. Hopefully it will click sometime.
rozenglass has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
xsperry has joined #lisp
<loke>
equThat part of it is complicated?
warweasle has quit [Ping timeout: 240 seconds]
Guest12397 has joined #lisp
<equwal>
I just have a hard time remembering all the details, and knowing when it is better than the functional paradigm I am accustomed to.
<equwal>
Do you recommend any resources? I've read Peter Siebel's book and Graham's On Lisp sections on CLOS, but I don't really get still.
<sjl>
Keene's CLOS book is short, but was very helpful for me.
JuanDaugherty has joined #lisp
Guest12397 has quit [Remote host closed the connection]
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
cgay_ has quit [Ping timeout: 240 seconds]
<equwal>
I found myself a copy, I'll definitely give this a read.
<equwal>
Thanks!
Kundry_Wag has quit [Ping timeout: 260 seconds]
<aeth>
I think there's only one person here who really knows CLOS
Guest12397 has joined #lisp
<equwal>
I think the main problem for me is that CLOS is so much bigger than any object orientation I have tried to do before. 'Thing's huge.
<aeth>
And it's just underspecified enough for there to be annoying incompatibilities between implementations.
Guest12397 has quit [Ping timeout: 240 seconds]
<xsperry>
what is your opinion of lisp-1 vs lisp-2 as far as functional programming go? and is there a way to reduce boilerplate in lisp-2 when doing that style of programming with some smart use of macros?
pierpal has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
<equwal>
Well I like doing things like this ((lambda (x) x) 1) in scheme, whereas in lisp you must do (funcall #'(lambda (x) x) 1) which is not as cool.
<xsperry>
I was thinking something like this... (funcall (funcall 'f 10) 20) vs ((f 10) 20)
<aeth>
it won't help you with that particular case (although you *can* drop the #') but it can help when funcalling named things
<equwal>
But you get to do things like (define list (list) list) and have it work, whereas (define list (lst) lst) is not so good. I'm not really sure, but I know I've seen very good discussion on both sides.
<xsperry>
equwal your lambda example actually works in CL.
<xsperry>
no. just calling a function stored in f variable, and then calling the function it returned
<xsperry>
(actually I guess that is partial application)
<equwal>
Well yes.
<equwal>
That is the same :P
<xsperry>
:)
<xsperry>
anything we can do in CL to make that more readable? custom macros included
<xsperry>
by more readable, I mean less verbose
mange has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
<equwal>
Yeah partial application is a mess. I'm not sure where I stand on the lisp-1 lisp-2, definitely pluses to both sides.
<equwal>
I think clojure does something like ((partial 1+) 1) => 2
<stacksmith>
Good morning. Apologies for slightly off-topic question.. Can someone help me out with roswell? I royally screwed up my environment by deleting an old version of sbcl-bin...
<xsperry>
I only played with clojure briefly, but if f is a variable that stores a function that returns a function, I am pretty sure what I typed above will work.. ie ((f 10) 20)
<equwal>
Right, but you can make the function f like (partial f 10) out of a function (defun f2 (x y) something)
<equwal>
So you could do (funcall (partial f 10) 20) or whatever, which is marginally more readable I guess.
<xsperry>
yeah, true
NotSpooky has quit [Quit: Leaving]
Guest12397 has joined #lisp
<xsperry>
actually I guess what I'd really like is do it in CL like haskell does it. where this would be just f 10 20 (since (defun f2 (x y) ..) equivalent in haskell is really just a function that takes one argument and returns a function that takes another)
<xsperry>
which would be ((f 10) 20) in lisp syntax, even if we defined f as (defun f (x y) ..)
<xsperry>
which would be ((f 10) 20) in lisp syntax, even if we defined f as (defun f (x y) ..)
<xsperry>
(sorry)
<equwal>
Yes, I know exactly what you mean. You don't want to have to (defun f (x) (lambda (y) (+ x y)))
<xsperry>
right
<equwal>
You want to be able to (defun f (&rest stuff) (apply #'+ stuff))
Guest123` has joined #lisp
Guest12397 has quit [Remote host closed the connection]
aindilis has quit [Ping timeout: 240 seconds]
<aeth>
Bike: "you could just define a :before on (setf slot-value-using-class)" I can't get that to work. It doesn't seem to be called.
<loke>
aeth: what did you try?
tll has joined #lisp
<aeth>
The only thing that has any noticable effect at all is (defmethod slot-value-using-class :before (class object slot) ...) which gives an SBCL error, which makes sense because I'm probably redefining some built-in.
<loke>
aeth: you need to defmethod sb-mop:slot-value-using-class
<loke>
(or use closer-mop)
<Bike>
where does it have t he reader and writer semantics...
gjvc has quit [Quit: leaving]
<loke>
aeth: I'm pretty sure you are notpicking up slot-value-using-class from the correct package (which is why you need to use SB-MOP, or load closer-mop so that you get a standard interface to it)
<aeth>
I'm using closer-mop
<Bike>
if that was the case i don't see why the unqualified method would cause an error.
<loke>
so did you defmethod CLOSER-MOP:SLOT-VALUE-USING-CLASS?
pierpal has quit [Ping timeout: 265 seconds]
Guest123` has quit [Remote host closed the connection]
<aeth>
loke: Yes, and if I M-. it it'll take me to SBCL's definition (or it would if it had a valid builddir)
tll has quit [Read error: Connection reset by peer]
<loke>
aeth: Show some code
<aeth>
(defmethod (setf slot-value-using-class) :before (new-value class object (slot slot-with-checked-type)) (format t "~S ~S~%" new-value (slot-definition-checked-type slot)) (check-type new-value integer))
<aeth>
That should have two visible side effects. It should print and it should almost always fail
<aeth>
I've also tried it with the class given
<Bike>
7.5.2 says they go through slot-value
tll has joined #lisp
tll has quit [Client Quit]
Guest123` has joined #lisp
<equwal>
I whipped up some partial application last month and just uncovered that file, I'll just dump the code here. The function we are looking at is called partial. This is why I brought up this "solution," which really solves a different problem then "how can we write (funcall (funcall ...) better, and instead solves the problem "how can we take a two argument function and make it partially applied to one argument."
<Bike>
hm, i don't see any output on sbcl for setf svuc either
<xsperry>
equwal thanks a lot for the effort! but I was thinking of tackling this from the other way around.. from the call site. so I can use all the functions that are available.
Guest123` has quit [Ping timeout: 256 seconds]
<xsperry>
(defun f (x y) .. ) to turn (f 10) into (lambda (x) (f 10 x)). and also to make curried functions callable like this ((f 10) 20), not like this (funcall (f 10) 20)
<xsperry>
would this be even possible? it would obviously only work in the body of my macro
<equwal>
Definitely it is possible, but I don't know how you would do it yet.
patlv has joined #lisp
<Bike>
the latter isn't really possible without a silly level of hacks.
<equwal>
I agree.
Guest123` has joined #lisp
subroot has quit [Ping timeout: 260 seconds]
<LdBeth>
equwal: CL21 provides some syntactic sugar for easier writing anonymous function.
<aeth>
And no matter how many side effects I add, it never happens.
<Bike>
you don't need the call-next-methods...
<aeth>
And whatever combination of whatever
<Bike>
but yeah, i think sbcl might be skipping it
marusich has joined #lisp
<aeth>
Not just SBCL
<aeth>
CCL also lets invalid things happen
<aeth>
e.g. I can set the name to 42. (let ((s (make-instance 'shader :name :hello :stage :fragment-shader :source ""))) (setf (zombie-raptor/data/shader::name s) 42) (zombie-raptor/data/shader::name s))
<loke>
aeth: You might want to try with a dfifferent metaclass
<Bike>
what's wrong with this metaclass
<loke>
you'r eusing standard-class, no?
<Bike>
no, there's a checked-types metaclass.
<xsperry>
Bike interesting! I'll play with your and equal's code. I am curious, and I must be missing something, but why would the other thing require silly level of hacks? ((x 10) 20) is only legal in CL if x is lambda, as far as I know. so can't we just prepend all ((x .. ) .. ) forms with funcall?
<aeth>
I stripped out as much as I could and I've been changing around as much as I can in those 50ish lines for the past few hours
<xsperry>
equwal*
<Bike>
xsperry: there is no mechanism to do such prepension.
<equwal>
But ((f 10) 20) works in Scheme, because that's just the syntax.
<Bike>
yes.
<loke>
Technically, it works in scheme because the first element in a form is evaluated, while it isn't in CL
<Zhivago>
You can ((lambda (x) (+ x 1)) 2) if you like.
Guest123` has joined #lisp
<Zhivago>
There is no principled reason that ((f 10 ) 20) shouldn't work in CL also -- it's just not supported.
<equwal>
Okay then.
<LdBeth>
It’s still possible for (#c(f 10) 20) to work
<xsperry>
just so we are both on the same page, I am talking about this syntax only working in custom macro, that would walk the entire tree, and prend funcall to all such forms where car is a list. why wouldn't this work?
<xsperry>
s/both/all
<Bike>
oh. that wouldn't work because you can't really walk code simply like that.
Oladon has quit [Quit: Leaving.]
<LdBeth>
xsperry: (let (funcall (x 10) ...
<LdBeth>
If the macro is two simple, it’s very possible to get get invalid code
vaporatorius has quit [Remote host closed the connection]
Guest123` has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<xsperry>
good example.. it would break all the macros where ((..)) is legal
brettgilio has joined #lisp
<xsperry>
and we can't just check if ((x ..) ..) x is a function. because even if it is, (let ((x 10)) ..) should still be left untouched
<loke>
Technically, it works in scheme because the first element in a form is evaluated, while it isn't in CL
<loke>
Oops
<equwal>
Looks like parser stuff to me.
<equwal>
loke: what makes you sure that is why?
<loke>
equwal: Well, it's more complicated than that
<loke>
Even if CL did evaluate the first element, you wouldn't get Scheme's behaviour
karlosz has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Ping timeout: 268 seconds]
<aeth>
loke: The problem is slot
<Bike>
oh, shit, wait
<loke>
equwal: The problem is that you can have separate value and function bindings for a symbol.
<Bike>
you subclassed DIRECT slot definition
<Bike>
Doh
<Bike>
hm or maybe that's not it
<aeth>
Bike: I already thought of that. My current version subclasses standard-slot-definition and then I have double-inheriting versions for direct and effective
<equwal>
loke: in other words it is tangentially related to the lisp-1 lisp-2 debate we started out with.
<loke>
Here's the most recent code I wrote that implemented a custom metaclass and overriding SLOT-VALUE-USING-CLASS:
<aeth>
Bike: Okay, so I do get the side effect if I have the signatures (new-value (class checked-types) object slot) and ((class checked-types) object slot)
<aeth>
And if I make the side effect (format t "~S~%" (class-of slot)) I get #<standard-class sb-mop:standard-effective-slot-definition>
<equwal>
xsperry: I think you could get what you want by messing around with a parser. Flip to page 26 of SICP for details. There are problems with this kind of compiler, but whatever. http://web.mit.edu/alexmv/6.037/sicp.pdf
<Bike>
mop effective-slot-de-cl
<specbot>
Couldn't find anything for effective-slot-de-cl.
<Bike>
mm, maybe since you didn't define a method on compute-slots, it loses the :checked-type initarg
<Bike>
er not that one
<Bike>
the... slot mixy one....
<Bike>
compute-effective-slot-definition. that one
<equwal>
so the substitution model, replace ((f 10) 20) where f is definted using Bike's schonfinkel with ((lambda f (10)) 20) and you are in business.
<equwal>
But really at this point I feel like hairs are being split.
<loke>
equwal: It could, but what would you do if F returns a symbol?
<loke>
equwal: You could probably define (X ...) to be equivalent to (funcall X ...), but that was never done.
<aeth>
(And, yes, I'm commiting semi-broken code straight to master, which is evil.)
<Bike>
i'm sticking with my diagnosis
Kundry_Wag has joined #lisp
<equwal>
loke: Yeah, I think the easiest way is to merge the symbol and function tables into a Lisp-1 at this point.
<loke>
equwal: Easy, yes. That's why Scheme did it. They wanted to be simple. It's less useful though.
<Zhivago>
It doesn't matter for this -- given (a b c) which has been macroexpanded to evaluate, a names a function. Allowing a to be a function name producing form wouldn't affect lisp-1 vs lisp-2.
<aeth>
Well, I didn't import standard-effective-slot-definition and I did *NOT* get an error. Fixing that didn't fix it, though.
<Bike>
hey. aeth. compute-effective-slot-definition. i'm tellin ya
<aeth>
Apparently you can just inherit from random non-existent things without issues
<Bike>
forward referencing a superclass, sure.
<Bike>
there'd be a problem if yuou were actually instantiating the class, but you aren't
terpri has joined #lisp
<equwal>
Zhivago: The loke asked what if #'a produces a symbol name. The answer is everything breaks because we are in a lisp-2
Kundry_Wag has quit [Ping timeout: 264 seconds]
marusich has quit [Quit: Leaving]
zfree has quit [Read error: Connection reset by peer]
<aeth>
Bike: What is compute-effective-slot-definition supposed to return?
<Bike>
it takes a list of all the inherited direct slot definitions and returns an effective slot definition
<Bike>
the standard method doesn't know jack about your class and its extra slot, so it ignores it
equwal has left #lisp ["ERC (IRC client for Emacs 26.1)"]
zfree has joined #lisp
Guest39745 has quit [Ping timeout: 240 seconds]
<LdBeth>
gg, I believe it’s easier to work out a basic lambda calculator rather than hacking on CL’s read and eval behavior
zfree has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
brettgilio has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
zfree has joined #lisp
Inline has quit [Quit: Leaving]
orivej has joined #lisp
zfree has quit [Client Quit]
<aeth>
Is there a way to get the return value of a method when I'm in an :after method?
<loke>
aeth: no
<aeth>
compute-effective-slot-definition is simply too complicated, but if I can take the end result of it and set the unbound check-type value then everything would work
<aeth>
In my effective-slot-definition-class method, I was checking for checked-type. If checked-type was present, I returned (find-class 'effective-slot-with-checked-type) and otherwise I returned (call-next-method)
<aeth>
checked-type is always nil
<aeth>
This is because the initargs are (compute-effective-slot-definition-initargs class dslotds)
<aeth>
They're hardcoded to be the standard initargs
vlatkoB has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
<Colleen>
beach: karlosz said 8 hours, 15 minutes ago: err, scratch that. the variable being assigned to is what we both mean. its not a terribly complex special case to add, but i fear that any manipulation with assignment instructions will end up having to test for something similar
<Colleen>
beach: karlosz said 8 hours, 30 minutes ago: also, you surely must mean right hand side of the assignmnet
<Colleen>
beach: karlosz said 8 hours, 52 minutes ago: yes, thats the special casing i am talking about
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
kerrhau has quit [Ping timeout: 276 seconds]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
drduck` has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
EvW has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ofi has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
EvW has quit [Ping timeout: 256 seconds]
aindilis has joined #lisp
ntqz has joined #lisp
fikka has joined #lisp
himmAllRIght17 has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
ntqz has quit [Read error: Connection reset by peer]
himmAllRIght17 has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<aeth>
Using assert with typep instead of check-type is ugly, though
ntqz has joined #lisp
<aeth>
Apparently I can't use change-class with the MOP slot classes so the only way I could think of writing the implementation via :around is to make them all effective-slot-with-checked-type and use nil for the ones that don't actually have a type to check.
MichaelRaskin has quit [Quit: MichaelRaskin]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
robotoad has quit [Quit: robotoad]
Kundry_Wag has joined #lisp
ntqz has joined #lisp
impulse- has quit [Ping timeout: 248 seconds]
saki has quit [Quit: saki]
Kundry_Wag has quit [Ping timeout: 268 seconds]
shka1 has quit [Ping timeout: 240 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ofi has quit [Remote host closed the connection]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
ntqz has joined #lisp
ebzzry has quit [Quit: WeeChat 2.1]
flamebeard has quit [Client Quit]
snits has quit [Ping timeout: 240 seconds]
igemnace has joined #lisp
snits has joined #lisp
xaotuk has joined #lisp
ebzzry has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
scymtym has quit [Ping timeout: 240 seconds]
impulse has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
xificurC has joined #lisp
ntqz has joined #lisp
fikka has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
Folkol_ has joined #lisp
ntqz has joined #lisp
ofi has joined #lisp
ravndal has quit [Ping timeout: 244 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
Smokitch has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
impulse has quit [Ping timeout: 268 seconds]
ntqz has joined #lisp
flamebeard has joined #lisp
ravndal has joined #lisp
saki has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
gousuto has quit [Read error: Connection reset by peer]
gousuto has joined #lisp
gousuto has quit [Changing host]
gousuto has joined #lisp
gousuto has quit [Read error: Connection reset by peer]
gousuto has joined #lisp
gousuto has quit [Changing host]
gousuto has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
xaotuk has quit [Ping timeout: 276 seconds]
igemnace has quit [Quit: WeeChat 2.2]
ntqz has joined #lisp
rumbler31 has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
shrdlu68 has joined #lisp
angavrilov has joined #lisp
Guest39745 has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
schweers` has joined #lisp
ntqz has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
schweers has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
impulse has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
gravicappa has joined #lisp
Kundry_Wag has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 256 seconds]
mflem has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 256 seconds]
ntqz has joined #lisp
shrdlu68 has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
housel has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
gousuto has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
fikka has quit [Quit: leaving]
fikka has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
araujo has quit [Ping timeout: 248 seconds]
schweers` has quit [Remote host closed the connection]
ntqz has joined #lisp
shrdlu68 has quit [Ping timeout: 244 seconds]
shrdlu68 has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ofi has quit [Remote host closed the connection]
ntqz has joined #lisp
ofi has joined #lisp
capisce has quit [Read error: No route to host]
capisce has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
makomo has joined #lisp
shrdlu68 has quit [Client Quit]
ntqz has quit [Read error: Connection reset by peer]
hhdave has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
Oddity has quit [Read error: Connection reset by peer]
mange has quit [Remote host closed the connection]
milanj__ has joined #lisp
heisig has joined #lisp
ntqz has joined #lisp
MoziM has joined #lisp
saki has quit [Ping timeout: 240 seconds]
Oddity has joined #lisp
saki has joined #lisp
impulse has quit [Ping timeout: 256 seconds]
Murii__ has joined #lisp
Kundry_Wag has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
faraco has joined #lisp
faraco has quit [Changing host]
faraco has joined #lisp
subroot has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
ntqz has joined #lisp
rozenglass has quit [Read error: Connection reset by peer]
ntqz has quit [Read error: Connection reset by peer]
impulse has joined #lisp
ntqz has joined #lisp
panji has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
faraco has quit [Quit: Leaving]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
dddddd has joined #lisp
_cosmonaut_ has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
lumm has joined #lisp
subroot has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
light2yellow has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<shka>
hello
<shka>
i have question regarding changelog of sbcl 1.4.3
<shka>
"bug fix: fixed heap exhaustion bug when consing millions of small objects "
<shka>
how this would manifest?
<shka>
just heap exhausted game over?
m00natic has joined #lisp
random-nick has joined #lisp
ntqz has joined #lisp
Murii__ has quit [Quit: Salve]
Murii has joined #lisp
panji has quit [Ping timeout: 248 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
nirved has joined #lisp
nirved has quit [Quit: Leaving]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ntqz has quit [Read error: Connection reset by peer]
<jmercouris>
it makes literally no sense to me
<jackdaniel>
jmercouris: it is enough to look in the spec for definition of * and + functions
<jackdaniel>
and how they behave if no numbers are supplied
<jmercouris>
I see
<jmercouris>
and why is * -> 1?
<trittweiler>
shka: You can git blame NEWS in the sbcl git repository, to determine which commit the changelog entry is about. Usually, changes come with tests. See https://github.com/sbcl/sbcl/commit/dfddbc8ada - you could try that test in sbcl 1.4.2 to see exactly what happens. But yes, to me that reads like game over.
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<beach>
jmercouris: It's the neutral element for multiplication.
<jackdaniel>
because (*) is by definition = 1, part of the spec. it is only natural, because neutral element for multiplication is 1
<jackdaniel>
heh, too late
<jmercouris>
I understand it doesn't effect the value
<jmercouris>
but why wouldn't it instead return an error?
<jmercouris>
like insufficient number of parameters or something?
<LdBeth>
It’s very natural from a math perspective
<jmercouris>
is there some implementation reason? or is it just so defined?
<beach>
jmercouris: It is defined that way in mathematics and in Common Lisp.
<trittweiler>
jmercouris, it is defined so to play nicely with REDUCE :)
<jackdaniel>
you would be suprised what happens, if you supply negative number of arguments, try it! :-)
Folkol has quit [Read error: Connection reset by peer]
<jmercouris>
so when I write 5 * 5 = 10, I'm really writing 5 1 5 = 10?
<beach>
No.
AetherWind has quit [Quit: Leaving]
<beach>
And it is 25.
<jmercouris>
lol
<jmercouris>
sorry
ntqz has joined #lisp
<jmercouris>
whoops :D
<jmercouris>
okay, so to multiply something, we agree that you need at least two values, right?
DataLinkDroid has joined #lisp
<jackdaniel>
um, no?
<LdBeth>
No
<trittweiler>
shka, there should also be a mail on sbcl-devel around dec 4, 2017, about this problem - as per the commit message
<jmercouris>
Okay, explain to me, how multiplication of a single value works?
<jackdaniel>
(* n) === n
<jmercouris>
as far as I am concerned, you need a source number, and a multiple
<jmercouris>
you've still provided a multiple, but it is just a value of 1
varjag has joined #lisp
<beach>
. The product of no factors at all is known as the empty product, and is equal to 1.
<beach>
jmercouris: Under "Product of sequences" on that page.
<jackdaniel>
do you have *any* practical purpose of these questions, or you just broadly share your amusement? (given you know [from the spec] how * and + functions work when supplied with 0 arguments)?
<jackdaniel>
and see you in 10y when you finish with studying math basics ;-)
<scymtym>
jackdaniel: commutativity is not needed, though
<jmercouris>
jackdaniel: I'm okay without :D, perhaps my curiousity is not as strong as I thought
<beach>
Apparently.
<beach>
It ought to be though.
<jmercouris>
beach: I like computer science, but I don't like math
<beach>
Intellectual curiosity is the basis of much learning.
<loke>
However... The single-argument version of ‘/’ _is_ arbitrary though (but useful)
<loke>
Yes?
<jmercouris>
I hve a deep distaste for math
ntqz has joined #lisp
<jmercouris>
s/hve/have
<beach>
jmercouris: I am sorry to hear that.
<jackdaniel>
it is not something to brag about
<jmercouris>
jackdaniel: am I bragging?
<jackdaniel>
scymtym: you mean operations on floats?
<jmercouris>
I am simply being honest
ntqz has quit [Read error: Connection reset by peer]
<jackdaniel>
(and such:)
<jmercouris>
it's not like I am proud or anything, I don't think I've ever brought it up on this channel before
<LdBeth>
I should look at J’s introductory, i remember there’s a section gives a explain about that
gigetoo has quit [Ping timeout: 240 seconds]
<LdBeth>
See you in few minutes
<jmercouris>
beach: Yeah, it is because math is quite difficult for me, at least certain types of math, I'm very good at geometry, physics, but not so good with discrete mathematics and algebra
<scymtym>
jackdaniel: an Abelian group is a group plus commutativity if i recall correctly, but the commutativity is not relevant to this discussion (i completely agree with pointing out the concept of a group as the underlying reason, though)
<jackdaniel>
ah, OK
<jackdaniel>
I misunderstood
fikka has quit [Ping timeout: 244 seconds]
ntqz has joined #lisp
xsperry has quit [Quit: CGI:IRC (Session timeout)]
pioneer42 has left #lisp [#lisp]
ntqz has quit [Read error: Connection reset by peer]
MoziM has quit [Quit: WeeChat 2.1]
xaotuk has joined #lisp
BitPuffin has joined #lisp
gigetoo has joined #lisp
Posterdati has quit [Ping timeout: 240 seconds]
ntqz has joined #lisp
<LdBeth>
Well, then, J just tells 0 = +/ 0$0, 1 = */ 0$0，and I have to explain what’s identity and rank to make it more clean. So i give up.
<jmercouris>
I guess the real problem with languages like python is primitive operators change the function order
<jmercouris>
so normally you might say in python function_call(x, y z)
<jmercouris>
but of course for the + operator you nest it between two numbers
<jmercouris>
so the order is now different, which makes it impossible to express nil * nil
<jmercouris>
of course removing "nil" and replacing it with nothing
ntqz has quit [Read error: Connection reset by peer]
fikka has joined #lisp
ntqz has joined #lisp
<heisig>
Which are, luckily, off-topic :)
<shka>
well, cl also has problems
<beach>
Nah!
<jmercouris>
I think it has a few
<jmercouris>
but I haven't really mastered the language enough to truly criticize it
ntqz has quit [Read error: Connection reset by peer]
<jmercouris>
I can only say that the naming conventions, and the argument order are very confusing frequently
<shka>
but at least cl seems to be more solidly designed
<shka>
probabbly, one extra standard version would fix everything that is suboptimal
orivej has joined #lisp
<jmercouris>
I would be very much in favor of this, but I understand it would take a lot of work from many people
ntqz has joined #lisp
<LdBeth>
A superset language is easier than new specification
<jmercouris>
Yes, this argument comes up every time, and it is valid, but it would feel nice to have a new specification
<beach>
There are SO many more important things to do than to update the standard this way.
<jmercouris>
something about a new, unified, super squeaky clean spec sounds nice to me
<tfb>
I think the diffference is that, if you feel that CL is creaky (which I do slightly, now), you can, in almost all cases, make your own variant which is not and which will run on top of the existing language. You can't do that in Python without serious pain
<LdBeth>
jmercouris: schemers wrong door : P
xaotuk has quit [Ping timeout: 240 seconds]
<tfb>
beach: yes, agree -- if you want a new better (for you) CL implement one on top of the old CL, which is what we all do.
<jmercouris>
yes, but if everyone is doing that, wouldn't it be nice to have a unified set of improvements?
<jmercouris>
I don't mean to beat a dead horse, so I'll stop now
<LdBeth>
Out of curiosity, has anyone implemented Scheme on top of CL?
ntqz has quit [Read error: Connection reset by peer]
makomo has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
<LdBeth>
I’m looking for a more recent one which implements pattern match based macro
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jmercouris>
what does "D" in "DTRACE" stand for?
ntqz has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Folkol_ has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
<Posterdati>
D = Deadful
fikka has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
<jackdaniel>
CL lacks semantics for efficient (i.e without emulation) implementation of call/cc
fikka has quit [Ping timeout: 244 seconds]
ntqz has quit [Read error: Connection reset by peer]
<jackdaniel>
so it would by hard I think to implement non-toy scheme in CL
<tfb>
jmercouris: dynamic
<tfb>
assuming you mean the thing that originated in solaris
ntqz has joined #lisp
<beach>
jackdaniel: Only if you insist on a fairly direct translation from Scheme to Common Lisp.
<beach>
jackdaniel: OK, I guess that's what you meant by "without emulation".
ntqz has quit [Read error: Connection reset by peer]
<tfb>
beach: I think it's only interesting if the shim is fairly thin (so, say, you could call into and out of Schemy things) as otherwise you might as well just use one of the 9 billion existing schemes
<beach>
Yes, I see.
fikka has joined #lisp
ntqz has joined #lisp
rumbler31 has joined #lisp
xaotuk has joined #lisp
saki has quit [Ping timeout: 256 seconds]
<jackdaniel>
right, I'm not claiming that you can't write Scheme compiler in CL (vice versa is possible too) - both are general purpose programming languages after all
<beach>
Right.
saki has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jmercouris>
tfb: I was thinking in the context of gentle introduction to symbolic computation
JuanDaugherty has joined #lisp
ntqz has joined #lisp
rumbler31 has quit [Remote host closed the connection]
ntqz has quit [Read error: Connection reset by peer]
<tfb>
jmercouris: I certainly think implementing little Lisps in CL is interesting.
ntqz has joined #lisp
pierpal has quit [Quit: Poof]
<jmercouris>
tfb: I didn't say anything about little lisps in cl?
pierpal has joined #lisp
<jackdaniel>
why do you ask that? shouldn't you know what you did say?
<jackdaniel>
(or didn't)
<tfb>
Oh sorry, I was getting confused between the dtrace thing and the scheme-in-CL thing
<tfb>
jmercouris: sorry, see prev msg
Smokitch has quit []
ntqz has quit [Read error: Connection reset by peer]
JuanDaugherty has quit [Quit: Exeunt]
<jmercouris>
I see
cgay_ has joined #lisp
<jmercouris>
whoops :)
ntqz has joined #lisp
schweers has joined #lisp
sthalik has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
markoong has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
terpri has quit [Ping timeout: 268 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
Folkol has joined #lisp
graphene has quit [Remote host closed the connection]
ntqz has quit [Read error: Connection reset by peer]
graphene has joined #lisp
<tfb>
jmercouris: and I guess 'detailed'?
Satou has joined #lisp
ntqz has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
vap1 has joined #lisp
<jmercouris>
could be, that would make sense
Satou has quit [Client Quit]
X-Scale has quit [Ping timeout: 248 seconds]
karlosz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
krrrcks has quit [Ping timeout: 256 seconds]
ntqz has quit [Read error: Connection reset by peer]
EvW has joined #lisp
krrrcks has joined #lisp
wigust has joined #lisp
vaporatorius has quit [Quit: Leaving]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
Bike has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
patlv has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
brendyn has quit [Ping timeout: 244 seconds]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
jmercouris has quit [Remote host closed the connection]
Raybih has joined #lisp
ntqz has joined #lisp
Kundry_Wag_ has joined #lisp
graphene has quit [Remote host closed the connection]
Kundry_Wag_ has quit [Client Quit]
ntqz has quit [Read error: Connection reset by peer]
mindCrime has joined #lisp
graphene has joined #lisp
karlosz has quit [Quit: karlosz]
Kundry_Wag has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
jmercouris has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
rumbler31 has joined #lisp
warweasle has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 265 seconds]
ntqz has joined #lisp
karlosz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
patlv has quit [Ping timeout: 240 seconds]
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
ntqz has joined #lisp
sjl has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
ntqz has quit [Read error: Connection reset by peer]
xaotuk has quit [Remote host closed the connection]
slyrus1 has quit [Quit: slyrus1]
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
terpri has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
Raybih has quit []
ntqz has quit [Read error: Connection reset by peer]
kingcons has joined #lisp
jeosol_ has joined #lisp
JuanDaugherty has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
morning guys
<beach>
Hello jeosol_.
<jeosol_>
anyone following AWS summit in NY. It will be nice to see how CL plays into most of these. As a single developer, I am trying to see how I get my apps to scale if I get to that step
<jeosol_>
morning beach
ntqz has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
broccolistem has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
housel has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
jmercouris: thanks for your input about running my remote jobs. I saw it but could not respond back. My use case is a bit crazy, something between running in slime and running jobs on LINUX command line after launching SBCL
<jeosol_>
So what I do normally, I have a monitor on one side with code, and some linux terminals. Since I am testing different configs, I usually create a new defun, and just run it on the a linux terminal.
<JuanDaugherty>
somehow it doesn't seem like AWS can be amazon web services
ntqz has joined #lisp
<JuanDaugherty>
except for the scaling part
mindCrime has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
JuanDuagherty: Sorry I didn't make that clear enough, but yes, AWS -> Amazon Web Services
<jeosol_>
I have been interested in the AI/ML/DS capabilities
graphene has quit [Read error: Connection reset by peer]
<jeosol_>
the->their
<JuanDaugherty>
most 'apps' don't even have parallelization opportunities other than serving many users and that's highly routinized by such places and various pkgs now
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
graphene has joined #lisp
<JuanDaugherty>
DS?
asarch has joined #lisp
<jeosol_>
ah my bad Jaun. ..
<JuanDaugherty>
deep search?
<jeosol_>
I meant Data Science
<JuanDaugherty>
ah
<jeosol_>
oh really sorry about that
Kundry_Wag has quit [Ping timeout: 248 seconds]
pierpal has quit [Quit: Poof]
fikka has joined #lisp
slyrus1 has joined #lisp
pierpal has joined #lisp
<JuanDaugherty>
they do have some offerings in those categories, i'd be surprised if they use lisp though
ntqz has joined #lisp
<jeosol_>
I have had interests in Gabor Melis AI/ML library and the CLML library, and wanted to pick these up. Latter still have issues with license. For Gabor's code, I made small changes to work in a recent SBCL license,
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
I trained the model on my linux box, it was taking over two days to train and I killed the job. I think Gabor said he used GPU machines
* JuanDaugherty
checks if AWS offers GPUs
<jeosol_>
Yes, Juan, they have several offerings. I think it is mostly C++, Python and Java based on the low-level frameworks
<jeosol_>
JuanDuagherty: Yes, that is the plan eventually, take up the code there and if I can things to improve
ntqz has joined #lisp
<JuanDaugherty>
confirmed
<JuanDaugherty>
they even have EC2 GPUs
<JuanDaugherty>
just to see what it was like I tried a 99 thread EC2 a couple months ago
Kundry_Wag has joined #lisp
<JuanDaugherty>
lparallel is the likely suspect here i presume
<jeosol_>
thanks for that info. I will try to get back to this soon.
<jeosol_>
You mean you used the lparallel library?
fikka has quit [Ping timeout: 240 seconds]
Inline has joined #lisp
<JuanDaugherty>
i meant it is a way of getting back on topic
lumm has quit [Ping timeout: 245 seconds]
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
Oh ok.
<JuanDaugherty>
doesn't look like it's been updated in 3 y
_cosmonaut_ has quit [Ping timeout: 264 seconds]
ntqz has joined #lisp
nika_ has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<JuanDaugherty>
ql shows two more recent pkgs though
FreeBirdLjj has joined #lisp
saki has quit [Ping timeout: 240 seconds]
<JuanDaugherty>
only one of which is general lisp parallelization
<JuanDaugherty>
igess it's only newer in ql,(cl-parallel)
skapata has joined #lisp
ntqz has joined #lisp
ofi has quit [Remote host closed the connection]
<jeosol_>
JuanD ...: I didn't get your lparallel comment, it was probably from a different conversation
EvW1 has joined #lisp
skapata has quit [Read error: Connection reset by peer]
flamebeard has quit []
surya has joined #lisp
skapata has joined #lisp
DingoSaar has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
_cosmonaut_ has joined #lisp
fikka has joined #lisp
<JuanDaugherty>
disregard
ntqz has quit [Read error: Connection reset by peer]
Smokitch has joined #lisp
<jeosol_>
hmmm,
<jeosol_>
I will like to discuss with folks running lisp related applications on the web. Even when using other language frameworks around the core engine in lisp.
<JuanDaugherty>
you'll get pushback here if you don't limit yourself to common lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
robotoad has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
marvin2 has quit []
mindCrime has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
eli_oat has quit [Quit: eli_oat]
eli_oat has joined #lisp
lumm has joined #lisp
ntqz has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
ntqz has joined #lisp
EvW has joined #lisp
<jeosol_>
Ok, thanks for the info Juan...
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
sorry about that.
robotoad has quit [Read error: Connection reset by peer]
<jeosol_>
The intent was to connect and not discuss that here. I do understand the focus of this forum.
robotoad has joined #lisp
pierpal has quit [Quit: Poof]
<beach>
jeosol_: I think the topic says what it is.
<JuanDaugherty>
based on what I've looked at since we started talking, as far as common lisp is concerned lparallel still seems the default choice, imo anyway
pierpal has joined #lisp
<jeosol_>
apologies to you guys, I didn't intend to cause any problems
<jeosol_>
Like I said, I am just looking for users with similar issues as I am facing so we can share ideas. Intent was not to discuss that here ..
EvW has quit [Ping timeout: 276 seconds]
ntqz has joined #lisp
<jmercouris>
jeosol_: no problem
<JuanDaugherty>
no worries. Are you in Korea?
<jmercouris>
jeosol_: I'm running lisp applications on the web
al-damiri has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<jeosol_>
JaunD...: no, not in Korea.
<JuanDaugherty>
ah. I wonder how well the CLIM web stuff works, in remote browsers
<JuanDaugherty>
(or if it even does (as opposed to some other client))
vlad_ has joined #lisp
vlad_ is now known as DonVlad
ntqz has joined #lisp
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
mflem has joined #lisp
<beach>
Here is an idea: When I compile SICL code to HIR on SBCL, the functions created would be subclasses of STANDARD-FUNCALLABLE-OBJECT. I would have a slot in that subclass that contains a "code object".
<beach>
The code object would have information about mappings from source locations to values of the "program counter" in the form of a place in the HIR code. It would also have tables that map HIR locations to other HIR locations for various debugger stepping functions.
ntqz has joined #lisp
<beach>
At strategic points in the HIR code, I generate code to interrogate a hash table to determine whether the current thread runs under the control of the debugger. If so, it further interrogates to determine whether it is at a breakpoint.
<beach>
If so, it waits on a semaphore that is associated with the thread. The debugger uses the code object to find source location for the breakpoint. The debugger can set more breakpoints, and it then signals on the semaphore to make the application thread continue its execution.
serghey has joined #lisp
<beach>
er, I think the class name is FUNCALLABLE-STANDARD-OBJECT.
vlatkoB has quit [Remote host closed the connection]
<dlowe>
the standard object that makes calling fun
<beach>
Heh.
shka1 has joined #lisp
<jackdaniel>
funny :)
vlatkoB has joined #lisp
k4rtik has quit [Quit: WeeChat 2.2]
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
ntqz has quit [Read error: Connection reset by peer]
<TMA>
beach: ordinary debuggers use hardware breakpoints (interrupt when program counter is equal to this value) or just modify the code to "interrupt now"; I think you might achieve the one-thread debuggee, other thread runs the same code with duplicating the debugged code with breakpoints (so as the HW not to triger and to have modifiable copy)
<TMA>
beach: the only caveat is that (funcall (symbol-function XXX) ...) equivalent machinery needs to use the debugee code if one is available
<beach>
TMA: Not sure I follow. But I can't use hardware breakpoints here, because I don't want to dig deep into SBCL to find out low-level details.
ntqz has joined #lisp
<jeosol_>
jmercouris: thanks for the info. It seems my recent issues are out of focus for this forum. I'll need to follow up later.
ntqz has quit [Read error: Connection reset by peer]
<beach>
TMA: I also don't want to modify the code, even though it might be possible to not break in some situations.
Khisanth has quit [Ping timeout: 240 seconds]
<TMA>
beach: I see. With those two additional conditions other debuggers are not subjected to, you do not have much options except to instrument the code heavily as per your design.
ntqz has joined #lisp
<beach>
Yes, that decision was already made. This suggestion was about actually running and debugging SICL code inside SBCL.
Kundry_Wag has quit [Remote host closed the connection]
ntqz has quit [Read error: Connection reset by peer]
<beach>
TMA: By instrumenting the code this way, in the final system I can trivially debug system code like SYMBOL-VALUE without having the system die on me. And I can debug the debugger.
surya has quit [Remote host closed the connection]
saki has joined #lisp
<beach>
Hardware breakpoints may work in the final system. But I need to figure out how to avoid stopping when the thread is not debugged.
kajo has quit [Ping timeout: 240 seconds]
ntqz has joined #lisp
_cosmonaut_ has quit [Ping timeout: 248 seconds]
ntqz has quit [Client Quit]
Khisanth has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
JuanDaugherty has quit [Quit: Exeunt]
Guest39745 has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
karlosz has quit [Quit: karlosz]
<beach>
What's the name of that library that provides a uniform way of examining backtraces across implementation?
<beach>
across implementations.
<Xach>
beach: trivial-backtrace is one way
jasmith has quit [Ping timeout: 276 seconds]
<beach>
I think that's the one I was thinking of. Thanks.
<Xach>
beach: i believe there is another, less trivial, but the name escapes me
<beach>
I see.
Folkol has quit [Ping timeout: 240 seconds]
<Bike>
shinmera's dissect?
shka1 has quit [Remote host closed the connection]
<kingcons>
shinmera's output is pretty amazing
shka1 has joined #lisp
sthalik has quit [Quit: leaving]
<Xach>
output? is that part of quicklisp?
jasmith has joined #lisp
<kingcons>
Sorry, I meant his volume of production.
<kingcons>
I don't generate much lisp these days. :)
<Xach>
on the internet, it can be difficult to distinguish ironic stupidity from legitimate stupidity
Guest39745 has joined #lisp
<beach>
What I would need for my suggested debugging interface is to get to the function object that is executing in a particular stack frame.
Guest39745 has quit [Remote host closed the connection]
Guest39745 has joined #lisp
hhdave has quit [Ping timeout: 276 seconds]
jmercouris has quit [Ping timeout: 240 seconds]
nsrahmad has quit [Remote host closed the connection]
nsrahmad has joined #lisp
jasmith has quit [Ping timeout: 240 seconds]
wheelsucker has joined #lisp
Folkol has joined #lisp
Folkol has quit [Client Quit]
nsrahmad has quit [Quit: Leaving]
EvW1 has joined #lisp
jealousmonk has joined #lisp
heisig has quit [Quit: Leaving]
Guest39745 has quit [Read error: Connection reset by peer]
hvxgr has quit [Quit: leaving]
sauvin has quit [Remote host closed the connection]
Kaisyu has quit [Quit: Connection closed for inactivity]
jasmith has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
k4rtik has joined #lisp
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
kajo has joined #lisp
Arcaelyx has joined #lisp
equwal has joined #lisp
patlv has quit [Ping timeout: 268 seconds]
kajo has quit [Client Quit]
kajo has joined #lisp
patlv has joined #lisp
pfdietz2 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<pfdietz2>
I read this paper on mutation testing at Google. I was surprised to see one of the 7 languages involved was Common Lisp. https://ai.google/research/pubs/pub46584
Smokitch has quit []
patlv has quit [Ping timeout: 268 seconds]
equwal has quit [Ping timeout: 268 seconds]
X-Scale has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
brettgilio has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<drduck>
Also that there's a big difference between mostly dead and dead, though.
Guest39745 has quit [Quit: Konversation terminated!]
Guest39745 has joined #lisp
Guest39745 is now known as nowhere_man
xificurC has quit [Client Quit]
xificurC has joined #lisp
k4rtik has quit [Ping timeout: 240 seconds]
patlv has quit [Ping timeout: 260 seconds]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
equwal has joined #lisp
rpg has joined #lisp
equwal has left #lisp [#lisp]
patlv has joined #lisp
Ziemas has quit [Remote host closed the connection]
graphene has quit [Read error: Connection reset by peer]
Ziemas has joined #lisp
WhoTookMyName has joined #lisp
graphene has joined #lisp
WhoTookMyName has quit [Client Quit]
<drduck>
Am I able to get the latest version of SBCL on macOS?
equwal has joined #lisp
patlv has quit [Ping timeout: 260 seconds]
equwal has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
Guest83554 has quit [Read error: Connection reset by peer]
lumm has quit [Quit: lumm]
<Xach>
drduck: yes, if you build it yourself from a not-latest version.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
DingoSaar has quit [Ping timeout: 268 seconds]
equwal has joined #lisp
Pixel_Outlaw has joined #lisp
equwal has quit [Ping timeout: 268 seconds]
patlv has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
hifitim has quit [Quit: Leaving]
robotoad has joined #lisp
Jesin has quit [Ping timeout: 260 seconds]
pierpal has quit [Ping timeout: 244 seconds]
orivej has quit [Ping timeout: 244 seconds]
<drduck>
Can anyone speak on if there are any differences in the hot reload capabilities SLIME provides lisp compared to that of which an IDE provides java?
Kaisyu has joined #lisp
<whartung>
sure gimme a minute
<drduck>
Okydoke. Trying to get a grip on the differences. Very interested to hear. :)
rumbler31 has joined #lisp
emacsomancer has left #lisp ["ERC (IRC client for Emacs 26.1)"]
JuanDaugherty has joined #lisp
<whartung>
Ok, so.
rumbler31 has quit [Ping timeout: 268 seconds]
<whartung>
I don’t know exactly what slime does, but we know what CL can do. Basically the REPL, “LOAD”, and “COMPILE”. All of those impact the environment in subtle, different ways (which I can’t detail, only knowing that there’s differences.)
<whartung>
but, fundamentally
<whartung>
what’s happening
<whartung>
is Lisp has a global Symbol table.
<whartung>
and through load/compile/repl, those symbols get reassigned
<whartung>
and the symbol table is simply one aspect of the global environment, but an important one.
<whartung>
the SYMBOLS remain (unless they’re specifically unintern’ed), but what they reference changes.
<whartung>
much like reassigning the value in a hash table.
<whartung>
no, since (normally), Lisp continues do dereference stuff through symbols (when they have global scope), then you have dynamic changes to a running system. This can clearly be adjusted trhough efficiency hints and stuff like that, but at the high level, if you have (defun x () (print “hello world”)), and something calls (x), if you later do (defun x () (print “goodbye world”)), that existing reference x will now say “goodbye” instead of “hello
<whartung>
without recompiling that reference.
<whartung>
and, as I mentioned there are exceptions (like inlining code and what not).
<whartung>
So, that’s what SLIME does, is it “simply” updates the global environment, and then the chips fall where they may.