eschatologist has quit [Remote host closed the connection]
eschatologist has joined #lisp
wigust has quit [Ping timeout: 252 seconds]
safe has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
lclark``` has quit [Ping timeout: 248 seconds]
manualcrank has quit [Quit: WeeChat 2.0.1]
smurfrobot has joined #lisp
manualcrank has joined #lisp
wxie has joined #lisp
smurfrobot has quit [Ping timeout: 265 seconds]
manualcrank has quit [Client Quit]
smurfrobot has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
manualcrank has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
rumbler31 has joined #lisp
zaquest has quit [Read error: Connection reset by peer]
asarch has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
spoken-tales has joined #lisp
pagnol has quit [Ping timeout: 252 seconds]
smurfrobot has joined #lisp
zaquest has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
z3t0 has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 248 seconds]
libreman has quit [Ping timeout: 256 seconds]
raphaelss has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
libreman has joined #lisp
smurfrobot has joined #lisp
raphaelss has joined #lisp
smurfrobot has quit [Ping timeout: 272 seconds]
wxie has quit [Remote host closed the connection]
parjanya has quit [Remote host closed the connection]
z3t0 has joined #lisp
parjanya has joined #lisp
smurfrobot has joined #lisp
z3t0 has quit [Ping timeout: 268 seconds]
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
varjag has quit [Ping timeout: 272 seconds]
karswell has quit [Read error: Connection reset by peer]
karswell has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
dieggsy has quit [Remote host closed the connection]
varjag has joined #lisp
quazimodo has joined #lisp
jmercouris has quit [Remote host closed the connection]
smurfrobot has joined #lisp
z3t0 has joined #lisp
varjag has quit [Ping timeout: 252 seconds]
smurfrobot has quit [Ping timeout: 264 seconds]
z3t0 has quit [Ping timeout: 264 seconds]
z3t0 has joined #lisp
markong has quit [Ping timeout: 250 seconds]
z3t0 has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
spoken-tales has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
z3t0 has joined #lisp
wxie has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
d4ryus1 has joined #lisp
z3t0 has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
d4ryus has quit [Ping timeout: 248 seconds]
philosaur has quit [Quit: philosaur]
philosaur has joined #lisp
z3t0 has joined #lisp
damke_ has joined #lisp
z3t0 has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 264 seconds]
zaquest has quit [Quit: Leaving]
pagnol has joined #lisp
dalkire has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<dalkire>
is anyone familiar with socket programming using usocket? i'm trying to connect to a server, but i'm having some difficulties and i don't exactly know how to go about debugging.
<dalkire>
i'd like to inspect the usocket:datagram-usocket i get back, but i get an error trying (slot-value *socket* 'connected-p)
red-dot has joined #lisp
nika has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
<pagnol>
dalkire, what about using wireshark?
smurfrobot has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 263 seconds]
bgardner has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
JuanDaugherty has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
smurfrobot has joined #lisp
epony has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 272 seconds]
uuplusu has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
wxie has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 256 seconds]
Acherontius has joined #lisp
<beach>
Good morning everyone!
<JuanDaugherty>
moin beach
pagnol has quit [Ping timeout: 248 seconds]
<JuanDaugherty>
does your ISP assign a v6 address?
<beach>
Maybe so.
bgardner has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
conceivably has joined #lisp
LiamH has quit [Quit: Leaving.]
dddddd has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Acherontius has quit [Quit: WeeChat 2.0.1]
fikka has quit [Ping timeout: 248 seconds]
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
epony has joined #lisp
epony has quit [Max SendQ exceeded]
epony has joined #lisp
Acherontius has joined #lisp
red-dot has joined #lisp
Acherontius has quit [Client Quit]
Acherontius has joined #lisp
JonSmith has joined #lisp
z3t0 has joined #lisp
bkst_ has quit [Ping timeout: 265 seconds]
bkst has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
ykoda has joined #lisp
smurfrobot has joined #lisp
Kyo91` has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
raphaelss has quit [Remote host closed the connection]
epony has quit [Remote host closed the connection]
smurfrobot has joined #lisp
ykoda has quit [Remote host closed the connection]
epony has joined #lisp
Acherontius has quit [Quit: WeeChat 2.0.1]
epony has quit [Max SendQ exceeded]
epony has joined #lisp
asarch has quit [Quit: Leaving]
smurfrobot has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
schoppenhauer has quit [Ping timeout: 260 seconds]
schoppenhauer has joined #lisp
conceivably has quit [Remote host closed the connection]
uuplusu has quit [Remote host closed the connection]
epony has quit [Remote host closed the connection]
smurfrobot has joined #lisp
uuplusu has joined #lisp
JJBby has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<JJBby>
I am just getting started on learning programing and Lisp seems very interesting any good reads on why to try list?
<JJBby>
lisp*
red-dot has joined #lisp
<beach>
I don't understand. Do you want a book to learn Common Lisp?
<beach>
If so, and if you already know some other programming language, then most people here recommend PCL.
<beach>
minion: Please tell JJBby about PCL.
<minion>
JJBby: direct your attention towards PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
smurfrobot has quit [Ping timeout: 264 seconds]
<JJBby>
beach, i think i was looking more for something explaining lisp and its uses. or an overview of lisp
<beach>
Yes, I see.
<parjanya>
he seems to be just starting programming at all, and asks why Lisp would be a good one to start with
<beach>
There must be stuff on the net, but nothing comes to mind right now.
<JJBby>
whats your experience and thoughts on lisp?
<beach>
JJBby: Otherwise, Common Lisp is a general-purpose programming language that supports multiple paradigms, so you can use it for basically anything.
<JJBby>
and PCL has the first chapet called "why lisp"
<beach>
Oh, OK.
<parjanya>
it’s quite a broad question, JJBby :) most languages do things more or less the same, they differ in small details; lisp is quite different overall, and people tend to say that lisp teaches one to think about programming in a better way
<parjanya>
I would start reading the Practical Common Lisp and see how that feels... try it, nothing anyone says will replace you trying
pierpa has quit [Quit: Page closed]
Kyo91` has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
rumbler31 has joined #lisp
<JJBby>
yeah diving into that first chapter now
<beach>
Yes, it looks pretty good for what you are looking for.
smurfrobot has quit [Ping timeout: 260 seconds]
JonSmith has quit [Remote host closed the connection]
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
smurfrobot has joined #lisp
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
Poeticode has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
wxie has joined #lisp
smurfrobot has quit [Ping timeout: 268 seconds]
Poeticode has joined #lisp
wxie has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
lagagain has joined #lisp
damke_ has joined #lisp
<beach>
JJBby: I just finished reading that chapter of PCL, and it is quite complete.
damke has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
turkja has joined #lisp
epony has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
epony has quit [Max SendQ exceeded]
epony has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
epony has quit [Quit: QUIT]
epony has joined #lisp
rumbler31 has quit [Remote host closed the connection]
epony has quit [Max SendQ exceeded]
epony has joined #lisp
rippa has joined #lisp
JonSmith has joined #lisp
<jasom>
minion: message for dalkire: UDP sockets are connectionless
<minion>
watch out, you'll make krystof angry
<jasom>
minion: memo for dalkire: UDP sockets are connectionless
<minion>
Remembered. I'll tell dalkire when he/she/it next speaks.
<jasom>
minion: your strictness in grammar and syntax is annoying
<minion>
what's up?
JonSmith has quit [Ping timeout: 248 seconds]
mlau has quit [Ping timeout: 268 seconds]
red-dot has joined #lisp
OS-26949 has joined #lisp
waynecolvin has joined #lisp
Poeticode has quit [Changing host]
Poeticode has joined #lisp
eSVG has joined #lisp
eviltofu has joined #lisp
<eviltofu>
Hello
uuplusu has quit [Remote host closed the connection]
<beach>
Hello eviltofu.
LocaMocha has joined #lisp
<waynecolvin>
do CL floating point numbers need to be binary, rather than BCD or something else? what if a system doesn't have a FPU?
<beach>
You can still implement the operations in software, even if it is binary. I haven't thought much of your question. But it looks pretty tied to binary.
<eviltofu>
In CLOS, can we specify a slot and limit its type to a class? (defclass tag () (value :initarg :value)) I want value to be symbol only.
<eviltofu>
I just started Common Lisp last week.
<beach>
waynecolvin: Maybe not. I suggest you read the Common Lisp HyperSpec page for decode-float and see what you conclude.
<beach>
See (:TYPE TYPE-SPECIFIER) in the slot options.
<eviltofu>
Thanks
yeticry has quit [Ping timeout: 240 seconds]
<beach>
Anytime.
<eviltofu>
"The consequences of attempting to store in a slot a value that does not satisfy the type of the slot are undefined."
yeticry has joined #lisp
<eviltofu>
Ha ha
<beach>
Why is that funny?
OS-26949 has quit []
<eviltofu>
so how do I know if :type is violated?
<beach>
It is typical for a language definition to have unspecified behavior. You must either choose an implementation (and a DEBUG setting) that you know will verify it for you, or else, you check it yourself in a :BEFORE method on the setter.
<eviltofu>
ok I was hoping that I wouldn't have to do the :before method.
<beach>
eviltofu: If you are new to Common Lisp, you should know that it is much less common to use type declarations than it is in other languages.
<rme>
eviltofu: You're so new to CL that you probably shouldn't even worry about this.
<beach>
eviltofu: In fact, many people think that providing type information early on in a project is detrimental to productivity, because you are forced to specify too early what types you want.
<eviltofu>
Well, it's a bit much learning emacs, slime, paredit, etc
<beach>
Definitely.
<beach>
But you can trust us on this one. Forget about it until much later in your project.
makomo has joined #lisp
<eviltofu>
Besides :Prove is there another unit testing package?
JuanDaugherty has quit [Quit: Ex Chat]
raphaelss has joined #lisp
<beach>
Plenty.
fikka has joined #lisp
<beach>
I don't use any myself, because using ASSERT is enough, and the type of tests that the typical testing framework allows is often not what I want.
<beach>
Perhaps the proliferation of testing frameworks is an indication that it is hard to write one that satisfies the needs of all projects.
<eviltofu>
I'm testing the logic of my code so ... I don't know if assert is enough.
fikka has quit [Ping timeout: 240 seconds]
<beach>
I don't see why not.
<beach>
For example, when I implement a data structure, I often write a second, trivial and slow, implementation of it. Then I generate random operations on both of them and use ASSERT to check that they behave the same way.
mishoo_ has joined #lisp
<beach>
eviltofu: Do you care to share with us the type of application you are writing?
JJBby has quit [Ping timeout: 272 seconds]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<eviltofu>
Sorry, I misunderstood. I thought you meant assert alone in the code was enough. You are still writing tests but using assert instead of a test frame work.
<beach>
Correct.
<eviltofu>
I'm just putting around and exploring Common Lisp.
<beach>
I understand.
<shaftoe>
im writing some code, and there's a bunch of validations i want to perform before executing a function... but i don't want a whole bunch of nested if tests
<shaftoe>
atm im using a longer chain of tests in a (cond)
<shaftoe>
wondering if there's another approach worth considering
<beach>
You could put the tests in a separate function. Or you can use a :BEFORE method. But I can't see how you can avoid executing every validation.
FreeBirdLjj has quit [Ping timeout: 248 seconds]
FreeBird_ has joined #lisp
<shaftoe>
ok
<waynecolvin>
maybe use a short circuit (or ...)
aindilis has quit [Read error: Connection reset by peer]
<shaftoe>
if i do an or, it's harder to send the error back up the chain
<waynecolvin>
oh
<shaftoe>
i started with something like that
<shaftoe>
but it was unclear why a validation failed
<shaftoe>
because my tests are just boolean results atm
aindilis has joined #lisp
<beach>
eviltofu: So what is it that you are working on?
terpri has joined #lisp
eviltofu has quit [Ping timeout: 260 seconds]
t0adst00l has joined #lisp
<beach>
Oh well.
turkja has quit [Ping timeout: 240 seconds]
emacsoma` has quit [Ping timeout: 264 seconds]
zaquest has joined #lisp
fikka has joined #lisp
JonSmith has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
JonSmith has quit [Ping timeout: 240 seconds]
t0adst00l has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 248 seconds]
mishoo_ has quit [Ping timeout: 248 seconds]
safe has quit [Read error: Connection reset by peer]
Karl_Dscc has joined #lisp
gravicappa has joined #lisp
zaquest has quit [Remote host closed the connection]
<beach>
(RETURN ...) always expands to (RETURN-FROM NIL ...)
attila_lendvai has quit [Ping timeout: 272 seconds]
<beach>
flip214: I take it you are not satisfied with that answer.
fourier has joined #lisp
<flip214>
beach: yeah, well, no, that's good enough...
fourier has quit [Changing host]
fourier has joined #lisp
<flip214>
seems that RETURN simply isn't parsed (like COLLECT etc.) by ITERATE
<fourier>
what is the config file for ecl?
uuplusu has joined #lisp
<flip214>
and so of course the wrong block name is used.
<beach>
flip214: Correct, it's a normal macro.
<flip214>
so thanks once more!
BitPuffin|osx has joined #lisp
<beach>
Sure.
<pagnol>
beach, when I try to jump to my code from the backtrace I get an error 'unhandled DEBUG-CONDITION: #<SB-DI::COMPILED-DEBUG-FUN MINROOT> has no debug-block information.'
<beach>
pagnol: Did you compile your code with a high DEBUG setting?
varjag has joined #lisp
<beach>
pagnol: I have this in my .sbclrc: (declaim (optimize (speed 0) (debug 3) (safety 3)))
<beach>
pagnol: I regret to tell you that those are not the default values.
<pagnol>
previously I only had (sb-ext:restrict-compiler-policy 'debug 3)
<beach>
It could be something else. I am just guessing.
Karl_Dscc has quit [Remote host closed the connection]
uuplusu has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
<phoe>
pagnol: this sounds very implementation-specific, I advise you ask on #sbcl.
uuplusu has joined #lisp
<phoe>
Unrelated: my life became so much nicer when I realized that I can (funcall (fdefinition (list 'setf FOO)) ...) where FOO is a symbol of my choosing.
<beach>
Or just '(setf foo).
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe>
beach: yes yes, except FOO is variable in there.
<beach>
`(setf ,foo) then
<phoe>
Correct. It's a bit shorter than (list 'setf foo).
attila_lendvai has joined #lisp
<Shinmera>
It's a bit weird actually that function designators do not contain '(setf foo) despite '(setf foo) being a valid function name.
<beach>
Indeed. Sounds like an omission.
uuplusu has quit [Ping timeout: 252 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
raynold has quit [Quit: Connection closed for inactivity]
attila_lendvai has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
ykoda_ has joined #lisp
eviltofu has quit [Ping timeout: 260 seconds]
gravicappa has quit [Ping timeout: 256 seconds]
<phoe>
yep
Arcaelyx has joined #lisp
LocaMocha has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
uuplusu has joined #lisp
<phoe>
CLOS question - when I have class FOO, class BAR subclassing FOO, class BAZ subclassing BAR, and all three classes have INITIALIZE-INSTANCE :AFTER methods - when I make an instance of BAR, do all three methods get called by default?
<beach>
phoe: Speaking of which, KZiemian asked for input to CLUS, and I gave some, but then KZiemian has not been seen. This function designator could also deserve a not in there.
openthesky has quit [Quit: peace out]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<beach>
phoe: No, the :AFTER method on BAZ is not applicable then.
<phoe>
So INITIALIZE-INSTANCE uses a method combination to take other constructors into account? Like, in case of BAZ, constructors for classes BAR and FOO.
<phoe>
Or does INITIALIZE-INSTANCE call CALL-NEXT-METHOD directly?
uuplusu has joined #lisp
<beach>
It has nothing to do with constructors. ALLOCATE-INSTANCE is first called, then INITIALIZE-INSTANCE is called with the allocated instance.
<beach>
When the effective method is computed, all applicable methods are first determined...
<phoe>
Oh wait.
<phoe>
"All the after methods are called in most-specific-last order."
<phoe>
This answers my question.
<beach>
OK.
<phoe>
CLOS really is amazing.
<beach>
I agree.
<Shinmera>
You could always do the same thing done in other OOP styles by defining a primary method and calling CALL-NEXT-METHOD.
<Shinmera>
But :after is more convenient.
<beach>
Shinmera: The point is that doing so after the fact might change the protocol, so that client software needs to be rewritten. I asked that question in a course I held in New Zealand once. And they suggested exactly that. When I explained the maintenance problem, they immediately got it.
<fourier>
at some point Stroustrup wanted to add :before and :after into C++, and even had a prototype but then the community has decided it makes it too complex though
uuplusu has quit [Ping timeout: 265 seconds]
<beach>
Heh, that's a good one.
<beach>
As if it isn't already too complex.
<fourier>
there was quite an opposition from compiler vendors
<Shinmera>
Woulda preferred he had added a specified ABI instead
orivej has joined #lisp
damke_ has joined #lisp
<fourier>
it was not really an option, for performance reasons iirc
<jmercouris>
fourier: Is he the only one who decides the evolution of the language? is there not some sort of community?
iskander has joined #lisp
<fourier>
no it was a commitee gathering like once a year. mainly lead devs, compiler devs and vendors
damke has quit [Ping timeout: 264 seconds]
<jmercouris>
So he's just a member of that community then
<jmercouris>
I see
<fourier>
but until like 85-88 he had some freedom. then the language started to started to spread and he got bounded by "customers" and developers, hence all the stuff which is hard to remove/change
loli has joined #lisp
<jmercouris>
I wonder what it is like to work on one language your whole life
<fourier>
he has a huge influence on the language though, like he solely practically force commetee to accept STL - the part with iterators/containers/algorithms into the standard practically last moments after 2 days of discussions with Alex Stepanov who has implemented STL, then Stroustrup got the concept of it.
<fourier>
heh at least it evolves and into the good direction. it is so much easier to write code in c++ now after c++11/14. feels almost like a new language.
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<Shinmera>
Can't wait for C++ to grow a GC :^)
<fourier>
it was available like from day 1
red-dot has joined #lisp
<fourier>
the language itself designed so you can use external gc, nothing to prevent it. the problem is no one needs it - people do manual memory management for reason.
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
That too.
<Shinmera>
And make-array, since vectors are sequences too
<fourier>
op make-list is nice, always forget about it :)
<fourier>
thanks for suggestions!
Tobbi has joined #lisp
uuplusu has quit [Ping timeout: 260 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
attila_lendvai has joined #lisp
Ven`` has joined #lisp
BitPuffin|osx has quit [Ping timeout: 264 seconds]
alexmlw has quit [Read error: Connection reset by peer]
dieggsy has joined #lisp
alexmlw1 has joined #lisp
White__Flame is now known as White_Flame
Jesin has joined #lisp
alexmlw1 is now known as alexmlw
Olgierd has joined #lisp
uuplusu has joined #lisp
test1600 has quit [Ping timeout: 268 seconds]
JonSmith has quit [Remote host closed the connection]
fourier has quit [Ping timeout: 256 seconds]
uuplusu has quit [Ping timeout: 240 seconds]
ryanbw has quit [Ping timeout: 240 seconds]
omilu has quit [Ping timeout: 252 seconds]
ykoda has quit [Quit: WeeChat 2.0.1]
ykoda_ has quit [Quit: WeeChat 2.0.1]
ykoda has joined #lisp
smurfrobot has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 272 seconds]
uuplusu has joined #lisp
smurfrobot has joined #lisp
milanj has joined #lisp
eazar001 has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
uuplusu has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
test1600 has joined #lisp
uuplusu has joined #lisp
vap1 has quit [Ping timeout: 240 seconds]
vaporatorius__ has joined #lisp
python476 has quit [Remote host closed the connection]
uuplusu has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 256 seconds]
asarch has joined #lisp
smurfrobot has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 2.0.1]
uuplusu has joined #lisp
manualcrank has joined #lisp
manualcrank has quit [Client Quit]
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
randomstrangerb has quit [Ping timeout: 256 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
randomstrangerb has joined #lisp
red-dot has joined #lisp
JonSmith has joined #lisp
manualcrank has joined #lisp
uuplusu has quit [Ping timeout: 265 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe>
What is a proper way to curry/rcurry something like (lambda (x y) (make-instance x :name y)) ?
Tobbi has joined #lisp
attila_lendvai has joined #lisp
EvW has joined #lisp
ykoda has quit [Quit: WeeChat 2.0.1]
uuplusu has joined #lisp
smurfrobot has joined #lisp
JonSmith has quit [Remote host closed the connection]
ykoda has joined #lisp
uuplusu has quit [Ping timeout: 265 seconds]
smurfrobot has quit [Ping timeout: 265 seconds]
uuplusu has joined #lisp
<shka>
phoe: no clever way to do it in alexandria, i suggest to define constructor!
<shka>
i have a macro for that, though
manualcrank has quit [Quit: WeeChat 2.0.1]
smurfrobot has joined #lisp
manualcrank has joined #lisp
manualcrank has quit [Client Quit]
uuplusu has quit [Ping timeout: 256 seconds]
<Shinmera>
(defmacro define-constructor (class lambda-list) `(defun ,(intern (format NIL "~a-~a" 'make class)) ,lambda-list (make-instance ',class ,@(loop for v in (lambda-fiddle:extract-lambda-vars lambda-list) collect (intern (string v) :keyword) collect v))))
manualcrank has joined #lisp
<shka>
something like that
<shka>
not worth it in general :-)
whyNOP has quit [Quit: reboot]
JonSmith has joined #lisp
uuplusu has joined #lisp
JonSmith has quit [Ping timeout: 248 seconds]
makomo_ is now known as makomo
uuplusu has quit [Ping timeout: 252 seconds]
JonSmith has joined #lisp
notzmv has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<makomo>
does anyone have any recommendations where to look for good implementations of combinatorial algorithms?
<makomo>
bonus points if the implementation language is CL :D
<makomo>
algorithms such as generating all of the permutations, n-tuples, combinations (all w/ or w/o repetition), etc.
notzmv has quit [Ping timeout: 248 seconds]
zmv has joined #lisp
randomstrangerb has quit [Ping timeout: 268 seconds]
damke has joined #lisp
randomstrangerb has joined #lisp
smurfrobot has joined #lisp
* JuanDaugherty
would have made one but for the bonus
<Shinmera>
If I remember correctly Rosetta Code has some stuff, but I'm not sure if it's been translated to CL yet
<phoe>
^
smurfrob_ has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
Andrew_ has joined #lisp
Andrew_ is now known as OS-26949
<_death>
alexandria also has a few
mson has joined #lisp
smurfrob_ has quit [Ping timeout: 256 seconds]
SqREL has joined #lisp
uuplusu has joined #lisp
test1600 has quit [Quit: Leaving]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
uuplusu has quit [Ping timeout: 260 seconds]
red-dot has joined #lisp
uuplusu has joined #lisp
<makomo>
if i have nested LOOPs, what's the best way to just forward the result of one of the the inner LOOPs
<makomo>
i.e. i have (LOOP ... :do (LOOP ... :collect ...))
<makomo>
the inner LOOP returns the collected items. how do i just forward those out from the outer LOOP?
JonSmith has quit [Remote host closed the connection]
<makomo>
or do i have to do something like (LOOP ... :for res = (LOOP ... :collect ...) :finally (return res))
JonSmith has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
<_death>
you can use an nconc clause.. or just use push/nreverse
<_death>
or collect and flatten..
<_death>
or do you mean that you want to return early?
uuplusu has quit [Ping timeout: 268 seconds]
JonSmith has quit [Ping timeout: 240 seconds]
<makomo>
erm, nvm, i mixed something up, sorry. however, is there a way for LOOP to return the result of the last executed form in its DO block?
<makomo>
assuming all the LOOP has is an arithmetic FOR clause, and a DO clause
lagagain has quit [Quit: Connection closed for inactivity]
uuplusu has joined #lisp
<makomo>
e.g. i would like for (LOOP :for i :from 1 :to 10 :do (list i)) to return (10), instead of the usual NIL
<_death>
if you use DO, then the you're signaling that the form's result is irrelevant
manualcrank has quit [Quit: WeeChat 2.0.1]
manualcrank has joined #lisp
<_death>
a less silly example would make what you're actually trying to do clearer
<makomo>
i see, so that's just how DO is supposed to be used. what would be the best solution then? maybe a :with, a setf, and then a :finally (return)?
<makomo>
yeah i don't really have a non-silly example. i'm just wondering what's the most elegant way to do something like that
<makomo>
i thought i had a non-silly one a few moments ago but i was wrong
uuplusu has quit [Ping timeout: 264 seconds]
manualcrank has quit [Client Quit]
<_death>
the thing is, GIGO also applies to such considerations..
manualcrank has joined #lisp
<makomo>
hm, fair point
<_death>
sometimes it's better to try doing what you want without the long form of LOOP
<_death>
this can expose underlying control structure that's easier to abstract
Murii has joined #lisp
manualcrank has quit [Client Quit]
uuplusu has joined #lisp
smurfrobot has joined #lisp
uuplusu has quit [Ping timeout: 264 seconds]
<_death>
makomo: but you can do better than with/setf even here.. (loop for i from 1 to 10 for thing = (list i) finally (return thing))
smurfrobot has quit [Ping timeout: 260 seconds]
manualcrank has joined #lisp
manualcrank has quit [Client Quit]
uuplusu has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has joined #lisp
manualcrank has joined #lisp
uuplusu has quit [Ping timeout: 265 seconds]
manualcrank has quit [Client Quit]
kajo has joined #lisp
EvW1 has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Ven`` has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
manualcrank has joined #lisp
uuplusu has joined #lisp
OS-26949 has quit [Ping timeout: 260 seconds]
<makomo>
_death: yup, true, recalled that a few moments later
SqREL has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
attila_lendvai has quit [Read error: Connection reset by peer]
uuplusu has joined #lisp
attila_lendvai has joined #lisp
josemanuel has quit [Quit: leaving]
JonSmith has joined #lisp
random-nick has quit [Quit: quit]
random-nick has joined #lisp
raynold has joined #lisp
JonSmith has quit [Ping timeout: 248 seconds]
uuplusu has quit [Ping timeout: 260 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
uuplusu has joined #lisp
shka has quit [Ping timeout: 240 seconds]
uuplusu has quit [Ping timeout: 240 seconds]
<pagnol>
is there something like the `test` macro that lets me supply an equality predicate?
<pagnol>
err I mean `case` macro
pierpa has joined #lisp
smurfrobot has joined #lisp
<Shinmera>
No, but you can make your own with COND easy.
<pagnol>
good idea, I'll give that a try
cromachina has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
cromachina_ has quit [Ping timeout: 264 seconds]
kajo has quit [Ping timeout: 252 seconds]
papachan has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
<White_Flame>
LET + COND is basically CASE with full test evaluation
<White_Flame>
with the LET ensuring the value to be tested is only evaluated once at the top
makomo has quit [Ping timeout: 240 seconds]
LexLeoGryfon has joined #lisp
<LexLeoGryfon>
heyy
<LexLeoGryfon>
whats up?
<LexLeoGryfon>
any python devs here?
<Shinmera>
This is not #python
<LexLeoGryfon>
just want to chat with python dev about lisp
<LexLeoGryfon>
the lisp vs python actually
<LexLeoGryfon>
Shinmera: oh i know u !
<Shinmera>
Do you now
<LexLeoGryfon>
u are the swiss guy who gave talk and have few post in lisp magazine or smthn, and have really beautiful homepage with arts n stuff
<pierpa>
Lisp magazines?
<Shinmera>
I don't know about a lisp magazine
<Shinmera>
But thanks for the compliment on the homepage, I suppose.
<Shinmera>
Anyway, what in specific were you looking for comparing python and lisp?
<LexLeoGryfon>
u are a cool dude :) but I have personal ( i think) problem with lisp, so I came here to discuss it shortly and confront interests n ideas of this channel...
<phoe>
ask your question then
<mfiano>
Which Lisp?
<LexLeoGryfon>
let me try to describe it briefly...
<mfiano>
This channel is for that of the Common Lisp variety
<phoe>
oh right, mfiano is right
manualcrank has quit [Quit: WeeChat 2.0.1]
JonSmith has joined #lisp
<papachan>
LexLeoGryfon just curious what is your question?
mariari has joined #lisp
fikka has joined #lisp
<LexLeoGryfon>
i'm mainly a python dev. And I like python very much because of following things: readability, simplicity, dynamism, metaprogramming, ability to write kinda functional style, etc. My problem with lisp is that I made somewhat huge research(in my sense) about it, even tried to code in it (hylang), and for me all this hype around lisp makes no sense, and I find it bullshit.
<LexLeoGryfon>
I tried to discover advantages of lisps over ruby\python, and found none , practical n useful.
<mfiano>
I came from Python a decade or so ago, and I can say that all of those are better with Lisp, with the addition of the surprising rapid prototyping aspect.
<LexLeoGryfon>
there are advantages over languages like C\Java, maybe for their devs LISPS could be mind blowing. but not for python\ruby devs
<random-nick>
python's meta-programming is a joke compared to most lisps, including common lisp
<pierpa>
what code speed, once written?
<pierpa>
*what about
<loli>
Python is rather annoying to write in the functional style, where as CL is rather agnostic when it comes to the functional style
manualcrank has joined #lisp
<White_Flame>
and of course, languages like Python and Ruby are their own spin on Lisp-isms, so looking at Lisp will seem kind of old hat, but you won't realize the depth vs shallowness of those featues between languages yet
<White_Flame>
I'm curious to see an example of Python metaprogramming, if the word even means the same thing
<mfiano>
I think that means that to do anything fast in Python involves writing ffi
<random-nick>
I think the most important meta-programming feature in python is decorators
manualcrank has quit [Client Quit]
<LexLeoGryfon>
pierpa: I don't have issues with perfomance in python world with pypy+cython for cpu-bound, and asyncio+uvloop for io-bound tasks
mson has quit [Quit: Connection closed for inactivity]
manualcrank has joined #lisp
<White_Flame>
LexLeoGryfon: lisp is a very, very syntactically regular language. That makes complex code much easier to read than the traditional infix/postfix/prefix mix of other languages
<White_Flame>
of course, the hylang example doesn't seem to follow quite the same level of regularity, combining both [] and ()
* phoe
gently, geeeently nudges the discussion towards #lispcafe
<White_Flame>
and in metaprogramming and many other features, the benefits of the design decisions behind Lisp emerge when you start writing complex stuff
<mfiano>
Just read the Hylang README. "It's [Python] really awesome. Oh, and lisps are neat.". Heh
manualcrank has quit [Client Quit]
<mfiano>
That says a lot.
<White_Flame>
many modern languages optimize for succinct code golfing
<pjb>
We don't eat of that bread here.
<pierpa>
OTOH if you are happy with python, don't see any benefit in Lisp, then it's not mandatory to like Lisp. Use Python and be happy.
<random-nick>
LexLeoGryfon: you should probably try using Common Lisp instead of hylang
<random-nick>
hylang is not very representative of the lisp family
<LexLeoGryfon>
can anyone propose me in real world practical daily example of the thing that syntactically looks better in lisp rather than in python? not some rare-meta-bs case that occurs in 1 of 100 days, but something that could occur daily in life of web\script\dev lets say?
<loli>
pattern matching
<White_Flame>
and the "Common" part of Common Lisp was a reuniting of an entire family of commercially used, mature Lisps
<White_Flame>
"looks" is 100% subjective
<White_Flame>
but any time you create a project-specific macro, your use of it will look better than a macro-less language calling functions & object interfaces to do the boilerplate manually
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<LexLeoGryfon>
loli: show me the code
<loli>
here is an example of pattern matching for a functional insertion sort
<LexLeoGryfon>
White_Flame: there are macroses in python . however why not to be happy to insert boilerplate in to functions?
<loli>
Also most things written in the functional style aren't too well supported in Python due to the lack of a proper list
<random-nick>
there's also the binary file parsing example
<White_Flame>
LexLeoGryfon: because your boilerplate might change, you might typo/forget it, and it creates more inertia to get over to put a new thing into your code
<White_Flame>
also with pattern matching, lisp macros can reach into your code and extract instances of variables to use for pattern matching directly, reducing the amount of configuration you need to set up to use it
<aeth>
LexLeoGryfon: The practical use for Lisp over something like Python is controlling when something is evaluated.
AndChat-153225 has joined #lisp
papachan has quit [Ping timeout: 263 seconds]
<White_Flame>
a practical use for Lisp over anything is super-easy internal code generation
<aeth>
There are lots of ways to control when something is evaluated in Common Lisp. read-eval, reader macros, defmacro macros, modify-macros, symbol macros, inline functions, etc.
manualcrank has joined #lisp
kajo has joined #lisp
<White_Flame>
as I've said elsewhere, you tend not to even think of those sorts of solutions in other languages, because the tools & work to get there are too complex. But when code generation & transformation is so easy, you're way more empowered even though it's technically feasible elsewhere
<Baggers>
Xach: ugh I hadnt pushed the release branch. I'll check the others to see if I have slipped up elsewhere. Is it possible to subscribe to these test results so I see the failures (and hopefully fix them) without bothering you?
jack_rabbit has joined #lisp
<aeth>
s/when something/when and how something/
<White_Flame>
LexLeoGryfon: I suggest, if you really want to know the differences, to go through actual Lisp learning/tutorial material to evaluate the differences between the macro systems
<random-nick>
LexLeoGryfon: but can you easily create a new statement which is just like if but binds the test to a variable?
<White_Flame>
because no, that's not metaprogramming; that's simply having slots to place function objects
uuplusu has joined #lisp
<random-nick>
s/test/test result/
mariari has quit [Ping timeout: 276 seconds]
<aeth>
LexLeoGryfon: You can do most of the things that Common Lisp can do in other languages, but (1) usually it's much harder and (2) you will need to use several very different languages to exactly match the feature set of CL because it's ridiculously multiparadigm
manualcrank has quit [Client Quit]
<aeth>
s/most of the things/all of the things/
<random-nick>
yes, since most programming languages are turing-complete
manualcrank has joined #lisp
<aeth>
random-nick: But not every paradigm is efficient in every language.
JonSmith has quit [Remote host closed the connection]
<White_Flame>
"efficient" in the amount of programmer work, especially
z3t0 has joined #lisp
JonSmith has joined #lisp
<White_Flame>
I tend to point to PCRE
<White_Flame>
in C, you either need to interpret runtime data (massive slowdown in CLIPS expressions), or do all sorts of massive architecture to get JIT code generation (PCRE)
<White_Flame>
in Lisp, you can simply generate new code in basically AST form, using literal templates and such right in-language, and have it be machine-code compiled transparently
<White_Flame>
those sorts of leaps are all over the place in Lisp usage
uuplusu has quit [Ping timeout: 248 seconds]
<LexLeoGryfon>
random-nick: thats FUN point regarding creation of new syntax\statements , yes we can create macro in python with that https://github.com/lihaoyi/macropy and similiar libs. But for which task do we really need to create DSL? I beleive we could get away with simple functions\classes. even this https://amoffat.github.io/sh/ looks OK fine for me, even without new DSL.
<White_Flame>
and anybody who's ever built up code in eval(string) oriented languages knows the pain of not having a proper AST form of code available
<White_Flame>
LexLeoGryfon: again, regular functions/classes are fine for basic code
<aeth>
LexLeoGryfon: A macro is the last level of abstraction, above functions and objects.
<White_Flame>
once you increase the level of complexity, modification becomes difficult without things like DSLs
<aeth>
LexLeoGryfon: You need full syntactic control to get declarative end results.
JonSmith has quit [Ping timeout: 248 seconds]
<aeth>
Macros have an advantage over functions because you can control exactly when and how they evaluate things, so you can produce better high level abstractions.
<White_Flame>
if you haven't said to yourself "Ugh, I wish Python would do X for me, it would make things so much easier", then you're just either not aware of the slow rate of development you're enduring, or your projects are simple enough not to hit the boundaries of your environment
<aeth>
Common Lisp is a language for writing inline declarative languages that look like they were part of the main language the whole time.
<aeth>
Some things simply cannot be abstracted with functions, but they can almost always be abstracted with macros. Macros are for when functions fail.
<random-nick>
even if you ignore the whole macro machinery, common lisp is a pretty good language
<random-nick>
especially CLOS
<Shinmera>
I really hate the "DSL" description in relation to Lisp since usually people think of DSLs as entirely separate things like ini files or whatever that share close to nothing with the "host" language.
<White_Flame>
good point
<Shinmera>
And if you think about macros creating DSLs that are very constrained in what they can do, it's easy to think there isn't much use for them.
<Shinmera>
The whole point of macros is that they extend the language, not create "sub-languages"
<aeth>
You have full control in CL how to embed the language. A string? format does this. cl-ppcre does this. A fancy macro? loop does this. A syntactically regular macro? do does this. A reader macro? I'm sure that's used somewhere. A separate file? Probably been done. And *separate* from this, you have control over when and how it's evaluated. Some of them can be fully compile time.
<aeth>
e.g. I generate GLSL shader strings at compile time, and SBCL produces the output as constant strings in the FASL file when I compile them. And it's not any harder than doing it with functions.
<aeth>
A language as a string, reader macro, or separate files can all be implemented the exact same way, with a stream.
vibs29 has quit [Ping timeout: 268 seconds]
<Shinmera>
aeth: Embedding a language isn't very interesting. People can do that elsewhere with strings and extra files too. The interesting use is things that extend and integrate seamlessly like ITERATE, CLOS, etc.
manualcrank has quit [Quit: WeeChat 2.0.1]
AndChat-153225 has left #lisp [#lisp]
<aeth>
Shinmera: People do that elsewhere with other people's libraries because it's a hard problem in most other languages.
<aeth>
Working with mini-languages in CL is trivial, especially if you keep them as s-expressions.
vibs29 has joined #lisp
<White_Flame>
pagnol: I started on one, but went on to other things. I got it to the point where it could parse java .class files including disassembling the byte codes & deferring through the constant tables
<Shinmera>
pagnol: Have a look at binary-types
<random-nick>
also, looks like that macropy doesn't really let you create macros that really fit into the language
<random-nick>
there doesn't seem to be a way to create new statements
<pagnol>
White_Flame, I'm not familiar with the format used by class files but sounds like you got rather far?
smurfrobot has joined #lisp
<Baggers>
LexLeoGryfon: I'll just nip into this discussion to say that I feel this stuff is part of the spectrum of dynamic & static code. Why emulate/interpret/jit something when you dont need to? macros can be about more than just syntax (although they get used for this too). Why dynamically dispatch when the function to call is absolutely known at compile time? Macros can let you provide insights to compilation that would
<Baggers>
be too hard or too expensive for the compiler to reason about itself. I love python myself, but IIRC transforming the ast at compile time stuff isnt integrated into the standard build flow. There is, I agree, a good deal of BS around lisps (no syntax and that nonsense) and thats a shame as some damn enjoyable aspects in these languages
<White_Flame>
pagnol: yeah, but many of its features were implemented a little too specific for their particular use case in that instance, so it's not generalized enough to be a general tool
<pagnol>
White_Flame, if it's on github, mind if I take a look nevertheless?
<White_Flame>
not on github unfortunately
<Xach>
Baggers: did you see my link from earlier?
<random-nick>
LexLeoGryfon: that's not what the Common Lisp community thinks when they say "DSL"
manualcrank has joined #lisp
<Baggers>
Xach: yes thankyou. I replied a little way up too. I had forgotten to push the latest from that repo
jack_rabbit has quit [Ping timeout: 248 seconds]
manualcrank has quit [Client Quit]
<Shinmera>
My new year's wish is for people to stop using "DSL" to try to describe macros
<Baggers>
Xach: just checking the others now. Is it possible to subscribe to these test results so I see the failures (and hopefully fix them) without bothering you?
<random-nick>
iirc the clojure community uses the abbrevation "eDSL" for "embedded Domain Specific Language"
<random-nick>
which is a lot more clear
<Shinmera>
Not really
<aeth>
LexLeoGryfon: In Common Lisp, you can use reader macros to embed a syntactically different DSL directly into the source code of the .lisp file, no separate file necessary. And it will be compiled ahead of time with the .lisp file. No interpreter necessary.
<aeth>
if you don't want to follow the link, it's just #4f(+++++++++[>++++++++<-]>.<+++[>++++++++<-]>+++++.+++++++..+++.>++++[>++++++++<-]>.<<<+++[>--------<-]>.<+++[>++++++++<-]>.+++.------.--------.>>+.<++++++++++.)
<aeth>
No separate file. No string. It looks like it's part of the language, sort of.
manualcrank has joined #lisp
<Shinmera>
Again that's not really interesting because what's the point of doing that when a string works just as well
<pagnol>
White_Flame, out of curiosity: what were you going to do with the class files?
<White_Flame>
I think the best simple example of reader macros is adding full datetime "primitives" to the language
<White_Flame>
pagnol: java-in-lisp stuff
<aeth>
Shinmera: Inline Scheme would be a better example. A language that uses s-expressions but has subtle differences in syntax that would necessitate a reader macro to properly do the inline Scheme.
<aeth>
CL is perfectly capable of doing that.
<aeth>
Shinmera: Also, most languages would probably interpret the string, this is compiled as CL.
<Shinmera>
Much simpler example: Allowing the use of {}[] as regular parens
z3t0 has quit [Remote host closed the connection]
<Shinmera>
You can do that with four lines of code
JonSmith has quit [Remote host closed the connection]
z3t0 has joined #lisp
<LexLeoGryfon>
k, maybe you have some points :) i'm sleepy, going to bed (EU time), have a good night, thank you for your time
<Baggers>
sleep well
<aeth>
Although, really, the #1 reason is that the SBCL compiler is about 10x faster than the Python interpreter.
damke_ has joined #lisp
<aeth>
10x speedup is enough to be noticable, even without any feature benefits.
<LexLeoGryfon>
aeth: dude I have C like perfomance of my code with cython+pypy ;)
<aeth>
What that means is that it takes a lot more performance requirements before we have to resort to C or C++ or Fortran libraries.
<aeth>
So we can keep everything in one language for longer.
<aeth>
Obviously if you're going to be calling into the same C libraries, there's not as big of a difference.
damke has quit [Ping timeout: 264 seconds]
manualcrank has quit [Quit: WeeChat 2.0.1]
<aeth>
LexLeoGryfon: The problem is that most of the Python ecosystem is mostly around the slowest popular programming language implementation in existence.
<aeth>
Most of the CL ecosystem is (mostly) portable, so we can choose the fast implementation with essentially no ecosystem penalties.
<Baggers>
LexLeoGryfon: ignore aeth, hes talking shit again
<White_Flame>
and heck, LexLeoGryfon should look at that as an example of DSL'ing right in the language
smurfrobot has joined #lisp
* LexLeoGryfon
looking
<aeth>
Okay, it looks like Pypy isn't as far behind the main implementation as it used to be.
<White_Flame>
even the "def" itself is custom code, and the entire system to consume that spec and give a fully broken down AST of a java .class file is only 415 lines of code
randomstrangerb has quit [Ping timeout: 268 seconds]
<aeth>
For a very long time, PyPy was this cool, fast thing that you could basically not use for most Python projects.
jack_rabbit has joined #lisp
<LexLeoGryfon>
White_Flame: crazy neat
<White_Flame>
(:find <table> <index> <value>) can even dereference pointers/indexes/offsets between items in the file
<White_Flame>
again, 415 lines to implement all that
randomstrangerb has joined #lisp
<White_Flame>
I'm technically a big fan of data-driven programming, which I guess might be a subset of DSLs in general
JonSmith has joined #lisp
<LexLeoGryfon>
aeth: 3.5 latest supported version. cpython stable currently at 3.6 . pypy now have better support of c-extension, numpy, etc, and lotsa major projects.
JonSmith has quit [Remote host closed the connection]
JonSmith has joined #lisp
Atomic2 has joined #lisp
manualcrank has quit [Quit: WeeChat 2.0.1]
makomo has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
Murii has quit [Quit: WeeChat 1.4]
<_death>
this isn't a channel for discussing python
<_death>
unless it's the python compiler
manualcrank has joined #lisp
<White_Flame>
(spoiler: the compiler tech inside SBCL & CMUCL is called "Python", and existed long before python the language)
random-nick has quit [Remote host closed the connection]
<Baggers>
White_Flame: was it using the name python during the Spice project?
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
<Xach>
Baggers: I'd like to make something like that (subscribe to bug reports)
<Xach>
Build failures
<Xach>
You can visit http://report.quicklisp.org/ but that shows everything, would be nice to have individual feeds for individual projects
* Xach
will think about publishing rss for each alongside
<Xach>
Baggers: is that what you meant by feed?
<Baggers>
Xach: absolutely, rss sounds like it would do perfectly
Riviera- has joined #lisp
<mfiano>
Xach: That would be a killer feature to subscriber to individual projects so you can get next day fixes ready without tracking us down
<mfiano>
subscribe*
* Shinmera
gets ready to subscribe to ~70 feeds
<Xach>
ok, i will whip something up
<_death>
can have a bot that creates issues for failing projects
<Baggers>
Shinmera: serves you right for making useful stuff :)
<Xach>
_death: I hesitate to go that far
<Shinmera>
_death: Spamming issues for projects that are temporarily in flux doesn't sound great
<Xach>
That's partly my worry
<_death>
Shinmera: it be smarter than a dumb failure->action
<_death>
ah, my broken english suggests that it may be time to sleep ;)
JonSmith has quit [Remote host closed the connection]
EvW1 has quit [Remote host closed the connection]
EvW has joined #lisp
Bike has joined #lisp
brendyn has joined #lisp
<Shinmera>
_death: How would it be able to discern whether a failure is just temporary or unintended?
waynecolvin has quit [Ping timeout: 246 seconds]
zooey has quit [Ping timeout: 272 seconds]
<_death>
Shinmera: it could for example delay its response.. maybe also take into account the time of a new quicklisp dist upgrade.. and there could also be an interface for project authors where they could tweak things, perhaps disabling it entirely..
<Shinmera>
Well now we're getting into the territory of "a lot of effort"
JonSmith has joined #lisp
fikka has joined #lisp
zooey has joined #lisp
smurfrobot has joined #lisp
JonSmith has quit [Remote host closed the connection]