<p_l>
no-defun-allowed: there used to be some heavy duty hacking toolkit using lisp
<vms14>
"Thanks to LISP, I was able to write a large, complex application which might ordinarily require a whole team of programmers to complete. Also, LISP is very easy to customize so that as users become more sophisticated, applications written in LISP can grow along with those users."
igemnace has quit [Quit: WeeChat 2.4]
<fiddlerwoaroof>
What automatic system documentation do people use? I've tried declt recently
<fiddlerwoaroof>
But I'm not entirely satisfied with it
<splittist>
I haven't used it, but Shinmera has staple.
<vms14>
was clisp in the past the most used implementation?
<Xach>
vms14 no
<vms14>
Xach: which one?
<Xach>
not clisp
<vms14>
xD
<no-defun-allowed>
could have been CMUCL or Clozure CL
<aeth>
vms14: CLISP used to be very popular. That stopped about 10 years ago, when it stopped getting stable updates.
<vms14>
aeth: you mean clisp still being unstable today?
<aeth>
vms14: I mean there hasn't been a "stable version" since 2010-07-07, not that the implementation is "unstable".
<no-defun-allowed>
it's stable, but not updated
<aeth>
vms14: Although, yes, technically any more recent version of CLISP is "unstable"
anewuser has joined #lisp
<vms14>
and do you use other free implementation than sbcl for production code?
<aeth>
I use SBCL
<no-defun-allowed>
well Clozure CL is good if you're running on a Raspberry Pi (read: potato) cause it's got a faster (compile-time) compiler and want threads too
<vms14>
no-defun-allowed: would be a bad choice sbcl for a rpi?
<no-defun-allowed>
i would say so if you want multithreading out of the box
<vms14>
usually a rpi will be a server
<aeth>
no-defun-allowed: Also, SBCL afaik has the highest RAM usage
<aeth>
That's another important factor on a limited platform
<no-defun-allowed>
even better for CCL, you only get 1GiB of that on a Pi
<vms14>
aeth: but it's worth that RAM waste?
<vms14>
I mean it's what makes sbcl be faster than most of implementations?
<vms14>
a rpi3 should have enough RAM for a server in sbcl
<no-defun-allowed>
SBCL (probably, not familiar with either compiler) knows more optimisation tricks, which makes the compiler slower but code faster
<vms14>
would you choose another implementation?
<no-defun-allowed>
sure, hunchentoot usually only consumes 100MiB but the pi3 also only has 1GiB of memory
<no-defun-allowed>
and that's only hunchentoot, you have a program, some libraries, SQL server, probably would be under 500MiB though
<vms14>
well I don't care in compiling time
khisanth_ has quit [Ping timeout: 250 seconds]
<vms14>
yeah and sql should be in memory, sd is ultra slow
<vms14>
so no lisp for a rpi server?
* vms14
cries
<no-defun-allowed>
vms14: just use CCL on the pi
<vms14>
well a raspberry pi is not meant to be a huge server, so I guess it could do something with little websites
* no-defun-allowed
passes vms14 a tissue
<vms14>
tnx
<no-defun-allowed>
i tested my parallel chess program on a Pi since everything's slow and you can use htop to watch utilisation at that speed
<vms14>
oh a chess program
<no-defun-allowed>
turns out it didn't make enough "work" pieces so cores would run out of work early
<vms14>
how it was to write a chess program?
<vms14>
was harder than you thought?
<vms14>
or easier?
<no-defun-allowed>
it wasn't that hard, but i have to redo it since i didn't implement quite a bit of chess and is messy as hell
<vms14>
seems to be a challenge
<vms14>
a nice one
<no-defun-allowed>
(i got a 3x speedup from using Zobrist hashing for computing moves btw)
dddddd has quit [Remote host closed the connection]
khisanth_ has joined #lisp
zotan has quit [Ping timeout: 250 seconds]
zotan has joined #lisp
Achylles has quit [Ping timeout: 259 seconds]
<Arcaelyx>
Anyone ever make a lisp docker container?
orivej has joined #lisp
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
mgsk has quit [Ping timeout: 240 seconds]
Duns_Scrotus has quit [Ping timeout: 240 seconds]
<vms14>
Arcaelyx: nope, but sbcl can create a lisp image
<Arcaelyx>
vms14: Lisp image?
<vms14>
executable
<Arcaelyx>
Ah.
l1x has quit [Ping timeout: 276 seconds]
<Arcaelyx>
It can run independently of Lisp right?
<Arcaelyx>
I would be putting the lisp image inside of a container for execution.
<aeth>
clothespin: If you're using reddit, I would use /r/lisp instead of /r/common_lisp because while /r/lisp is "Lisp family" like ##lisp (and not like #lisp) it is probably 90% CL and is more active than /r/common_lisp.
<clothespin>
ok, thanks
karlosz has quit [Quit: karlosz]
<aeth>
clothespin: Depending on the project, you may also want to announce on Hacker News. A lot of Lisp stuff winds up on there even though in general it's more like /r/programming. https://news.ycombinator.com/news
<loke`>
It's a bit more than that, but I guess that works as a first-order approximation
<loke`>
It's the only “social” media I use.
<aeth>
Personally, I very rarely post on reddit, but other than that I have wound down most of my social media usage. I lurk on reddit and on HN, at least for now. Both seem increasingly like a waste of time, though.
<loke`>
aeth: All social media is a waste of time. However, Masotodon tends to not try to make it seem as though you're doing anything important.
<clothespin>
i don't like social media either for a lot of reasons
<loke`>
It's more honest that way :-)
<aeth>
loke`: The quality of everything goes down considerably over time. I probably missed the good old days of Mastodon already.
<PuercoPop>
Isn't IRC social media as well?
<aeth>
PuercoPop: More like antisocial media
<loke`>
aeth: Haha. You're right :-)
<loke`>
Everything always gets worse.
<loke`>
You know, there was a time (about 30 minutes or so) when even FB was good
<aeth>
For pretty much my entire IRC life, IRC has been that old thing that people who don't want to use the shiny new thing use. Of course, I've been using IRC since 2002 or 2003 or so, so at this point almost all of those shiny new proprietary chat apps are not only old, they're dead.
<aeth>
(And I can't wait for the new batch to go away. Discord, in particular, seems to be pushed very aggressively, but it's very limited in configuration. I don't think you can even have 24 hour timestamps, local logging, etc., on it.)
<clothespin>
Common Lisp seems dead too
<aeth>
clothespin: The difference is that there's no company that can shut down Common Lisp when its numbers drop low enough
<aeth>
Or IRC
<clothespin>
Common Lisp is now so obscure it doesn't even get mentioned on the "Least Popular Programming Languages" surveys
<PuercoPop>
What I really dislike is how Slack has taken over the workplace and displaced email.
<defunkydrummer>
clothespin: plz announce on /r/lisp . Comp.lang.lisp is full of spam and annoyng people like Gavino
<defunkydrummer>
clothespin: Liso is still above Rust and Kotlin on the last TIOBE index so it can't be that obscure.
<loke`>
defunkydrummer: “full of”. You mean “nothing but”
<defunkydrummer>
yep
<aeth>
defunkydrummer: TIOBE is essentially nonsense
<aeth>
But it's not like popularity can be reliably measured, anyway.
<defunkydrummer>
aeth: but is commonly used as an indicator of popularity
<defunkydrummer>
not that I could care too much about CL being popular or not.
<aeth>
And lie detectors are commonly used as an indicator of lying. And horoscopes are commonly used as an indicator of personality.
<defunkydrummer>
aeth: You sound like a Capricorn.
<aeth>
Sorry, I'm a Leo
<defunkydrummer>
hahaha
t58 has quit [Quit: Night]
<PuercoPop>
Btw which do check to for the 'sign bit' of a signed integer, (logbitp 31 i) vs (>= i #.(1- (expt 2 31)))
<PuercoPop>
(Recently found nyef's CLXS code in a forgotten folder in disc)
<Bike>
there's no actual sign bit
<Bike>
is that what the scare quotes are for?
<aeth>
PuercoPop: Wouldn't the sign-bit just be determined by MINUSP or not?
<aeth>
The location isn't fixed since it can be an arbitrary length. Iirc, it's just a bunch of leading 1s infinitely, or something like that.
<Bike>
yes, it's 2-adic.
<Bike>
in particular, (>= i (1- (expt 2 31))) is neer going to be true if i is negative
<Bike>
so uh... don't use that one.
<Bike>
the other one will be true if i is negative and short enough
<aeth>
PuercoPop: Oh, and note that PLUSP is not NOT MINUSP because ZEROP is neither.
<PuercoPop>
aeth: Sorry for got about the context, you are in the process of 'building' it. You have an integer from sticking together a sequence of octets and you want to know what number they represented
defunkydrummer has quit [Ping timeout: 246 seconds]
<aeth>
Bike: You could use INTEGER-LENGTH instead of 31 to make sure that it's always "short enough"
<PuercoPop>
I want to turn it into a number negative number
<Bike>
well, you're treating it as a byte more than a number, then, so i'd use logbitp
<Bike>
it's probably fine efficiency wise if that's what you're worried about
<aeth>
PuercoPop: You can only reconstruct it if you know its size and if it's signed or unsigned. If it's a (signed-byte 32) then whatever works works.
<PuercoPop>
aeth: you, we know the size, both when dealing with X11 requests or OSC (which is the context of the code)
defunkydrummer has joined #lisp
t58 has joined #lisp
<PuercoPop>
Bike: yeah seems the most appropriate
t58 has quit [Client Quit]
t58 has joined #lisp
t58 has quit [Remote host closed the connection]
<aeth>
PuercoPop: So I'm guessing you have combined a bunch of bits to get a number from 0 to (1- (expt 2 32)) and you want to shift that so it's an (unsigned-byte 32). Iirc, the conversion for e.g. 2^32 - 1 is (let ((number (1- (expt 2 32)))) (- (mod number (expt 2 31)) (expt 2 31)))
defunkydrummer39 has joined #lisp
defunkydrummer39 has left #lisp [#lisp]
<aeth>
PuercoPop: Iirc, there's a neat branchless trick you can use here. I think this is it. (multiple-value-bind (quotient remainder) (floor number (expt 2 31)) (- remainder (* quotient (expt 2 31))))
defunkydrummer has quit [Ping timeout: 246 seconds]
clothespin has quit [Remote host closed the connection]
<aeth>
PuercoPop: This works because if it's (expt 2 31) or higher its quotient will be 1 instead of 0, which means it will become negative.
<Bike>
isn't it the opposite direction? you have thirty two bits off the wire and now want a signed integer?
<aeth>
Bike: This goes unsigned->signed. So you're combining the four bytes as if it was an (unsigned-byte 32) and then you're turning it into the equivalent signed representation for the same bits.
<aeth>
I tested it on the boundary numbers, but I might have made a mistake.
<aeth>
If it's 0 to (1- (expt 2 31)) this does nothing, if it's (expt 2 31) to (1- (expt 2 32)) it converts it properly, and it's not valid past that because it's only for ub32s
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
<aeth>
My function is correct because I just compared its behavior to this function in a loop and every ub32 had an = result. (defun cffi-abuse (number) (declare (type (unsigned-byte 32) number)) (cffi:with-foreign-object (i :unsigned-int) (cffi-sys:%mem-set number i :unsigned-int) (cffi-sys:%mem-ref i :int)))
<PuercoPop>
(I have to fix a missing unquote bug I introduced with my previous PR :v)
karlosz has quit [Quit: karlosz]
miatomi is now known as femi
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
rumbler31 has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 246 seconds]
mindCrime has joined #lisp
<beach>
Good morning everyone!
phoe has joined #lisp
mgsk has quit [Ping timeout: 246 seconds]
mgsk__ has joined #lisp
caltelt has quit [Ping timeout: 246 seconds]
mindCrime has quit [Ping timeout: 250 seconds]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
Nilby has joined #lisp
karlosz has joined #lisp
lavaflow has joined #lisp
libertyprime has quit [Remote host closed the connection]
karlosz has quit [Client Quit]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
p9fn has quit [Ping timeout: 240 seconds]
manualcrank has joined #lisp
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
rwlisp has quit [Quit: rwlisp]
dacoda has quit [Ping timeout: 255 seconds]
dale has quit [Quit: dale]
lavaflow has quit [Ping timeout: 246 seconds]
Bike has quit [Quit: Lost terminal]
vlatkoB has joined #lisp
froggey has quit [Ping timeout: 244 seconds]
froggey has joined #lisp
techquila has joined #lisp
igemnace has joined #lisp
rumbler31 has joined #lisp
sauvin has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
rumbler31 has quit [Ping timeout: 258 seconds]
libertyprime has joined #lisp
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
ebrasca has quit [Remote host closed the connection]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
marusich has quit [Remote host closed the connection]
makomo has joined #lisp
andrei-n has joined #lisp
Inline has quit [Quit: Leaving]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
shka_ has joined #lisp
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
femi has quit [Ping timeout: 246 seconds]
anewuser has quit [Quit: anewuser]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
femi has joined #lisp
JohnMS_WORK has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
libertyprime has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 246 seconds]
bendersteed has joined #lisp
femi has quit [Ping timeout: 246 seconds]
femi has joined #lisp
fivo has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life has joined #lisp
lavaflow has joined #lisp
idlus has joined #lisp
ltriant has quit [Quit: leaving]
idlus_ has quit [Ping timeout: 256 seconds]
Folkol has joined #lisp
varjag has joined #lisp
scymtym has joined #lisp
orivej has joined #lisp
p9fn has joined #lisp
ricekrispie has joined #lisp
ricekrispie2 has quit [Ping timeout: 250 seconds]
<dim>
good morning beach!
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
hhdave has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 246 seconds]
hhdave_ is now known as hhdave
<phoe>
morning
<no-defun-allowed>
morning
idlus_ has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
libertyprime has joined #lisp
idlus_ has quit [Ping timeout: 256 seconds]
notnotdan has joined #lisp
notnotdan has left #lisp [#lisp]
idlus_ has joined #lisp
femi has quit [Ping timeout: 268 seconds]
pierpal has quit [Quit: Poof]
femi has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pankajgodbole has joined #lisp
heisig has joined #lisp
bendersteed has quit [Remote host closed the connection]
femi has quit [Ping timeout: 276 seconds]
femi has joined #lisp
idlus_ has quit [Ping timeout: 256 seconds]
random-nick has joined #lisp
idlus has joined #lisp
Folkol has joined #lisp
idlus has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 258 seconds]
tankf33der has quit [Quit: Connection closed for inactivity]
orivej has quit [Ping timeout: 246 seconds]
idlus has joined #lisp
longshi has joined #lisp
<dim>
I've heard about the BBC initiative for exposing kids to programming, the Micro-Bit, a kind of very cheap arduino board with many popular extensions; and to program it in Lisp all I can find at the moment is http://www.ulisp.com/show?2672
<dim>
do you guys know if there's an implementation of Common Lisp that would target this little board?
<aeth>
probably not
jmercouris has joined #lisp
lumm has joined #lisp
<aeth>
If there is, no-defun-allowed probably would know
<no-defun-allowed>
nope, too small
pjb has quit [Read error: Connection reset by peer]
<no-defun-allowed>
also, it has one of those separated code and data models that make COMPILE pretty useless
idlus has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
idlus has joined #lisp
<dim>
mm, so uLisp it is then
cosimone has joined #lisp
refpga has quit [Ping timeout: 250 seconds]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
troydm has quit [Ping timeout: 258 seconds]
<p_l>
no-defun-allowed: unless you use code for optimized routines and data for bytecode+data
makomo has joined #lisp
jmercouris has quit [Ping timeout: 246 seconds]
Arcaelyx has quit [Ping timeout: 250 seconds]
Nilby has quit [Read error: Connection reset by peer]
vaartis has joined #lisp
<vaartis>
hey
<vaartis>
wanted to ask if there's a way to bundle static files when building the program with something like program-op?
longshi has quit [Ping timeout: 250 seconds]
<vaartis>
and is it a decent idea to bundle a dynamic library with an asdf system that someone might install from quicklisp, and if so, how do i do it
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<loke`>
vaartis: Normally you wouldn't do that.
stylewarning_ has joined #lisp
lavaflow has quit [Read error: Connection reset by peer]
<vaartis>
I see.. I want to write bindings for a certain library that isn't in linux package managers, but takes less than a minute to build and doesn't have any dependencies, so i though about maybe just building it for most platforms and bundling like this python thing does http://www.pymunk.org/en/latest/index.html
fowlduck_ has joined #lisp
lavaflow has joined #lisp
<loke`>
vaartis: You can ship the source code as part of the package and then build it if needed.
stylewarning has quit [Ping timeout: 252 seconds]
fowlduck has quit [Ping timeout: 252 seconds]
asedeno has quit [Ping timeout: 252 seconds]
kilimanjaro has quit [Ping timeout: 252 seconds]
stylewarning_ is now known as stylewarning
fowlduck_ is now known as fowlduck
kilimanjaro_ has joined #lisp
<loke`>
THat's something I believe IOLIB should do with libfixposix, but the author don't agree
kushal has quit [Read error: Connection reset by peer]
kushal has joined #lisp
longshi has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Folkol has joined #lisp
dddddd has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
scymtym has quit [Ping timeout: 240 seconds]
schjetne has quit [Ping timeout: 245 seconds]
<vaartis>
the dll-op doesn't seem to do anything though
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
nowhere_man has quit [Ping timeout: 246 seconds]
ggole has joined #lisp
longshi has quit [Ping timeout: 276 seconds]
ym has joined #lisp
scymtym has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
Intensity has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Client Quit]
v88m has quit [Remote host closed the connection]
v88m has joined #lisp
nowhere_man has joined #lisp
scymtym has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
scymtym has quit [Ping timeout: 276 seconds]
pierpal has joined #lisp
ironbutt has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 252 seconds]
idlus has joined #lisp
aeth has quit [Ping timeout: 250 seconds]
aeth has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
idlus has joined #lisp
rwlisp has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
jcowan has joined #lisp
<jcowan>
Question: when if ever does it make practical sense to mix &optional, &rest, and &key in a single lambda list, other than the special case of &allow-other-keys?
gxt has quit [Ping timeout: 276 seconds]
idlus has quit [Remote host closed the connection]
keep_learning_M has joined #lisp
<Bike>
&optional and &key together are kind of verboten
<Bike>
i think sbcl signals a style warning for it, or if did not did at some point
<Bike>
does locally
<Bike>
&rest and &key together is useful if you want to throw your arguments at some other function
idlus has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Bike>
(which is pretty close to what i assume you mean by the &allow-other-keys case)
<jcowan>
Right. I didn't think of the pass-along case, only of the crack-keys-yourself case (like structure constructors)
Folkol has joined #lisp
<jcowan>
I'm glad to hear that &optional and &key together doesn't make sense. I am evaluating a pair of macros for Scheme, which has only &rest (spelled "."), one for optional arguments and the other for keyword arguments. I was checking that it made sense to separate them.\
<Bike>
i mean the rules are consistent and everything, and the code will compile and run... it's just confusing
* jcowan
nods.
<jcowan>
I feel no great need to push for the standardization of functionality that serves only to confuse people. :-)
<Bike>
sensible
<jcowan>
I do think Scheme lambda lists are pretty: (a b c &rest x) is written (a b c . x)
<pfdietz>
&rest and &key together is common, though
<_death>
that forces the rest parameter to be the last one specified
<pfdietz>
(as Bike talked about there, I see)
<jcowan>
in my context that would mean using the macro (which accepts a rest-list and binds variables corresponding to the keywords) as well as the raw rest-list itself.
<jcowan>
s/rest-list/& and keywords/1
<Bike>
you can do (a b c . x) in macro lambda lists, though i don't think i've ever seen it
* jcowan
nods
<pfdietz>
I wonder if SBCL tries to check if a &rest arg's list is being mutated (the list itself, not the objects in the list)
<pfdietz>
It's permitted (but not required) for a CL implementation to reuse the last argument to APPLY as part of the rest list, so destructive modification of that list is a no-no.
lucasb has joined #lisp
vaartis has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
t58 has joined #lisp
cosimone has joined #lisp
heisig has quit [Quit: Leaving]
saravia has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
warweasle has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
nullman` has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
idlus has joined #lisp
cosimone has joined #lisp
orivej has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
sjl_ has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
cosimone has quit [Client Quit]
JohnMS_WORK has quit [Read error: Connection reset by peer]
<jcowan>
pfdietz: No warning, no error: the mutation happens.
lumm has quit [Remote host closed the connection]
<jcowan>
Given (defun foo (a &rest b) (rplaca b 'q) (cons a b)), then (foo 1 2) => (1 q)
lumm has joined #lisp
cosimone has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
<pfdietz>
Not surprised. It would be a good thing to check for.
sjl_ has joined #lisp
cosimone has quit [Client Quit]
nowhere_man has joined #lisp
<pfdietz>
Better to have some sort of "rest args object" from which a list could be obtained, if needed. APPLY would take one of these (or a list) as a final argument.
<pfdietz>
But that is not CL.
<Bike>
sbcl (and other implementations) have things like that internally
idlus has joined #lisp
<Bike>
i don't know if sbcl demotes user &rest into them when possible
keep_learning_M has quit [Quit: This computer has gone to sleep]
<pfdietz>
jcowan: but does the list passed as the last arg to APPLY get mutated?
<pfdietz>
I don't think it is in sbcl.
<pfdietz>
WHich means that list is being copied. Gets expensive with very long lists. This shows up in a programming style where one adds new :key arguments to this list down a call chain.
keep_learning_M has joined #lisp
<pfdietz>
In scheme, are repetitions of the same :key allowed?
<jcowan>
Standard Scheme has no keys at all. The macro I'm looking at will not reject multiple uses but ignores all but the first.
<Bike>
so same as lisp.
<Bike>
(i mean, all arguments are evaluated though)
<pfdietz>
Ok
<jcowan>
The signature of the macro is (let-keywords ls ((var [keyword] default) ... [rest]) body ...) where ... is postfix for iteration. Note that the variable can have a different name from the keyword, though you probably won't want that much.
<Bike>
oh, so it's just like a mini destructuring bind.
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jcowan>
yes
<jcowan>
except the square brackets are metanotation, not actual code.
<Bike>
well, sure.
<Bike>
oh, you don't have a -p?
<jcowan>
You can always use a unique object as the default.
libre-man has joined #lisp
<jcowan>
like (list 'missing) or (string-copy "missing")
<Bike>
right.
<flip214>
does the macro support a -given-p variable as well?
<Bike>
that's what i just asked.
<flip214>
ah, I guess that was Bike's question
<jcowan>
As I was saying, you put a newly consed object into a non-exported global variable and set that as the default: no one can pass you that object, so an eql test shows whether the keyword is missing or not.
idlus has quit [Ping timeout: 256 seconds]
<jcowan>
(there is no :: hack in Scheme)
Folkol has joined #lisp
Inline has joined #lisp
<jcowan>
I have used the same trick for alists as poor man's objects: if the first element in the alist is (<unique> . foo), code that cares can treat it as of type foo, and to code that doesn't it's just an alist.
<jcowan>
(specifically about the practical use of lambda-list keywords)
v88m has quit [Ping timeout: 246 seconds]
<flip214>
If I hang around here for some more time, I might be one of the elders... probably still not considered wise, though.
ludston has quit [Ping timeout: 258 seconds]
* jcowan
chuckles
v88m has joined #lisp
<jcowan>
By the time you think you're an elder, you're actually an old fart.
<saravia>
sorry but, portacle licence is?
<flip214>
thanks a lot!! that gives some new views to my situation...
<saravia>
i dont find portacle licence :S
mindCrime has joined #lisp
<pfdietz>
Talking about scheme to shed light on CL issues is borderline acceptable for #lisp :)
idlus has joined #lisp
<flip214>
which issues?
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<dim>
I'm trying to find this blog post of years ago with an implementation of FizzBuzz all as a single format string in CL, does it rings a bell to anyone here?
<shka_>
hyperspec is online reference, but i think that you could use some decent book
<vms14>
but they're not explaining everything
<shka_>
like PCL
<Jachy>
Maybe the answer vms14 is more simply, convention? You'll often see a get/set pair of (get-foo) and (setf (get-foo)) instead of (get-foo) and (set-foo).
<vms14>
there is no webpage with extensive lisp info? other than just reference manuals
<shka_>
just read PCL
<shka_>
best book out there
<vms14>
I have three lisp books to red
<vms14>
read
<vms14>
paip, onlisp and pcl
<Bike>
and that's not enough?
<katco>
vms14: i think common-lisp.net is the canonical landing-page for common-lisp, but i agree you can't beat a curated walkthrough like you get from a book, and practical common lisp is a great first read.
<vms14>
Bike: it's not money, I usually steal those books
<shka_>
paip is fine, but not strict cl guide, i don't like onlisp, PCL is free and awesome
<edgar-rft>
zero cost
<vms14>
xD
<Bike>
what are you asking about then
<_death>
vms14: On Lisp has good coverage of SETF
<vms14>
shka_: why you don't like onlisp?
<vms14>
isn't the book goal to teach macros?
<Jachy>
All 3 have legit html/pdf versions online for free from the authors anyway. ;)
<shka_>
i don't like Grahams writing style
<katco>
vms14: as an author who spent a lot of time away from my family and young daughter to write a book, it is distressing to hear you steal books.
<shka_>
i find it hard to understand
KLoop has joined #lisp
<vms14>
katco: sorry
<Bike>
seriously, if you say "more than you can afford" but don't mean money what are you even talking about
<katco>
please stop doing that
marusich has quit [Remote host closed the connection]
<_death>
all 3 books are available for free nowadays
<vms14>
Bike: I never end a book, but nvm. I was asking for a website because I usually need to look for more info while reading a book
<Bike>
pcl is on a website
<Bike>
the clhs is also a website
<Bike>
what more do you want
<shka_>
well, i kinda like zeal…
<vms14>
pcl is usually a result from google searchs
<vms14>
but pcl cannot cover lisp entirely
<Bike>
indeed, it doesn't, that's why there's also the clhs
<vms14>
yeah I guess there is no need after all
<Bike>
so you have the easy to understand introduction, and then the manual for the more complicated points
<Bike>
for free
<Bike>
online
<vms14>
just read the books and have clhs as reference
<shka_>
ah there is also Steele's book
<shka_>
Common Lisp the language
<shka_>
which is flawed but valuable
<vms14>
why flawed
<shka_>
source of explanation
<shka_>
some stuff described in the book didn't make it into the standard
<shka_>
other was altered
<shka_>
majority is still relevant
<edgar-rft>
vms14: you can read CLtL2 (Common Lisp the Language 2nd edition) if you want a something that covers all of Lisp, but it predates the official CL Standard by a few years, see https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html
<vms14>
thanks for the hints
<shka_>
despite this, i really like CLtL2
<edgar-rft>
me, too :-)
<shka_>
it is nicely written
<shka_>
Steele is exceptional writer
idlus has joined #lisp
<vms14>
I forgot I've downloaded the cltl2 html version
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
vlatkoB has quit [Remote host closed the connection]
p9fn has quit [Ping timeout: 268 seconds]
lumm_ has joined #lisp
lumm has quit [Ping timeout: 258 seconds]
lumm_ is now known as lumm
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
<phoe>
fe[nl]ix: yes, give me a day - tomorrow I am free to do that
ggole has quit [Quit: Leaving]
t58 has quit [Quit: Shopping]
<katco>
early days, but cl-ana looks so, so, cool
troydm has joined #lisp
idlus_ has joined #lisp
idlus has quit [Ping timeout: 256 seconds]
p9fn has joined #lisp
anamorphic has quit [Quit: anamorphic]
idlus_ has quit [Ping timeout: 256 seconds]
gxt has quit [Ping timeout: 252 seconds]
idlus_ has joined #lisp
catchme has quit [Quit: Connection closed for inactivity]
scymtym has quit [Ping timeout: 276 seconds]
asdf_asdf_asdf has joined #lisp
TheWild has joined #lisp
<TheWild>
hello
<asdf_asdf_asdf>
@TheWild; hello.
<TheWild>
Lisp atoms are: NIL (an empty list), string, number and symbol. Non-empty list is not an atom. Are there other types that are built to the interpreter?
jmercouris has joined #lisp
<phoe>
yes
<phoe>
everything that is not a cons is an atom
<TheWild>
ah, yes. List is a bunch of nested conses. Cons is simply a pair of elements.
<phoe>
every cons is a list
cosimone has joined #lisp
<phoe>
just not necessarily a proper one
<TheWild>
I'm not sure whether vector is built-in or defined by some core library lisp code.
<TheWild>
well, that's a lot of stuff. I forgot about functions, but I was suspecting Lisp bootstraps everything from conses or something else.
<phoe>
kind of
<phoe>
that's the way it was done in the 60s
<phoe>
just conses and symbols
<shka_>
is it though?
<Bike>
yeah, in really old lisps you could call conses if they were lambda expressions, stuff like that
<phoe>
but you need more stuff to bootstrap off if you want to actually be efficient; numbers and arrays are a must, and some sort of function objects to represent code.
<phoe>
with that and a little bit of trickery, you can implement hash-tables, structures and classes, and bootstrap a lot of stuff off that.
<shka_>
interesting
davve has joined #lisp
<Bike>
actually i vaguely remember reading some old lisp implementation implemented numbers as conses of digits
<Bike>
which sounds horrible, but i guess that's what a bignum is if you really think about it and are intoxicated.
<phoe>
Bike: if your fixnum is (INTEGER 0 9) then I have bad news for you
<davve>
hey :) any good resource that covers lisps syntax?
<davve>
I am having a hard time wrapping my head around macros
<phoe>
davve: have you worked with Practical Common Lisp?
saravia has quit [Remote host closed the connection]
<Bike>
what are you having trouble understanding about macros?
<phoe>
are you somewhat proficient with standard rules of evaluation?
<davve>
no. i have just pieced together my emacs init.el :)
<minion>
davve: please look at 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).
<davve>
phoe: sure, mathematically
<Bike>
not those rules
<davve>
the rpn too
<TheWild>
darn, I have to think about Lisp as a higher-level language than just three steps away from assembly. (C was one step, C++ were two ;))
<phoe>
davve: oh, ummm, of standard rules of evaluation *in Lisp*
<davve>
if that is what it's called
<davve>
I'll check out your link
<Xach>
TheWild: it is not that many steps - see the "disassemble" function for example.
<phoe>
reverse Polish notation is kind of theoretical
<phoe>
TheWild: use TAGBODY and GO, there's your assembly toolkit once more
<Younder>
1994 is a long time ago. The standard became stale. No-one cared. The world moved on.
defunkydrummer has joined #lisp
<asarch>
(gtk-demo:main)
<asarch>
\o/
<defunkydrummer>
asarch: which library are you using for gtk?
zooey has quit [Ping timeout: 256 seconds]
<defunkydrummer>
phoe: TAGBODY and GO like a Real Programmer would do. Because Real Programmers are able to talk in actual caps.
<anamorphic>
(tagbody 10 (print "hello") 20 (go 10)) love it
zooey has joined #lisp
<Younder>
fine in macros. though it looks a bit revulting
<defunkydrummer>
minion: memo to saravia: Portacle is a combination of Emacs with SBCL and SLIME, Emacs license you know, SBCL license is mostly Public Domain, SLIME license is Public Domain.
<minion>
Remembered. I'll tell saravia when he/she/it next speaks.
* gjvc
hopes fedora 30 will soon update sbcl to 1.5.x
orivej has quit [Ping timeout: 246 seconds]
<defunkydrummer>
Younder: What looks revolting?
<asarch>
(ql:quickload 'cl-cffi-gtk)
<anamorphic>
gjvc: I gave up on distro packages a long time ago
<asarch>
How would you express your love to a girl if she was a Common Lisp programmer?
<Younder>
defunkydrummer, oh, just the use of got and the like in code. Of cource it is just used to use higher level constructs.
<anamorphic>
asarch: probably expose my slot values as accessors
<Younder>
goto
<asarch>
(be mine)
<gjvc>
anamorphic, know what you mean. I have no idea how good fedora is at this
<defunkydrummer>
Younder: GOTO makes total sense for some kind of code like state machines or some parsers. It simplifies the code.
Younder has quit [Quit: Leaving]
<asarch>
That would be great anamorphic :-P
<defunkydrummer>
anamorphic: Hi
<anamorphic>
Yeah you see goto a lot in Linux's code for simplifying error handling
<defunkydrummer>
open message: Has anybody used Portable AllegroServe? Any opinion on it ?
Younder has joined #lisp
<anamorphic>
defunkydrummer: I did before hunchentoot came a long
<defunkydrummer>
i've taken a look at the WuWei web framework, and it's built on Portable AllegroServe. It's a very nice framework and is actually used on a serious production system, so it has some credibility.
<anamorphic>
(not as brutally practical as if err != nil { return err though)
<defunkydrummer>
anamorphic: Wow, what a practical programming language!! I want it!! This must be the language of the XXI century!!
<PuercoPop>
defunkydrummer: have you seen how much would it take to port it to huchentoot?
<defunkydrummer>
defunkydrummer: I think I'll try AllegroServer first. If I was to port it to something, I'd port it to Clack instead, and let Clack interface to Hunchentoot
mindCrime has quit [Ping timeout: 252 seconds]
<defunkydrummer>
btw Hi dear friend PuercoPop
<defunkydrummer>
I'm just about to try AllegroServe
<anamorphic>
I'm looking forward to dabbling with weblocks when I get time again
<defunkydrummer>
anamorphic: Yeah, yesterday i took a look at weblocks, the problem is the authors state that the documentation isn't useful anymore since the rewrite(reblocks branch)changes the API
<defunkydrummer>
anamorphic: contrast this with Radiance, which probably has the biggest tutorial and documentation of any CL web framework
<anamorphic>
Yeah is there there any docs in the reblocks branch?
<anamorphic>
I will check out Radiance
<defunkydrummer>
reblocks has the same docs of always, some of them have been updated like the tutorial, but the tutorial is very succint
<defunkydrummer>
i also took another look at Caveman2 (fukamachi), the way one defined handlers looks nice, but then... idocumentation is very scarce, and i'd get a bit scared if something doesn't work as expecte
LiamH has quit [Read error: Connection reset by peer]
<anamorphic>
Oh wuwie is mark tarvers's thing? The shen guy?
<minion>
Remembered. I'll tell anamorphic when he/she/it next speaks.
LiamH has quit [Ping timeout: 252 seconds]
anamorphic has joined #lisp
<defunkydrummer>
PuercoPop: tiny simple lib with continuations and ajax. Examples' codebases look fine. Fits my purpose.
<vaartis>
Bike: nope, nothing seems to change
<vaartis>
i'll try attaching gdb
<Bike>
no idea then, sorry.
<defunkydrummer>
PuercoPop: yeah "ajax" sounds like so 2005, but good enough for some tasks, instead of going the "SPA" route
<vaartis>
gdb got it
<vaartis>
actually
<vaartis>
nice
<aeth>
SPA is almost always the wrong choice
anamorphic has quit [Client Quit]
<aeth>
it should be the exception, not the default
Bike has quit []
<vaartis>
now i need to somehow get the debug version of the library built
<PuercoPop>
defunkydrummer: I hate SPA's with passion, but the problem is 'continuations' and CL don't go well together afaik
<vaartis>
anyway, thanks everyone
<vaartis>
and goodnight
vaartis has left #lisp ["zzz"]
<PuercoPop>
plus wuwei seems to make some questionably choices
sjl_ has quit [Ping timeout: 250 seconds]
<PuercoPop>
like (ignore-errors (eval (read-from-string ...)))
<defunkydrummer>
PuercoPop: tell me more, tell me more, did it give you a fight? [Grease music]
<defunkydrummer>
Oh oh
<PuercoPop>
And patching json-encode to recognize alists as maps by walking all the alist
jcowan has joined #lisp
<PuercoPop>
*questionable
LiamH has joined #lisp
random-nick has quit [Ping timeout: 258 seconds]
shka_ has quit [Ping timeout: 246 seconds]
<aeth>
PuercoPop: Oh, wow, I didn't know that all I needed to do was use IGNORE-ERRORS and then I wouldn't make any mistakes anymore.
<pjb>
You still make them!
<pjb>
Only now, you're ignoring them. Which is very bad.
<pjb>
You can't debug your code anymore. You won't know why it's wrong.
oni-on-ion has quit [Ping timeout: 246 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
<PuercoPop>
it is turned on precisely form *developer-mode* ^_^. But everyone has their own debugging flow
<defunkydrummer>
thanks for this warning PuercoPop ...
<PuercoPop>
printf ftw!
<defunkydrummer>
i'm having a pain in the ass trying to make wuwei work with the modern Portable AllegroServe which works over ZACL (AllegroCL compatibility layer)
<vms14>
format so we see nicer output
mindCrime has joined #lisp
<defunkydrummer>
because wuwei also has it's own AllegroCL compatibility layer... they clash and rock the casbah
nullman` has quit [Ping timeout: 268 seconds]
anamorphic has joined #lisp
elderK has joined #lisp
anamorphic has quit [Client Quit]
<defunkydrummer>
well, since i don't have (yet) the money for my own AllegroCL Ultra Deluxe x64 Edition with Flux Capacitor, i think i'll pass...
<minion>
Remembered. I'll tell vaartis when he/she/it next speaks.
cosimone has joined #lisp
beach has quit [Remote host closed the connection]
manualcrank has joined #lisp
ealfonso has joined #lisp
idlus_ has quit [Ping timeout: 256 seconds]
moldybits has joined #lisp
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
<liambrown[m]1>
Is QuickLisp not intended for system-wide install? I just tried installing it system-wide, and it worked, but when I start SLIME as a non-root user I get an error about trying to access "system-index.txt" within the newly created installation tree.
idlus_ has joined #lisp
<no-defun-allowed>
i don't think so, quicklisp touches a lot of files and will create more files when downloading systems
<liambrown[m]1>
So it's a per-user thing? Odd, but not a big deal.