jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language<http://cliki.net/> logs:<https://irclog.whitequark.org/lisp,http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.5, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
<no-defun-allowed> i have a new idea to make cl-decentralise more useful
<no-defun-allowed> right now distribution is kinda messy and ip announcement and async messaging are tied up in one "i'm a node" switch
<no-defun-allowed> so block announcements get to live in channels and clients can subscribe to channels and receive async messages for those new blocks
<no-defun-allowed> the client would have to be redone to put "blocks we weren't expecting but subscribed to" into some storage or we could use a callback like node
housel has quit [Remote host closed the connection]
housel has joined #lisp
dale has quit [Quit: dale]
Fare has joined #lisp
fikka has joined #lisp
jochens has joined #lisp
danielvu has joined #lisp
Pixel_Outlaw has joined #lisp
jochens has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 252 seconds]
holycow has joined #lisp
danielvu has quit [Quit: Textual IRC Client: www.textualapp.com]
danielvu has joined #lisp
danielvu has quit [Client Quit]
Fare has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<AeroNotix> no-defun-allowed: is it intentional that the repo is cl-decentralise but the lisp system is just called decentralise?
<no-defun-allowed> hmm, it's obvious it's a Common Lisp system so yes
<AeroNotix> fair enough
<no-defun-allowed> it's not obvious from gitlab that it's a cl system so i use the `cl-` prefix for git repos
<AeroNotix> ok
caltelt_ has quit [Ping timeout: 252 seconds]
<no-defun-allowed> (blockchains were a terrible idea btw, we already have cl:cons)
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
Lycurgus has joined #lisp
Fare has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
dddddd has quit [Remote host closed the connection]
robotoad has joined #lisp
mindCrime has quit [Ping timeout: 272 seconds]
caltelt_ has joined #lisp
on_ion has quit [Ping timeout: 252 seconds]
robotoad has quit [Max SendQ exceeded]
ealfonso has left #lisp ["ERC (IRC client for Emacs 26.1)"]
robotoad has joined #lisp
holycow has quit [Quit: Lost terminal]
oni-on-ion has joined #lisp
SaganMan has joined #lisp
ealfonso has joined #lisp
sabrac has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
asarch has joined #lisp
jochens has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
jochens has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
lavaflow_ has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 272 seconds]
PuercoPop has joined #lisp
Lycurgus has quit [Quit: Exeunt]
robotoad has quit [Quit: robotoad]
fikka has joined #lisp
lavaflow_ has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
robotoad has joined #lisp
jlarocco has joined #lisp
fikka has joined #lisp
Hu0p has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 245 seconds]
yangby has joined #lisp
fikka has joined #lisp
[X-Scale] has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
[X-Scale] is now known as X-Scale
bradcomp has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<yangby> hello, folks! is there any linters (i found sblint, only) and formaters for CL.
<yangby> i am not good at CL, so i want to find some tools to criticize my codes, strictly.
<White_Flame> SBCL has pretty good compile-time warnings, due to its type inference
<White_Flame> but yeah, as a dynamic language that sort of thing isn't well traveled
<White_Flame> as for formatting, Emacs + SLIME keep the proper indentation for your source code
<yangby> thanks
<White_Flame> probably the biggest thing is to not have empty open or close braces on a line. no "(list (\n a...", nor "(progn (code\n)\n)"
<yangby> i used emacs+slime, i try to find some stand-alone command-line commands, not plugins for editors, for scenes without emacs.
fikka has joined #lisp
<White_Flame> keep open parens with the 1st term, and all close braces right after the last term
<yangby> maybe i can try to write one, :)
<yangby> i want to put them into CI or use as git hooks.
<White_Flame> indentation requires live knowledge of what terms are
<White_Flame> ie, (list 1 2 3) is indented differently if spread across lines than (and (foo) (bar) (baz))
<White_Flame> and that's runtime knowledge, not static knowledge that an external tool can have easy access to
whartung has quit [Ping timeout: 252 seconds]
<White_Flame> the major difference is nested source code bodies vs nested parameters
<White_Flame> there's no syntactic indicator for those 2 scenarios; it's solely the executed declarations describing functions
fikka has quit [Ping timeout: 246 seconds]
<beach> Good morning everyone!
slyrus has quit [Ping timeout: 244 seconds]
slyrus1 is now known as slyrus
slyrus1 has joined #lisp
<yangby> White_Flame: thank you for your patience and guidance!
<White_Flame> np
<no-defun-allowed> afternoon, beach
fikka has joined #lisp
mkolenda has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 246 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
mkolenda has joined #lisp
whartung has joined #lisp
fikka has joined #lisp
bradcomp has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
kristof has joined #lisp
Roy_Fokker has quit [Quit: Leaving]
edgar-rft has joined #lisp
igemnace has joined #lisp
NB0X-Matt-CA has quit [Ping timeout: 240 seconds]
<aeth> There are ways to add some static typing to CL, particularly SBCL, if you need it for verification. e.g. sb-ext:*derive-function-types*
<aeth> You probably don't want it in development because it adds the assumption that the function types won't change (e.g. foo will always return an integer or something) but it will catch some but not all bugs if you were to e.g. compile with it set just to see the warnings/etc.
<aeth> An example of the kind of bug it will (probably) catch: (defun foo (x) (+ x x)) (defun bar () (concatenate 'list (foo 42) "Hello")) ; number's not a sequence and it can tell foo has to return a number, not a sequence
sabrac has joined #lisp
Bike has quit [Quit: Lost terminal]
jochens has joined #lisp
fikka has joined #lisp
H4ns has quit [Ping timeout: 240 seconds]
jochens has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 244 seconds]
Oladon has quit [Quit: Leaving.]
bradcomp has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
steiner has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
bradcomp has quit [Ping timeout: 240 seconds]
kristof has quit [Ping timeout: 272 seconds]
buffergn0me has quit [Remote host closed the connection]
yangby has quit [Quit: Go out for a walk and buy a drink.]
buffergn0me has joined #lisp
NB0X-Matt-CA has joined #lisp
Inline has quit [Quit: Leaving]
scottj has joined #lisp
steiner has quit [Remote host closed the connection]
anewuser has quit [Quit: anewuser]
v0|d has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
logicmoo has joined #lisp
logicmoo is now known as dmiles
akovalenko has quit [Ping timeout: 272 seconds]
akovalenko has joined #lisp
dented42 has joined #lisp
SaganMan has quit [Ping timeout: 246 seconds]
gpiero has quit [Remote host closed the connection]
caltelt_ has quit [Ping timeout: 244 seconds]
sauvin has joined #lisp
Copenhagen_Bram has quit [Ping timeout: 252 seconds]
yangby has joined #lisp
SaganMan has joined #lisp
robotoad has quit [Ping timeout: 245 seconds]
mfiano has quit [Quit: WeeChat 2.1]
robotoad has joined #lisp
phoe has joined #lisp
mfiano has joined #lisp
robotoad has quit [Quit: robotoad]
<Demosthenex> did i miss a standard function for splitting a long list into smaller lists of specific size? i know its minor to code one
<dim> alexandria to the rescue again, maybe something names “partition” or such?
<Demosthenex> dim: i've been reading through the alexandria doc, didnt' see one. my searches came up empty, so thought i'd ask. i thought it was a pretty common case and didn't want to reinvent the wheel. but i just reinvented it :P
<dim> yeah I'm failing to find one too, bad guess
<dim> I'm discovering https://github.com/ruricolist/serapeum now
vlatkoB has joined #lisp
<dim> so, Demosthenex, serapeum:batches
<Demosthenex> cool, didn't see that before
<dim> me neither!
<no-defun-allowed> damn, they have runs
shrdlu68 has joined #lisp
<no-defun-allowed> i wrote a runs-if for my phoneme->syllable splitter, i wonder how they did theirs
gpiero has joined #lisp
zxcvz has joined #lisp
nowhere_man has joined #lisp
zxcvz has quit [Quit: zxcvz]
splittist has joined #lisp
a7f4 has joined #lisp
asarch has quit [Quit: Leaving]
<jasom> For very small fixed sizes, I'd do something like (loop for (a b c . d) on list by #'cdddr collect (list a b c))
<jasom> actually the . d I think is not required for loop destructuring
<aeth> really? it's required in the equivalent destructuring-bind
<aeth> hmm, it isn't required
a7f4 has quit [Ping timeout: 272 seconds]
<no-defun-allowed> loop's binder =/= destructuring-bind, it's way weaker
<aeth> I can understand why they wouldn't want . d to be required because most of the time in a looping context you'd be ignoring it
scymtym has quit [Ping timeout: 246 seconds]
charh has joined #lisp
steiner has joined #lisp
varjag has joined #lisp
jochens has joined #lisp
shka_ has joined #lisp
<shka_> good day
<no-defun-allowed> hi shka_
scymtym has joined #lisp
<shrdlu68> shka_: Good morning
<shka_> shrdlu68: oh, hello
<shka_> shrdlu68: is there a way for me to run your code?
<shka_> i would try to benchmark it for you
<shrdlu68> shka_: Try running #'arithmetic-coding::test-file on a small file (< 100kb)
<shka_> what file, though?
<shka_> and what repo? :-)
<aeth> no-defun-allowed: Ohm in case I was unclear, I meant "in the equivalent destructuring-bind [form]" not "in the equivalent[, ] destructuring-bind"
<aeth> s/Ohm/Oh,/
<shka_> shrdlu68: can i have some test file?
<no-defun-allowed> what's the internal resistance of loop again?
<aeth> no-defun-allowed: I think that's implementation-dependent
<no-defun-allowed> i see.
<no-defun-allowed> do i need to factor in parasitic capacitance while i'm at it?
<no-defun-allowed> (this is why lisp doesn't catch on: at least rust is mostly insulative)
<dim> loop forms aren't composable at all, see iterate for a fix
<no-defun-allowed> that's true but not the joke
<aeth> The problem is that Lisp is built out of a bunch of equations on paper, and not a just abstractions over a physical machine.
<dim> I personally like loop because it's simple for the simple cases and allows quite some level of complexity
<beach> no-defun-allowed: I think you are totally wrong about why Lisp is not catching on.
<dim> no-defun-allowed: oh. the joke passed well over my head here.
<dim> I guess my English is not up to the joke at hand
<beach> Mine too, I guess.
<no-defun-allowed> ohm = resistance
<aeth> Someone needs to make a programming language where loops are *real*
<no-defun-allowed> "the resistance of LOOP is implementation dependent"
<shka_> aeth: actually, this was already done
<dim> aeth: I thought CL loop was that?
<shka_> :P
<dim> I mean when I first read the docs/introduction about loop, I was in awe
<aeth> shka_: Did someone port Ruby to that?
<shka_> haha, not yet!
<no-defun-allowed> someone said loops happen when your language doesn't have good recursion
<beach> That someone was wrong.
<beach> I guess anybody is allowed to say anything these days.
<shka_> shrdlu68: anyway, please also send me some test file
<beach> Too bad people tend to believe just anybody as well.
<shka_> i don't have will to figure out what format you are using
<shka_> shrdlu68: great!
<shka_> shrdlu68: i think that this is output from sbcl-sprof
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<dim> beach: “don't believe everyting you can read on the internet”, as said Socrate
<shrdlu68> shka_: There's a text.bmp file, scroll down
<beach> dim: Right, of course he said that.
<shka_> shrdlu68: you are right, thanks
<shka_> shrdlu68: i will tackle this in the evening
<shrdlu68> shka_: There is no format, you can pass any (small) file to that function. Thanks!
<no-defun-allowed> actually, i quite agree with that statement, beach
<no-defun-allowed> from recursion you can build map(car), ranges and quite a lot of useful structures
<no-defun-allowed> admittedly it's not digital transistor-machine friendly but it's still a very pleasent system
<beach> no-defun-allowed: It sounds like something a CS theoretician would say, i.e. someone who has never programmed anything significant in his or her entire life, and who also doesn't intend to.
<beach> no-defun-allowed: I have way too many colleagues like that.
<no-defun-allowed> cool, i'm a cs theoretician now
<beach> no-defun-allowed: You just reversed the implication arrow, so, no, you are not sufficiently into theory.
<no-defun-allowed> good point
<no-defun-allowed> haha
glv has joined #lisp
<no-defun-allowed> theory sounds more exciting than actual code though
zfree has joined #lisp
<aeth> If theory is more exciting than code, then you need to find something more exciting to code.
pierpal has joined #lisp
housel has quit [Read error: Connection reset by peer]
<no-defun-allowed> maybe
<beach> no-defun-allowed: It is especially a much simpler activity to exercise.
<shka_> beach: i guess this depends
<shka_> neural network practicians seriouly could use some solid theory
<beach> Of course. It's a generalization.
<no-defun-allowed> i guess i'm just bored of writing programs that read two numbers and print out the sum for class
jlarocco has quit [Ping timeout: 245 seconds]
<flip214> no-defun-allowed: don't know whether someone told you that already, but get a few good books and work through them. SICP, PAIP, LoL (both ;)
<no-defun-allowed> alright
pierpal has quit [Quit: Poof]
<flip214> I'm aware that (the classical) SICP does Scheme - but translating all that into CL is a good exercise. At least I enjoyed it.
pierpal has joined #lisp
zfree has quit [Quit: zfree]
<beach> The other way around would be much harder.
<no-defun-allowed> it wouldn't be that hard, people try to do it in non-lisps
<no-defun-allowed> they'll fall over in chapter 2 i'm sure
<beach> no-defun-allowed: The other thing you can do is to start working on some of my "suggested programming projects". Then you can expose your code for remarks. http://metamodular.com/Common-Lisp/suggested-projects.html
orivej has joined #lisp
<no-defun-allowed> that's a lot of projects
<beach> You only have to do one.
<beach> But they all need to be done I think. Plus a lot more.
<no-defun-allowed> those look too hard actually
<beach> Oh, OK. Too bad.
<shka_> eh, i should get back to my graphviz clone
SenasOzys has joined #lisp
<no-defun-allowed> :c
<shka_> it is not that hard
<shka_> but kinda boring ;-)
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
SenasOzys has quit [Ping timeout: 244 seconds]
SenasOzys has joined #lisp
SenasOzys has quit [Remote host closed the connection]
yangby has quit [Quit: Go out for a walk and buy a drink.]
troydm has quit [Ping timeout: 252 seconds]
<Demosthenex> hrm. can postmodern dao objects have foreign keys?
kushal has quit [Ping timeout: 256 seconds]
kushal has joined #lisp
SenasOzys has joined #lisp
wigust has joined #lisp
glv has quit [Quit: Leaving]
m00natic has joined #lisp
steiner has quit [Remote host closed the connection]
troydm has joined #lisp
shangul has joined #lisp
<dim> beach: I keep thinking it would be awesome to have some infrastructure level software written in Lisp that would target production environments... on the level of a DNS server, (HTTP) proxy, something that you deploy and trust in the background
troydm has quit [Ping timeout: 240 seconds]
<shrdlu68> dim: Me too!
<dim> an example would be pgbouncer, which has some limitations that are hard to overcome because it's complex to do in C, but my take is that it wouldn't be too hard in CL
<dim> https://pgbouncer.github.io is a proxy for PostgreSQL, and in "transaction mode" it doesn't know how to handle protocol-level prepared statements
<dim> those need a 2-level indirection mapping data structure, dynamic
<dim> having a pgbouncer on steroids would be quite something
<shka_> oh, this really sounds like job for CL
<dim> it does, right?
<dim> also most of the PostgreSQL protocol is already implemented in Postmodern, and is quite well documented in the PostgreSQL docs themselves, and has been implemented in many other programming languages before
<dim> (already *partially* implemented in Postmodern)
ym has quit [Quit: Leaving]
<shka_> right
<shka_> well, i use both lisp, pg and postmodern daily
<shka_> but i have just one user
<shka_> ME :D
<no-defun-allowed> you're your own worst enemy
<dim> shka_: well do you have a single connection at a time?
<shka_> i am but that's not releated :-)
<shka_> dim: exactly
doubledup has joined #lisp
<shka_> just one
<shka_> but i was looking at manardb
<shka_> i think that it may improve my setup
<dim> in typical web based situations I've seen pgbouncer in transaction mode reduce client connections from 600 (client side) to 4 (PostgreSQL side), which is quite impressive
<shka_> yeah, certainly can see how it is usefull
<dim> then if you have time and want a project to hack on, either you shka_ or no-defun-allowed, have a look at pgcharts too: https://github.com/dimitri/pgcharts
<dim> it needs some Javascript foo and some lisp fixes too, and I don't have enough time in my hands to work on it
<no-defun-allowed> what do the charts mean?
<shka_> oooh
<no-defun-allowed> are they just sql visualisations?
<shka_> dim: i like it!
<dim> how do you mean?
<shka_> i will check it out
<dim> as in the name of the project, or a specific chart you saw on the website?
<no-defun-allowed> it's very cool
<dim> thanks guys! yeah the charts are the visual results of the SQL queries
<dim> in my head when done the project is awesome and allows to share documents with the other people in your company, maybe Marketing people etc, and you can save the result of a query in a doc or make it dynamic
<dim> also ala notebook (Jupyter) I'd like it if embedded queries in docs would be easi to edit and run again, and you see the result updated
<dim> well anyway
<shka_> dim: this sounds really neat
Kaisyu has quit [Quit: Connection closed for inactivity]
steiner has joined #lisp
<shka_> sadly, zeppelin is resource hog, though
igemnace has quit [Quit: WeeChat 2.2]
<Shinmera> no-defun-allowed: I'm always open to more contributors, so if you think one of my projects is interesting, I'd be willing to offer help and guidance.
<no-defun-allowed> alright thanks
<dim> if you guys have some time and are bored, another easy project is https://github.com/dimitri/pgloader/issues/782#issuecomment-397758567
dddddd has joined #lisp
<dim> QMYND:MYSQL-UNSUPPORTED-AUTHENTICATION attempting to load data from mysql 8.0.4-rc
<dim> no-defun-allowed: that might be a small enough hack for you to play with, really
<dim> adding the new authentication method from MySQL in the CL driver
dim has quit [Quit: ZNC - http://znc.sourceforge.net]
ebrasca has quit [Remote host closed the connection]
dim has joined #lisp
<no-defun-allowed> hmm ok
Bronsa has quit [Remote host closed the connection]
xristos has joined #lisp
fikka has joined #lisp
jochens has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
doubledup has quit [Quit: Leaving]
<AeroNotix> clhs function forms
<AeroNotix> dim: not lisp but: https://github.com/ankane/dexter
<phoe> I have a foreign pointer and a length. Can I somehow access that memory as if it was a Lisp array without copying?
<phoe> Or am I stuck with CFFI's mem-aref?
<fe[nl]ix> the latter
<phoe> welp - fine, then
sword has joined #lisp
kooga has joined #lisp
pierpal has quit [Quit: Poof]
zerobaud has joined #lisp
pierpal has joined #lisp
<zerobaud> I want to learn lisp, I am getting completely crazy by writing boilerplate in any language, I want to exploit metaprogramming. I know PHP,C,ASM,JS,Python and they all suck in their own ways....
fikka has quit [Ping timeout: 272 seconds]
<zerobaud> Which (modern) lisp dialect should I start with?
<zerobaud> I dont mind parenthesis, I want it for metaprogramming. I also want it to be compiled to assembly
<zerobaud> No virtual machine bytecode type of things.
<shrdlu68> zerobaud: We heartily recommend Common Lisp.
<zerobaud> alrighty then, now I usually program with a text editor, is this okay for lisp? and what compiler do you recommend? my platform is linux
<zerobaud> s/text editor/vim
<AeroNotix> vim will work fine for CL
nowhere_man has quit [Ping timeout: 252 seconds]
<shrdlu68> zerobaud: http://www.sbcl.org/
<dim> zerobaud: read PCL to get started, I think (http://www.gigamonkeys.com/book/)
Lycurgus has joined #lisp
<zerobaud> Thanks guys, got everything I need now!
fikka has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<shka_> zerobaud: most of people here use emacs, if you want to turn emacs into vim quickly take a look at the spacemacs
<zerobaud> yeah shka_, I can understand why you people us emacs... its written in lisp itself and stuff
nbunjeva3 has joined #lisp
<zerobaud> I dont know... emacs is a great OS but its still lacking a good text editor ^^
rumbler31 has joined #lisp
<shka_> anyway, do you guys think that it is possible to have something on par with slime in nvim nowdays?
<j`ey> there is vlime
<shka_> how good it is?
<j`ey> I installed it, but haven't worked it out yet
<shka_> ok
gypsydave5 has joined #lisp
nbunjevac has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
ym has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
TheWizard has joined #lisp
random-nickname has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<flip214> j`ey: shka_: I'm maintaining a few patches on top of the "official" vlime at https://github.com/phmarek/vlime
<flip214> zerobaud: ^^
<flip214> patches, comments, help is welcome, of course.
TheWizard has quit [Quit: Leaving]
LiamH has joined #lisp
TheWizard has joined #lisp
<AeroNotix> I'm looking for a state machine tester akin to PropEr's statem testing. Does anything like this exist for CL? Essentially you model transistions between states and the checker works much like a property tester to generate ops against that model.
nowhere_man has joined #lisp
<phoe> mfiano: inside pngload, can I first query the PNG file for its width and height, allocate a static-vector, and then tell pngload to load the image into that vector?
<AeroNotix> There's https://github.com/DalekBaldwin/check-it which is about 10% of what's needed.
<phoe> mfiano: or, in different words, can pngload load images into static-vectors?
<phoe> mfiano: oh, I see that it can - wonderful! Thanks
jochens has joined #lisp
Essadon has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
steiner has quit [Remote host closed the connection]
igemnace has joined #lisp
ym has quit [Quit: Leaving]
rumbler31 has quit [Remote host closed the connection]
steiner has joined #lisp
<j`ey> flip214: I should probably read vlime-tutor
Chream has joined #lisp
fikka has joined #lisp
steiner has quit [Remote host closed the connection]
<flip214> j`ey: might help, yeah ;)
argoneus has quit [Quit: No Ping reply in 180 seconds.]
argoneus has joined #lisp
arbv has quit [Quit: ZNC - https://znc.in]
arbv has joined #lisp
makomo has quit [Read error: Connection reset by peer]
Bike has joined #lisp
aijony has quit [Ping timeout: 245 seconds]
steiner has joined #lisp
reverse_light has joined #lisp
FreeBirdLjj has joined #lisp
jkordani has joined #lisp
lavaflow_ has quit [Ping timeout: 272 seconds]
cammey has joined #lisp
jkordani_ has quit [Ping timeout: 252 seconds]
Fare has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<beach> dim: Sounds great. If you write a page for those, I'll add them to my "suggested projects".
makomo has joined #lisp
arbv has quit [Ping timeout: 252 seconds]
<zerobaud> I really like the way linux kernel hanldes if(FEATURE(FEATURE_NAME)){}else{} etc... How do they implement this?
<j`ey> macros/defines?
<Shinmera> not with common lisp, that's for sure
<zerobaud> can I just #define FEATUREX and then #define ENABLED(x) x
<zerobaud> ops
<zerobaud> wrong channel
<dlowe> zerobaud: you could try defmacro on *features*
<zerobaud> yeah sorry, was meant for ##c
<dlowe> ;)
random-nickname is now known as random-nick
FreeBirdLjj has joined #lisp
Chream has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
razzy has quit [Ping timeout: 240 seconds]
Arcaelyx has joined #lisp
cage_ has joined #lisp
mindCrime has joined #lisp
rippa has joined #lisp
bradcomp has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
housel has joined #lisp
SenasOzys has quit [Ping timeout: 252 seconds]
kuribas has joined #lisp
<kuribas> what does the n in nconc stand for?
fikka has joined #lisp
bradcomp has quit [Ping timeout: 245 seconds]
<cammey> I believe it's for non-consing, but don't take *my* word for it.
gypsydave5 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
<Shinmera> it means destructive
SenasOzys has joined #lisp
<pfdietz> This is a convention that is followed in many places in Common Lisp, but not everywhere (glares at SORT).
<Bike> stands for non-undestructive
<beach> Heh!
<Shinmera> or maybe not-necessary-unless-youre-optimizing
steiner has quit [Remote host closed the connection]
<cammey> Yeah, the #\n is for "non-consing". Search for "non-consing" here: http://www.gigamonkeys.com/book/they-called-it-lisp-for-a-reason-list-processing.html
fikka has joined #lisp
<kuribas> right, thanks
<Shinmera> n functions can still cons though
<Bike> yeah.
<Shinmera> and pcl is not a spec by any means
<Bike> they're just allowed to be destructive to avoid it. they don't HAVE to. except nconc i guess.
<Shinmera> could still cons if you want it to as an implementor :)
<Shinmera> maybe for Contrarian-CL
fikka has quit [Ping timeout: 245 seconds]
dyelar has quit [Quit: Leaving.]
ebrasca has joined #lisp
<Bike> unlike the other n functions, it has a specific destructive algorithm laid out
<Bike> though i guess the implementation could have it cons just for fun
<mfiano> and nsubst
fikka has joined #lisp
Fare has joined #lisp
igemnace has quit [Quit: WeeChat 2.2]
jochens has quit []
fikka has quit [Ping timeout: 252 seconds]
<Bike> so it seems.
<beach> We could compile a set of quizzes. Here is another: What functions are obliged to test the elements in reverse when :FROM-END is given?
steiner has joined #lisp
<Shinmera> didn't Xach do something like that once
<beach> Nice!
<beach> No :from-end though?
equwal has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
<cammey> Hmmmm, is there a typo here?! shouldn't the parenthesized parts in the description be reversed?: http://www.lispworks.com/documentation/lw70/CLHS/Body/f_pos_p.htm
<cammey> Or "leftmost" and "rightmost" could be swapped.
Khisanth has quit [Ping timeout: 272 seconds]
<beach> I believe you are right.
<cammey> I really thought I was mad for a second.
fikka has quit [Ping timeout: 246 seconds]
<cammey> Does someone have a copy of the ANSI spec to see what it says there?
<dlowe> The hyperspec is, for all intensive purposes, identical to the ANSI spec
<dlowe> but there definitely are errors in the spec docs
<cammey> Yeah, thats what worries me. Now there are exactly zero fully conforming implementations...
<cammey> :P
pierpal has quit [Quit: Poof]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
pierpal has joined #lisp
fikka has joined #lisp
<dlowe> I went ahead and added your observation to the cliki page.
blackwolf has joined #lisp
<cammey> Thanks :)
Khisanth has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<Bike> but for lazy purposes they're WAY different
<shka_> Contrary Lisp
<shka_> Shinmera: that is really funny to me :D
<AeroNotix> uhm, I leaked some usocket listeners in my repl. How to find them?
<dlowe> AeroNotix: The fast path here is to restart your lisp
<AeroNotix> what's the slow path?
<shka_> *
<shka_> **
<shka_> ***
<AeroNotix> shka_: they leaked within a let that returned something else
<dlowe> check /proc/<pid>/fd for listeners, then close them
<dlowe> on linux at least
<shka_> AeroNotix: eh, that sucks
<dlowe> no idea what you could do on windows
<AeroNotix> I'm not on windows
fikka has joined #lisp
dyelar has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<AeroNotix> feckit, did it with gdb manually
<shka_> well, that works
<AeroNotix> indeed it does
scymtym has quit [Ping timeout: 252 seconds]
sjl has left #lisp ["WeeChat 2.2-dev"]
asarch has joined #lisp
fikka has joined #lisp
warweasle has joined #lisp
robotoad has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
pierpal has quit [Read error: Connection reset by peer]
eschulte has joined #lisp
<jkordani> AeroNotix: how did you do that?
<AeroNotix> jkordani: found the file descriptors with lsof, connected to the sbcl process with gdb and ran `p (int) close($FD)`
<jkordani> slick
<eschulte> Question on `match' from trivia. Can I match (e.g., with "(type string)") something in a condition *and* bind it to a variable for use in the clauses body?
shangul has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
scymtym has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
m00natic has quit [Read error: Connection reset by peer]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
m00natic has joined #lisp
fikka has joined #lisp
nika has joined #lisp
gpiero has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
k-hos has quit [Read error: Connection reset by peer]
Fare has joined #lisp
<eschulte> I guess guard does this, but the syntax feels clunky
MoziM has joined #lisp
MoziM has left #lisp ["WeeChat 2.2"]
Arcaelyx has joined #lisp
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
k-hos has joined #lisp
steiner has left #lisp ["ERC (IRC client for Emacs 26.1)"]
shrdlu68 has quit [Quit: WeeChat 2.0.1]
dale_ has joined #lisp
dale_ is now known as dale
kuribas has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
jlarocco has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
TSA66 has joined #lisp
fikka has joined #lisp
jkordani_ has joined #lisp
nbunjeva3 has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 245 seconds]
Fare has quit [Ping timeout: 244 seconds]
jkordani has quit [Ping timeout: 245 seconds]
Inline has joined #lisp
Inline has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Inline has joined #lisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
<TSA66> Hi all. Looking for help constructing a (define-condition x ...) along with (if ... (error x ...) exception handling pattern
steiner has joined #lisp
<fouric> zerobaud: as a former ("pure-")vim user, i _highly_ recommend spacemacs
<fouric> it took me i think less than a day do get comfortably productive in it - 95% of the keybindings just work out of the box
<Bike> TSA66: what do you need help with?
<Xach> TSA66: what's up?
<fouric> and there are equivalent elisp extensions for the most common vim scripts. also, you get SLIME/Sly, which are (1) generally better-tested and more feature-complete than VLIME because (2) more people use them
<russellw> Terminology question: I want to say stuff like #+ is called special syntax, but then I also kind of feel like if/lambda/defun etc should also be called special syntax. What are the proper terms in each case?
<TSA66> Using CCL on macOS. The define-condition part is pretty simple. But in the function where the error is being thrown, I'm getting "Unbound variable: ERROR".
<Bike> eh, i guess #+ is like, textual or reader or character syntax, whereas "defun's first parameter is an unevaluated symbol name" is form syntax
<Bike> TSA66: could you paste code for that function?
fikka has joined #lisp
<TSA66> I'm trying to trigger the condition as part of a (cond ((a) (b) (error x)) construct
<TSA66> Bike: Here it is: (define-condition unknown-or-missing-target-type (error)
<TSA66> ;; list of arguments, can be "()".
<TSA66> ((target_type :initarg :message
<TSA66> :reader target_type))
<beach> Not here
<TSA66> ;; class arguments
<TSA66> (:report (lambda (c s) (format s "unknown or missing option: ~s" (target_type c))))
<TSA66> (:documentation "This condition is thrown with the target type is unknown or missing."))
<beach> TSA66: On a pastebin site.
<Bike> please use a pastebin service for pastes of more than one line
<TSA66> SORRY !!!
<Bike> and i'm interested in the function, not that definition (though it looks fine, cursorily)
<Bike> stylewise it's "signaled" rather than "thrown", and you'd have target-type instead of target_type, but it's not a huge deal
<Bike> "signaled when" even
<Bike> i see, you wrote the cond wrong
<Bike> is the error supposed to be the default condition, if neither of the string=s are true?
<pfdietz> (t (error ...)) for last clause
fikka has quit [Ping timeout: 246 seconds]
<TSA66> Yes
<Bike> yeah, the cond syntax is (cond (condition ...body) ...), so the first thing is the condition
<Bike> in your case it takes ERROR to be a variable, which is why you get that error
<TSA66> So silly. Thanks for the extra set of eyes.
<Bike> no problem
<pfdietz> You could also write ((error ...)) I guess.
<beach> I would not encourage that.
<pfdietz> No, it would not be idiomatic.
<TSA66> I agree ... better to be explicit
<TSA66> @Bike: @beach: @pfdietz: Thanks for your help. Got it working.
<beach> Congratulations!
fikka has joined #lisp
steiner has quit [Remote host closed the connection]
TSA66 has quit [Quit: WeeChat 2.2]
orivej has quit [Ping timeout: 244 seconds]
steiner has joined #lisp
phao has joined #lisp
<phao> Hi. Is there some sort of "low level lisp" in which you have lisp syntax, macros and some lisp-like things but for low level programming?
Fare has joined #lisp
jlarocco has quit [Ping timeout: 240 seconds]
<beach> phao: This channel is dedicated to Common Lisp, which is pretty good with low-level programming, but I guess that depends on what you want to do.
fikka has quit [Ping timeout: 272 seconds]
m00natic has quit [Remote host closed the connection]
<phao> beach, thanks
<phao> I was asking just out of curiosity. I have no specific use in mind.
<beach> Hmm, OK.
<beach> phao: People write operating systems in Common Lisp for instance.
<phao> I see.
cammey has quit [Ping timeout: 272 seconds]
<Xach> rob warnock had some examples showing that if you can peek and poke, you can do pretty much what you want.
<beach> And I believe that's what froggey is doing for the garbage collector.
<beach> ... in Mezzano.
Lycurgus has quit [Quit: Exeunt]
<beach> phao: A garbage collector is a typical "low-level" thing, and froggey wrote the one for his Mezzano operating system in Common Lisp. Not in totally standard Common Lisp, of course, but he added primitives for accessing memory by address.
<phao> Ok.
<beach> phao: Do you have some planned project?
Fare has quit [Ping timeout: 272 seconds]
<phao> Nothing concrete. It was just out of curiosity really. I wanted just to see if there were people using lisp for low level programming and the sort of things they were doing, the kinds of results they were getting, etc.
<beach> I see.
Jesin has quit [Quit: Leaving]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
<beach> Interestingly, pretty much the entire object system can be written on top of only STANDARD-INSTANCE-ACCESS and (SETF STANDARD-INSTANCE-ACCESS).
<beach> Those are just a step above PEEK and POKE.
<beach> You need some bootstrapping code as well, of course, but those are the only "low-level" functions you need. Well, CLASS-OF as well perhaps.
fikka has quit [Ping timeout: 244 seconds]
Jessin has joined #lisp
<beach> I wonder whether they introduced a GC in Firefox at some point. I recently updated it, and it behaves as if there is suddenly a really bad GC algorithm in it with very long pauses.
<beach> If so, it would be a fantastic example of Greenspunning.
Arcaelyx has joined #lisp
gpiero has joined #lisp
<flip214> beach: FF has had a GC since the beginning, IIRC.
<beach> Hmm.
<beach> Thanks.
<flip214> beach: also see about:memory
<beach> good idea.
<flip214> hmm, quite a lot of things here...
<beach> What is the main code base written in ?
<Bike> you also need something to actually allocate the instance, don't you
<beach> Bike: True. ALLOCATE-INSTANCE.
<Bike> i think standard-instance-access plus setf, class-of plus some kind of setf, and an %allocate-instance that took the number of slots would probably be it. that's how the implementation with vectors in amop works, if i remember rightly
pierpal has joined #lisp
<beach> Sounds right.
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
lavaflow_ has joined #lisp
fikka has joined #lisp
terpri has joined #lisp
kajo has joined #lisp
equwal has quit [Ping timeout: 272 seconds]
<beach> The question by phao was not very detailed, so it is hard to be more precise.
fikka has quit [Ping timeout: 252 seconds]
<beach> Sometimes people come here with some similar questions, but more like "My colleagues told me not to even bother with Lisp because you can't do low-level programming it. Are they right?"
<dlowe> and then they go on with "man, nodejs is the best thing ever"
* dlowe shrugs.
<beach> But it could also be "I have this great project that requires some low-level programming. Would you recommend I learn Common Lisp to make it easier to realize this project?"
<beach> dlowe: I take it you talk from experience?
<dlowe> beach: yes.
<beach> :(
pjb has joined #lisp
jkordani has joined #lisp
<flip214> the fewer one knows, the more sure he [sic] is of his opinion...
<beach> "fewer" or "less"?
<beach> "fewer" suggests the number of people the person knows.
<flip214> beach: sorry, you're right, of course.
<flip214> seems I'm too tired, perhaps I should do less complex things...
<beach> Welcome to the club. I had a long week and a long day.
<flip214> so I shouldn't bother you with things I noticed about your GC right now?
orivej has joined #lisp
<beach> The positive thing about the day was that my favorite coauthor came over for lunch.
<beach> Correct, not right now. :)
<flip214> well, tell me when it's more appropriate then... if I'm awake I might even make a bit of sense ;/
jkordani_ has quit [Ping timeout: 246 seconds]
<beach> In the evening I usually spend time with my (admittedly small) family, but she is in Trump-land right now. Either way, I work from early in the morning, so in the evening I am unable to think straight.
fikka has joined #lisp
<beach> Also, before morning coffee is challenging.
<beach> Otherwise I am fine.
<flip214> good to hear! I'm looking forward to seeing you next year in Italy -- sadly I don't know any probable earlier chance (yet ;)
<beach> Aww!
<flip214> "Also, before morning coffee is challenging", ie. making coffee?? ;)
<beach> :)
<beach> We have already have friends of my (admittedly small) family on visit, then heisig and his gf, and soon drmeister and his family. Why would you hesitate?
<beach> phoe has promised to come visit too, but nothing concrete so far.
<flip214> I'd very much like to introduce you to my family ... but I'm afraid that we're too big a burden.
<flip214> of course I could try to come alone..
<beach> That depends on how long you stay and what level of service you require.
<beach> You can have the entire ground floor, but only for a limited period of time.
fikka has quit [Ping timeout: 244 seconds]
<beach> Like, if you handle the kitchen and invite me and my (admittedly small) family for meals every day, I would be delighted.
<flip214> Bordeaux, right? no direct flights, sadly...
<beach> Oh?
<LdBeth> Yaki Soba for lunch today
<beach> flip214: What is your nearest airport?
<flip214> beach: VIE
<flip214> and while I'd like to be your cook for some time, any visit needs careful planning - work & family...
<LdBeth> Good morning
<beach> flip214: I fully understand.
<beach> Hello LdBeth. Yakisoba sounds good to me.
<flip214> ouch, trains need ~ 15 hours.
<beach> Might as well drive.
<flip214> the flight, even with a stop, is only ~4.5 hours according to google. and even cheaper than going by train.
<beach> I can imagine.
kooga has quit [Quit: :]
<beach> But hey, take some time off and dive through our beautiful regions on your way.
<flip214> That
<flip214> That's quite a big risk you're taking... imagine that I'm taking you up on that offer -- I can't even read what I buy in French supermarkets....
<beach> That, we can help with. Fixing three meals a day for 9 people would be beyond our physical capacity, though.
<flip214> *That* I can fully understand ;)
<beach> We don't look it, but we are getting old. :(
<Demosthenex> lost in trumpland... aren't we all.
<flip214> beach: try to get as old as I'm feeling at some times ;)
<beach> Demosthenex: My wife tries to stay away, but she has family there. I don't so I do. :)
<beach> Heh!
<Demosthenex> as an american living in europe... i'm always apologizing. "oh you speak english, american?" "yes, sorry"
<beach> Demosthenex: Congratulations. My (admittedly small) family is from Texas and she just loves living in France.
<Demosthenex> i should start just adding "Eh?" at the end of each sentence, but it's hard to pass off "howdy eh?" as canadian instead of texasn
<beach> :)
<Demosthenex> france is great. i'm supremely grateful and humbled to be allowed to live in NL
<beach> Sure.
<Demosthenex> if i can retire here for life, i will be tremendously grateful
<Demosthenex> it's so refreshing to live someplace civilized
<beach> My (admittedly small) family just did that. :)
<beach> I totally agree.
<LdBeth> Too early, the restaurant haven’t open yet
<Demosthenex> my son got to visit france over the summer, he was thrilled
<beach> Demosthenex: If you bring your copy of Lisp in Small Pieces to ESL in April, my (admittedly small) family will sign it for you with the pen that she was offered as the "distinguished technical writer" at ILOG (which sold LeLisp).
<beach> ELS
<Demosthenex> beach: ha! awesome!
<Demosthenex> but... i can beat that
<beach> Bah, how?
<Demosthenex> i paid a full retail value of ms-office (~$500 usd) for a copy of org-mode.
<Demosthenex> to the author, and received a cdrom with the files AND a signed manual
<sukaeto> <no-defun-allowed> theory sounds more exciting than actual code though
<sukaeto> ^ can confirm. In theory, there is no difference between theory and practice
<sukaeto> in practice, theory is much more fun :-)
<beach> Demosthenex: ms-office beats Lisp in Small Pieces? Never!
fikka has joined #lisp
<Demosthenex> beach: not at all. as an independent consultant i use org-mode for everything. i nearly bought a copy of ms-office for compatibility reasons, and instead just bought excel. i figured i owed the author of org a compensation for the amount of usage i got that was comparable
<beach> I see.
<Demosthenex> he thought i was nuts, but i insisted on paying. not for the software, but for a "distribution and shipping" ;]
<beach> Heh!
<Demosthenex> gpl allows that
<Demosthenex> so i have a signed org manual
<stacksmith> Demosthenex: do you find libre office not compatible enough?
<beach> Demosthenex: I am willing to bet you will have more fun talking to my (admittedly small) family than to the author ms-office.
<Demosthenex> stacksmith: absolutely not. i can't stand libreoffice. or openoffice.
<Demosthenex> stacksmith: not that it's a bad product, it's that i'm not the target market
<Demosthenex> stacksmith: i'd rather write org/latex and compile my docs any day
<Demosthenex> stacksmith: as to vs excel, excel was the finest product Ms ever made. they should have stopped there. it was the only product worth paying for, and libre doesn't come close
<Demosthenex> can you imagine a world where ms made the best spreadsheet, and none of their other crap existed? such a happy dream
fikka has quit [Ping timeout: 245 seconds]
<Demosthenex> beach: could be ;] i like to think i'm a humble american looking to learn
<Demosthenex> teach me the ways of civilized living
<Demosthenex> gates can suck a lemon
<pjb> Yes, a world where scientific research has to be redone periodically, because of features of excel.
<beach> Demosthenex: We have lived here since 1987 and my (admittedly small) family is now a citizen.
<Demosthenex> pjb: i'm all too aware of how often IT encounters half-assed apps written in excel ;]
<stacksmith> Demosthenex: interesting. I haven't used it in a decade or more. But then again I almost never use libre either.
<Demosthenex> pjb: used to work for a company that had to run sales forecasting reports in excel for DAYS on ancient macs because the chairman was an excel guy.
<Demosthenex> stacksmith: i'm on excel 2003. there's a decade of room ther e;]
<stacksmith> I just have an absolute ban Microsoft and Google.
<stacksmith> Second one is much harder.
<Demosthenex> beach: i'm learning dutch in weekly classes, and hoping to apply for permanent residence or citizenship in a few more years. i'd be so glad
<Demosthenex> stacksmith: same.
<Demosthenex> like many consultants, i have to constantly deal with the windoze plague
<beach> Demosthenex: Good plan. I love the Netherlands and the people living there.
tfb has joined #lisp
<Demosthenex> i had a friend at a hospital IT dept... they had a storage array die which took down over 300 windoze VM's... and in the after meeting the unix admin was quoted as saying that "it was a good start". i wish i'd bought him lunch
<beach> Do it!
<stacksmith> It's like that lawyer joke.
<Demosthenex> professionally i
<aeth> On the earlier topic of "low level lisp", I wonder if immutable arrays solves the array of struct problem. i.e. the array itself is immutable, but not necessarily the object slots for the contained objects, so the compiler is free to optimize for objects that can't change size. (Including structure-objects? Array-level immutability means even inheritance won't matter because allocated as simply foo means they are just a foo!)
<aeth> Immutable arrays gives you AoS because you want COPY-INTO (already exists as REPLACE for sequences) and not SETF to copy that pattern, anyway. A lot of low-level programmers seem to consider AoS as a necessary feature when they list features and it seems to be the main thing CL doesn't do. This comes up enough that I keep refining this idea.
<Demosthenex> i'm an uber-consultant on high end unix systems (ibm/aix) for hospitals and banks, but i've been a hobbyist programmer since i was 8
<stacksmith> How do you get Windows to stop crashing? Install Linux.
<Demosthenex> i wish i'd learned lisp a few decades ago
<Demosthenex> stacksmith: it's patch omega.
fikka has joined #lisp
<stacksmith> What's the difference between Windows and a bucket of shit? The bucket.
<stacksmith> Damn! Any lawyer joke just works.
<Demosthenex> ha!
<Demosthenex> my current bane is cloud-anything :P
<Demosthenex> or "ooooh dev ops is shiny"
<phoe> beach: yes, I'll visit - need to straighten out some things beforehand.
<phoe> Real life and such.
<phoe> 2019 is possible..
<Demosthenex> beach: the bicycling here is amazing =]
<stacksmith> Mine is fingerprint analysis. Kind of ruins the web experience.
<beach> Speaking of "shit", if I can only get my shit together, I will have a bootstrapping paper to submit to ELS 2019
banjiewen has joined #lisp
<Demosthenex> stacksmith: that's got to be an interesting field.
<stacksmith> beach: you have a little time left, no?
<beach> phoe: Sounds good. I am tired of empty threats, though. :)
<beach> Demosthenex: flatland? Here too!
pierpal has quit [Quit: Poof]
<beach> stacksmith: I take as much time as I need depending on priorities.
varjag has joined #lisp
pierpal has joined #lisp
<beach> stacksmith: Are you thinking of a visit as well?
Jessin is now known as Jesin
fikka has quit [Ping timeout: 240 seconds]
<Demosthenex> beach: i was a communter cyclist in houston, tx in my college years, which was a huge personal risk. i didn't get a car until after i had kids. the NL cycling infrastructure is a cyclist paradise, i've come home.
<stacksmith> beach: I missed the beginning of this conversation... Where are we visiting?
<beach> Demosthenex: Wow! My (admittedly small) family is from Houston!
<beach> Demosthenex: You have tons of things to talk about.
<beach> stacksmith: I am located in a city called Bordeaux in a country called France.
<oni-on-ion> ahh france =) is it bikin g country also ?
<stacksmith> Demosthenex: houston eh. Did you get any 'get a car, faggot' combined with a beer can lobbed at your head?
<Demosthenex> stacksmith: yeah. often
kristof has joined #lisp
<Demosthenex> stacksmith: but then at stoplights i'd balance on my clips, and take off before corvettes
<beach> stacksmith: Lots of people visit is. I don't quite know why, because we don't think of ourselves as sociable. I guess it must be the service provided.
<Demosthenex> stacksmith: the US car addiction is in for a rude awakening. i can't wait for global warming to cause gas prices to soar
<stacksmith> beach: sounds good.
<kristof> Is anyone familiar with a way to compile non-local transfer of control to a target with only structured control flow (lexical breaks, etc.) other than passing along the continuation?
sauvin has quit [Read error: Connection reset by peer]
<stacksmith> Demosthenex: unless that russian guy is right and the earth's core is all oil.
<Demosthenex> stacksmith: we'll all just die of heat death then
sabrac has quit [Ping timeout: 240 seconds]
<stacksmith> Or drown in oil when we penetrate the upper mantle and pressurized oil comes out.
<dlowe> kristof: sure, you define a function with a lexical closure describing all its state that returns itself, and on re-invocation, jumps to the proper line of execution
fikka has joined #lisp
<kristof> There are no nested functions here, either.
jmercouris has joined #lisp
<dlowe> this doesn't depend on nested functions
<jmercouris> hello everyone :)
<beach> OK, tomorrow I just *have* to make progress on my SICL bootstrapping. It involves making a special version of MAKE-METHOD-LAMBDA in one phase if the bootstrapping procedure, I imagine.
<dlowe> kristof: anyway, you just keep a bit of state in whichever data object about where you are in the computation
<stacksmith> dlowe: that sounds an awful lot like a continuation?
<beach> But I had a long day and a long week, so I'll work on it tomorrow.
<jmercouris> beach: I don't want to give advice or anything, but I find it best to avoid using words like "must" or "have" or "should" and instead replace them with terms like "would be nice"
<jmercouris> this makes it so you don't stress yourself or put pressure on yourself
<dlowe> stacksmith: sure, without language support
<fouric> beach: do you have a second to give me a quick summary of SICL's status in general?
<beach> jmercouris: I am pretty sure I do that deliberately. remember that I am a teacher. I may have done it in some wrong places of course.
<kristof> dlowe: Can you elaborate further?
<kristof> if you don't mind
<beach> fouric: Sure. Give me two minutes to9 prepare...
<fouric> of course! thanks in advance - i'm interested in the idea of SICL but haven't yet put aside the time to dive into the source and grok it myself
maarhart has joined #lisp
maarhart has quit [Excess Flood]
maarhart has joined #lisp
maarhart has quit [Excess Flood]
fikka has quit [Ping timeout: 244 seconds]
<jmercouris> beach: as you wish :)
<dlowe> kristof: do you have a more concrete example?
<kristof> I'm trying to implement catch and throw on web assembly.
<dlowe> that's a very long way off from common lisp
<kristof> Is it?
<kristof> I know drmeister is interested in this :P
<Bike> they can be common lisp catch and throw
<kristof> Yes, I meant "I'm trying to figure out how to do common lisp catch and throw on web assembly". I should look at the compilation strategy for exceptions in other languages...
<dlowe> yeah, I don't think my examples were gonna help.
<kristof> I thought "just call the continuation" would work but I want to reclaim the stack space used.
<dlowe> I thought you meant in common lisp
<beach> fouric: I am all yours.
<LdBeth> Continuation is just subroutine in lambda calculus
<kristof> If I can gripe a little: I'm really annoyed that web assembly is a "stack machine", but then adds a few types on top to make the stack heterogenous. This really handicaps the architecture because the stack has to be verified for type correctness.
<fouric> beach: oh, sorry - i didn't have any specific questions aside from "how complete is SICL as a Common Lisp implementation" and perhaps" how far away is it with competing with e.g. SBCL"
<beach> jmercouris: I may be wrong of course, since I don't remember all the times I have used those words.
<LdBeth> And any assembly languages would support subroutine in a very straight way I think
<fouric> sorry if that's overly broad, again i'm not familiar at all with the project internals
<beach> fouric: Oh, not to hard to answer...
<Bike> LdBeth: if you're talking about rewriting all code in continuation passing style, this is not the most efficient strategy
<Bike> though it would work
<phoe> beach: no, I seriously want to visit you there. (: I just need a little bit of planning and another bit of luck.
<jmercouris> phoe: all that one truly wills one can do.
<beach> fouric: Almost all the code is written. The main remaining blob I finished yesterday (method combinations).
<kristof> If it was just a stack of "words" (e.g. 32 bit), you could easily do catch-throw by saving the offset on the stack and dropping the difference between the stack pointer and the offset.
<jmercouris> instead, acknowledge that it is simply not a priority
<stacksmith> I hate saying it, but if the code is continuation-based, would not something like Racket be more appropriate?
<LdBeth> Bike (IRC): I see
<beach> fouric: I don't have an x86-64 backend, but I used to. It needs to be updated.
<kristof> If you want efficient 64 bit words like longs and double floats, then just define those as "double words" and let the JIT compiler optimize accordingly. They really dropped the ball...
<beach> phoe: I am joking.
<kristof> but anyway. stacksmith: I meant continuation as in the compilation strategy, not the control flow construct for user consumption.
<fouric> beach: excellent, thanks!
<stacksmith> kristof: how do they mark types on the stack? Now I am curious.
<beach> fouric: I am not working directly on Cleavir optimizations. Bike and drmeister are more interested in that aspect at the moment, so the level of optimization will still take some time to be able to compete with SBCL.
<beach> fouric: Cleavir is pretty stable though. There are three current clients: Clasp, SICL, and CLISP.
<kristof> kristof: The runtime representation of the stack contains no types (that's what the verification stage is for). There are just 32 bit words and 64 bit words.
<kristof> Well, single and double ints, and single and double floats.
<fouric> ...a CLISP client?
* fouric was not expecting that
<beach> Yep.
<kristof> Yeah, that also surprised me
<kristof> I didn't know clisp was still maintained, I thought the last maintainer just disappeared?
<jmercouris> Clisp is not maintained
<beach> karlosz had a GSoC project to implement a Cleavir-based compiler for CLISP.
<kristof> interesting
<beach> fouric: I am lucky. drmeister is paying Bike to work for me :)
<drmeister> kristof: webassembly is supposed to get exception handling. Why not work with them?
<beach> jmercouris: CLISP is maintained.
<kristof> I want it *now*
<jmercouris> beach: Judging by the website, the last release was in 2010
<jmercouris> perhaps we have different definitions of "maintained"
<kristof> Besides: other languages have exceptions and compile to it just fine so I suppose I should just see what they do.
<phoe> jmercouris: release, yes, but there have been commits and bugfixes for clisp
<beach> jmercouris: I don't keep up so I don't know the current website.
<jmercouris> Why might someone choose CLISP over any other implementation?
<drmeister> kristof: also my understanding is that the stack is not accessible in web assembly - this precludes me porting our GC and clasp to web assembly.
nika has quit [Quit: Leaving...]
<kristof> drmeister: You just write your own stack in linear memory.
fikka has joined #lisp
<kristof> Which is what C does
<beach> jmercouris: Perhaps for the arbitrary-precision floats?
<kristof> drmeister: Do you have a GC? I thought you just link to Boehm
phao has quit [Quit: Leaving]
<kristof> I actually wrote a small lisp-like macro expander for web assembly s expressions so that I could get to work on an interim allocator
<kristof> but more than one person has said "Ok, now all I have to write is a garbage collector" and never resurfaced from that rabbit hole.
<jmercouris> beach: do no other implementations support this? no libs to simulate this?
<beach> I don't know.
<beach> SBCL does not.
<jmercouris> I guess it would be a pain if you used a lib to simulate it
<jmercouris> because in any operations outside of the lib, with any other systems, you'd have to ultimately go down to a base level of precision
<dlowe> could always make a wrapper for libm yourself
<beach> jmercouris: So here is my goal: Write an implementation-independent compiler that is so good that most (all?) implementations would use it.l
<drmeister> We use memory pool system and boehm. When I say “our” I mean that I’m a very loose sense. What does one truly “own”?
<jmercouris> beach: that's an ambitious goal, I hope you succeed!
<beach> jmercouris: It has already been done basically.
<kristof> drmeister: (Only faults and failures are truly owned by oneself)
fikka has quit [Ping timeout: 246 seconds]
<jmercouris> beach: well then, let me rephrase, congratulations on your invaluable contribution to the lisp community!!! :)
|3b| has quit [Quit: k]
<beach> jmercouris: The question is whether existing implementations will use it.
<beach> jmercouris: Then, we can free up maintenance resources to use for other Common Lisp projects.
nbunjeva1 has joined #lisp
<jmercouris> hopefully one day I can say the same, that I have contributed to the Lisp community through Next by exposing more people to the language
<beach> jmercouris: Oh, you really need to come to ELS. :)
<jmercouris> beach: I guess you have to do some marketing :D
|3b| has joined #lisp
<drmeister> kristof: and faults and failures are why we have exception handling - now I understand.
<kristof> drmeister: This is hypocritical given what I just said but there's no good reason to port Boehm to Web Assembly because there is a GC proposal and... it is actually quite good
<jmercouris> beach: I would really like to, next year I'll have more money as I'll no longer be a student, at least in a full-time academic sense
<beach> As I frequently say, I don't care if I am the only person using my stuff.
<Demosthenex> indeed
<stacksmith> beach: that's pretty good. Most of my stuff - even I don't use!
<kristof> drmeister: At the very least, the plan is to use tagged pointers. The high bit for fixnum vs pointer, and then double word alignment to give another two bits for tags
<beach> jmercouris: Do what I told froggey to do. Start a crowd funding site to finance your trip.
<makomo> hello :-)
<kristof> (two or three). There's some quibbling over how to do this in an architecture generic way but I've seen the discussions and I trust the person mainly responsible for this proposal
<beach> stacksmith: I am afraid your utterance was cut off.
keppy has joined #lisp
<stacksmith> beach: I was just saying that even I don't use most of my stuff. So one person using it is a lofty goal.
<beach> Got it.
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
jsjolen has joined #lisp
<jsjolen> Does anyone on here run Roswell and Ubuntu 18.04?
<beach> jmercouris: I can promise you I will contribute.
<Demosthenex> still wish i had a invoicing program that looks like dbase Iv i could use in ssh =]
<Demosthenex> i've been looking at ncurses stuff, like croatoan just added ncurses support
<beach> jsjolen: People might be reluctant to answer that unless you have a more specific question or suggestion.
<phoe> jsjolen: kind of
<phoe> I run roswell and debian sid
<phoe> and I guess ubuntu is debian enough
<beach> jsjolen: "If so, you have just won a 100k€ trip to Madeira"
<phoe> what do you need support with?
<jsjolen> beach: True, thanks for telling me :-).
<beach> phoe: You spoil all the fun. :)
<phoe> beach: no, I'm trying to win the 100k€ trip (:
<jsjolen> phoe: Ubuntu 18.04 made a change to libcurl4 (OK, I'm not entirely in on the specifics of that) and it broke some apps for people. For me it broke Roswell, so I wanted to see if someone else is succesfully running it
<stacksmith> I am
<jsjolen> (and if they had any issues w/ regards to libcurl)
<phoe> jsjolen: did you recompile roswell from scratch?
<beach> phoe: Oh, sorry, I should be quiet. :)
<phoe> beach: (;
<phoe> I remember that issue and recompiling with the proper dev headers made it go away.
<phoe> Something about curl version not being found.
<stacksmith> Successfully?? that's another story. I am always scratching my head with roswell.
<Demosthenex> i was looking at it, maybe for dumping executables
<phoe> stacksmith: all I use roswell for is `ros install sbcl-bin` and `ros run`
<makomo> beach: it's pretty fun to see how connected the lisp community is -- all these visitations and such :-)
<phoe> Demosthenex: Shinmera's deploy package is for that
<beach> makomo: Yes, it's great!
<jsjolen> phoe: In the middle of that process actually :-) (also yes, that's exactly the error that I have)
<stacksmith> phoe: same here. Until I notice things like .sbclrc being ignored and stuff.
<phoe> stacksmith: ~/.roswell/init.lisp
<phoe> jsjolen: do that then, it helped me in my case
<beach> makomo: The central thing is ELS.
<beach> makomo: Nearly 100 participants every year.
<makomo> speaking of ELS, the 2018 ELS videos still aren't up :-(. i've read some of the proceeding, but hearing/seeing the real thing is a special feeling, especially if there are interesting questions at the end
<jsjolen> Alright! Seems like the roswell error has now changed :).
<kristof> lol. Ok, I looked up how one ocaml fork does exceptions in web assembly
<makomo> proceedings*
a7f4 has joined #lisp
<kristof> they... do it in javascript! So it seems like everyone wants exceptions.
<beach> makomo: You need to harass the local organizers.
<makomo> beach: i emailed Didier about it and he said he'll try to put some pressure on the committee but still nothing
<beach> He is not the local organizer.
fikka has joined #lisp
<beach> He is very busy as it is.
<phoe> jsjolen: what is it?
<makomo> yeah, true. i'm not sure who the local organizer is though, hmm
<makomo> i only emailed him because his name was at the bottom of the webpage :-)
<beach> makomo: Ravenpack
<jsjolen> phoe: It was an unnecessary error when I tried doing ros setup. Compile error from ECL when compiling SB-GROVEL for some reason. I thought "hey I already have SBCL, what gives?" and tried ros use sbcl, ros run sbcl and bing-bada-boom it worked fine
<makomo> beach: oh i see. does it say that somewhere on the ELS webpage or? i can't find anything obvious
<jsjolen> Thanks for the help phoe, stacksmith!
<phoe> jsjolen: no prob
<phoe> see you the next time roswell blows up (;\
<jsjolen> Hahaha, now you made me feel like a tech support parasite :'(. Which I guess is true, but I have nothing interesting to say anyway :-/
rpg has joined #lisp
<makomo> beach: i guess you can tell by the people listed as "Local Chair"?
keppy has quit [Remote host closed the connection]
<phoe> jsjolen: nah, it's perfectly fine
<phoe> I can't count the times I needed support with roswell
<phoe> it got much better in the last months but it's still immature software.
<phoe> needs a year or two more to stabilize
graphene has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
jsjolen has quit [Remote host closed the connection]
graphene has joined #lisp
<beach> makomo: Not sure that that means.
<makomo> beach: i mean, how can you tell ravenpack is the local organizer just by looking at the website? it's not stated anywhere explicitly
<makomo> but the two guys that form the "Local Chair" are both from Ravenpack (listed at the beginning of the proceedings), so i guess that's a clue
<beach> I have no idea. Shinmera is apparently in charge of the website these days.
<beach> You have a good point though.
<makomo> thanks for the info though, i'll try emailing them and see what they say :-)
<beach> I am pretty sure the web site was med for people who were already there.
<beach> So I see only one solution for 2019...
fikka has joined #lisp
<phoe> put the local organizers on quicklisp!
nanoz has joined #lisp
<phoe> (ql:quickload :els) (els:organizers)
<beach> No, be there or be square.
graphene has quit [Remote host closed the connection]
<oni-on-ion> =)
graphene has joined #lisp
<beach> makomo: You should create a crowd-funding site. I would contribute.
<makomo> beach: haha :-). well, i'm thinking about it, since it's pretty close
<jmercouris> beach: maybe I should have, well, next time!
<makomo> beach: thanks very nice to hear and thank you for the kind offer, but money isn't the problem
<beach> makomo: Not a joke. Let me know and I will transfer some money.
<beach> Oh?
lavaflow_ has quit [Ping timeout: 240 seconds]
<makomo> there's no problem really, but it'll be my first time at a conference (or going out of country by myself at all)
<makomo> s/thanks/that's/
fikka has quit [Ping timeout: 245 seconds]
<makomo> beach: you are too kind :-)
<beach> makomo: It would then be an excellent opportunity.
<beach> makomo: You would be among friends.
<makomo> :-)
<phoe> makomo: what country are you from?
<beach> Again, not a joke. I strongly encourage it.
<makomo> phoe: croatia, literally right next to italy :-)
<beach> makomo: Oh, come on! No reason to stay away!
<makomo> i'll be starting my first job soon which is another plus since i'll probably earn the money by myself
<makomo> yeah, i think you're right :-)
<beach> We are, trust us! :)
kristof has quit [Ping timeout: 245 seconds]
trittweiler has quit [Ping timeout: 260 seconds]
<makomo> i guess i'll have to start planning soon then :-D
<beach> makomo: I know phoe and he is often right.
<beach> makomo: you do.
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<beach> I am very serious about the crowd funding
fikka has joined #lisp
<jmercouris> I was actually thinking about starting a crowd funding campaign to support the Linux port of Next
<beach> I am sure you will get what you need.
lavaflow_ has joined #lisp
<makomo> beach: that's very inspiring to hear and nice of you, but i think it won't be needed
<makomo> italy is very close and the trip isn't very expensive from what i've heard
<phoe> makomo: wellll
<phoe> that's close
<makomo> yeah, i think it's a really good opportunity. it's just that i haven't made any concrete plans so far
<makomo> but i am (was) seriously thinking about it
<beach> makomo: Fine with me. Whatever it takes to make you consider going.
<makomo> :-)
fikka has quit [Ping timeout: 272 seconds]
<phoe> woah
<phoe> DEFGENERIC accepts declarations!
* phoe +1 Lisp experience
<pjb> some of them at least.
rumbler31 has joined #lisp
<phoe> ...
<pjb> only optimize.
<phoe> This has a DX declaration.
Fare has joined #lisp
fikka has joined #lisp
troydm has joined #lisp
lavaflow_ has quit [Ping timeout: 245 seconds]
makomo has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 252 seconds]
warweasle is now known as warweasle_afk
zhlyg` has joined #lisp
<zhlyg`> What is the DECLARE form to inline a function?
<jmercouris> flet
<phoe> zhlyg`: (declare (inline foo)) (defun foo ...)
<jmercouris> or what do you mean?
<phoe> wait
<phoe> s/declare/declaim/
<jmercouris> oh, sorry, I misunderstood
<jasom> zhlyg`: declaim
<zhlyg`> I want to inline AREF calls
<stacksmith> (declaim )
<phoe> oh wait a second
<jasom> zhlyg`: you have to hope the compiler does it for you then
rumbler31 has quit [Remote host closed the connection]
<phoe> zhlyg`: where? in a function body?
<jasom> zhlyg`: make sure that your array is of a known type
lavaflow_ has joined #lisp
<jasom> zhlyg`: sbcl won't inline calls to arrays that aren't simple
<stacksmith> outside the function. (declaim (inline foo))...
cage_ has quit [Quit: Leaving]
<stacksmith> And make sure to recompile any function that uses the inlined function.
<phoe> zhlyg`: you don't want to inline AREF since declaiming standard CL symbols is undefined behavior.
<phoe> What you want is use SBCL (because it has a very good type inference engine) and, inside your function (declare (optimize speed)).
<phoe> SBCL will then tell you where it is unable to optimize and why. Mostly it is because of unknown or non-declared types.
nly has joined #lisp
<phoe> For instance, inside (defun foo (x y) (declare (optimize speed)) (+ x (aref y 0)))
<phoe> There are two notes - first of all, X is of unknown type, second, Y is an array of unknown type.
<phoe> You could try evaluating this form in SBCL and reading the notes the compiler gives you.
nanoz has quit [Quit: Leaving]
<zhlyg`> phoe: is declare-inline-aref inside a function also undefined?
<jasom> (disassemble (lambda (x) (declare (type ( simple-array t (*)) x)) (aref x 3))) ;; <-- note this is inlined in sbcl, but without the type declaration it is not
<phoe> zhlyg`: yes.
<nly> "Hello"
<phoe> zhlyg`: but it's not what you want to do, anyway.
<zhlyg`> my array is a matrix, and I tell the type by using (declare (array single-float *) matrix)
<phoe> zhlyg`: what is the dimension of that array???
<phoe> ...sorry, my keyboard multiplies keypresses at times
<zhlyg`> phoe: 2! its a matrix?!
<phoe> (declare (array single-float (* *)) matrix)
<phoe> That'll be better. You'll tell Lisp that your array is two-dimensional.
<zhlyg`> phoe: Oh! thanks!
<phoe> Also
<nly> I came here after seeing some demos of lisp machine and Gerry sussman's talk "we don't know how to compute", does anyone know about those things?
<jasom> And if it's 3x3 you can do (array single-float (3 3))
vlatkoB has quit [Remote host closed the connection]
<phoe> Do that trick with (optimize speed) on SBCL and read all the notes you get from the compiler. That's where SBCL needs more information to generate fast code.
<zhlyg`> phoe: Thank you alot! Also thanks to jasom and stacksmith! I need to rewrite my home-grown vector/matrix lib now :)
<jasom> Also make sure that your innermost loop gets inlined; sbcl will not elide type checks on function calls unless the safety is set to 0 (which is usually a bad idea), so having your inner loop inlined means it can hoist the type-check outside of the loop
makomo has joined #lisp
<zhlyg`> jasom: I dont know the size of each dimension at compile time, can it still unroll the loop? I was thinking about manually unroll the known modulo size.
<jasom> zhlyg`: I think it won't. Most serious matrix libraries special case everything smaller than 3x3
<jasom> zhlyg`: it will eliminate the type check, but I don't think it's smart enough to do the dimension check outside of the loop. Test it yourself though, as I haven't tried for 2+ years and sbcl is constanty improving
fikka has joined #lisp
<pjb> zhlyg`: you cannot put declarations on things in CL.
<pjb> Only on your own things.
razzy has joined #lisp
<zhlyg`> Also last question, should you strive to remove the SB-KERNEL:HAIRY-DATA-VECTOR-REF ?
<jasom> zhlyg`: almost certainly, if you are seeing that then it either can't tell the arity or cannot determine that it is a simple-array
<pjb> But perhaps you can declare inline functions in CL, it doesn't seem to be forbidden in
<pjb> Only special, type and ftype declarations are forbidden.
<AeroNotix> Why is #'usocket:socket-server not exported properly? It's in the exports but it seems the asd file doesn't include the file where it is defined but includes implementation specific files which end up not including the mentioned function
<jasom> all functions in CL will meet the INLINE requirements anyways since redefinitions are forbidden
<jasom> AeroNotix: already disregarded
<AeroNotix> It's exported through a different system
fikka has quit [Ping timeout: 252 seconds]
<AeroNotix> oh wow and I just learned something about CL systems
<AeroNotix> or asdf definitions any way
<pjb> jasom: actually declaring a CL function inline may be counter productive (again), since already all functions in CL can be open-coded (which AFAICT, is a stronger version of inlining).
<jasom> an inline declaration allows open-coding, doesn't it?
<zhlyg`> Also, aren't there some fluid setting when you build sbcl?
<pjb> jasom: I don't know. I see inlining as more restricted. For me, you need a lisp function body to replace the function call. Open-coding can be done as if it was a special operator, without having to have a source for the function.
<jasom> pjb: ah, I see you consider open-coding to be anything that preserves the semantics of the function, rather than anything that preserves the semantics of the forms that implement the function?
<pjb> Yes.
<jasom> I can see how that can be a useful distinction, but mostly I hear open-coding and inlining used interchangably with compiler people.
<jasom> of course these are non-lisp compiler people
<zhlyg`> How do you see the compiler hints? I see HAIRY calls stuff but get no hints.
<jasom> zhlyg`: how are you compiling your file?
lavaflow_ has quit [Ping timeout: 244 seconds]
<zhlyg`> jasom: naivly doing sbcl --load my.lisp
<jasom> zhlyg`: hmm let me see if that does it here...
<aeth> pjb: isn't the main practical distinction that it's a conditional inlining? So + can be open-coded for single-float but not for integer.
<pjb> This is a big difference, indeed.
<jasom> zhlyg`: (compile-file "my.lisp")
Roy_Fokker has joined #lisp
<jasom> zhlyg`: also, I can strongly recommend learning slime at some point, you can compile a file open in it with two keystrokes
<zhlyg`> jasom: I'll try putting (COMPILE 'myfun) directly after the function, but nothing spits out.
<jasom> zhlyg`: I'm pretty sure notes are suppressed for the entire time sbcl is processing a --load option
fikka has joined #lisp
<aeth> I actually wonder if open-coding can be implemented in a non-implementation specific way, possibly with https://github.com/markcox80/specialization-store/
<zhlyg`> jasom: compile-file didn't do it, but I'll load up slime :)
<pjb> aeth: yes, it can, with compiler macro. But not on CL functions!
<aeth> The main issue is that the type information that's inferred would have to be provided to https://github.com/Bike/introspect-environment which is currently not done in SBCL (you have to manually DECLARE types for it to work iirc)
<pjb> Said otherwise, the language reserves compiler macro on CL functions to the implementation, so it can open code them this way.
<aeth> pjb: No, I mean, you could build a CL around *portably* doing this sort of thing, if the compiler can provide information to introspect-environment and then work through introspect-environment
<aeth> So the internals of the open-coding would be portable CL
flazh has quit [Ping timeout: 246 seconds]
<pjb> You could propose such an API to SICL.
fikka has quit [Ping timeout: 246 seconds]
<Bike> sbcl type inference is done aftercompiler macros are expanded
<Bike> it would be a huge pain in the ass to do type inference on source
<aeth> Oh, hmm, just realized a problem for arithmetic. + takes in a list of numbers (i.e. &rest numbers)
<Bike> and type inference is ALREADY a huge pain in the ass
<Bike> so no, you cannot build a CL around portably doing this sort of thing.
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth> pjb: I expected a negative response, though
<aeth> Easiest way to find out something won't work is to say it on IRC
<Bike> sicl already includes environment accessors
<aeth> Bike: thanks
fikka has joined #lisp
<Bike> i could write a backend for introspect-environment, but SICL is non-operational and specialization-store is the only thing using the library anyway
trittweiler has joined #lisp
fikka has quit [Read error: Connection reset by peer]
<Bike> actually i suppose i'd have to fix sicl up so that the global enviroment readers work on lexenvs.
<aeth> Bike: specialization-store is fairly popular for solving certain problems, though. Not enough to make it to http://blog.quicklisp.org/2018/03/download-stats-for-february-2018.html yet but I wouldn't be surprised to see it there eventually once something that uses it gets enough popularity.
<aeth> (well, it looks like download stats aren't being published after February)
<aeth> (The problems are problems involving numbers and sequences, by the way.)
mindCrime has quit [Ping timeout: 252 seconds]
<no-defun-allowed> Hi everyone
Arcaelyx has joined #lisp
<AeroNotix> aeth: do you know if the download stats are available for every package?
fikka has joined #lisp
<aeth> AeroNotix: I would ask Xach
<aeth> AeroNotix: The numbers are probably skewed by automated testing, though
<AeroNotix> Sure, I get that
<AeroNotix> btw what happens when Xach is no longer around?
<AeroNotix> with quicklisp I mean
<AeroNotix> bus factor seems rather high
<jasom> AeroNotix: anyone can setup a distribution; there sources for each package in quicklisp are in git. You could run a clone of the main distribution today.
<aeth> AeroNotix: Someone used to use the name busfactorone (or something similar) here.
<aeth> AeroNotix: I'm not sure I've seen one higher than 3 in the Lisp community.
<aeth> Maybe some compilers
<AeroNotix> jasom: I know custom distributions are a thing but the "de facto" main quicklisp dist seems at risk
Denommus has joined #lisp
<aeth> jasom: The problem is that most people never touch a setup that works. If the main Quicklisp dist stopped being updated and everyone moved to FooLisp it would literally take years for the migration.
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
<AeroNotix> to me it seems like a "self serve" system like mvn/pypi/crates.io would seem "better"
acolarh has quit [Ping timeout: 245 seconds]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<AeroNotix> though it ruins that awesome feature of QL that as far as I understand it X a c h takes time to test that all systems work together/pass tests within that distribution
<aeth> Oh, and not every guide gets updated. People still come to Lisp help places with issues about Lisp in a Box or whatever it was called
<aeth> AeroNotix: Quicklisp is something that cannot scale but offers a superior experience (i.e. curation and testing that everything works together) to something that would scale
<AeroNotix> I agree
<aeth> The tooling isn't really designed to handle a chaotic anything-goes environment for libraries.
<aeth> Right now the only issue is package name collisions.
<AeroNotix> I feel far more comfortable bringing in dependencies with QL and trusting them to be relatively stable than I do with other platforms
<AeroNotix> but I still do think what would happen if x a c h got bored or hit by a bus
flazh has joined #lisp
jkordani_ has joined #lisp
<phoe> AeroNotix: nowadays anyone can create a QL dist using the code published in the quicklisp repository
<AeroNotix> phoe: I know that :) the above delves into my issues with that a bit
<phoe> so, at least, theoretically, it should be possible to bootstrap a quicklisp-2.0
<phoe> there's also a proof of concept in form of http://ultralisp.org/
<phoe> which is a rolling dist updated whenever a new commit lands in a repository
<phoe> that's as bleeding-edge as you can get.
jkordani has quit [Ping timeout: 246 seconds]
<aeth> phoe: I wonder if there are any Linux distros based on the same principle
<aeth> Linux kernel straight from git!
msb has quit [Ping timeout: 246 seconds]
<jasom> there are linux distros that you update with a "git pull" then "make" but you are pulling from the distros git, not upstream.
fikka has quit [Ping timeout: 245 seconds]
<aeth> I suspect you'd want to use tags or, failing that, user-contributed known-stable commits.
Denommus has quit [Remote host closed the connection]
<aeth> (If you don't just have your own distro git, of course)
msb has joined #lisp
<aeth> I guess a distro git is a way of doing the latter.
<razzy> ultralisp :D the hooks are awesome :D
<aeth> Unless that hasn't updated, it's currently just one organization with the exception of two projects
<aeth> It also doesn't support Gitlab, which is fairly common (mostly gitlab.common-lisp.net rather than gitlab.com)
anewuser has joined #lisp
<razzy> i am hooked, my guts are dragging me through mud
fikka has joined #lisp
Hu0p has joined #lisp
Bike has quit [Ping timeout: 252 seconds]
itruslove has quit [Remote host closed the connection]
beknoll has joined #lisp
asarch has quit [Quit: Leaving]
jmercouris has quit [Remote host closed the connection]
<beknoll> IRC logfile link leads to Not Found?
<aeth> beknoll: because it's poorly formated
<aeth> it's two different urls separated by a ,
<aeth> so it gets parsed by many clients as one URL as https://irclog.whitequark.org/lisp,http://ccl.clozure.com/irc-logs/lisp/
<beknoll> ah, see it now. Thanks.
acolarh has joined #lisp
<beknoll> I'm learning Lisp. Working through Land of Lisp. Read on Stackoverflow that it's not a good primer. Anyone read it? Thoughts?
<phoe> beknoll: Practical Common Lisp is the generally suggested book
<phoe> I haven't read LoL though so I cannot comment on it.
<AeroNotix> beknoll: +1 for Practical Common Lisp. Far superior to Land of Lisp imho. PCL doesn't try to deify CL as practically every other author does
<aeth> You can also write programs and ask for advice in #clschool and you'll find easier or more idiomatic ways to write them.
<beknoll> LoL is cool because of the angle... Make 80s-type text adventure and other games. And there are comics.
<no-defun-allowed> The Haskell comic was great.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<aeth> beknoll: these days you can use something like https://borodust.org/projects/trivial-gamekit/
<aeth> You just need to learn enough to get to the point of being able to use something like that
DGASAU has quit [Ping timeout: 245 seconds]
DGASAU has joined #lisp
<beknoll> @aeth I'll have to check out the #clschool. Tx
<phoe> beknoll: usually the Lisp Learning Kit™ that gets served over here is PCL + Portacle
<beknoll> Lol. Cool. I'll work through PCL. Using portacle now
varjag has quit [Read error: Connection reset by peer]
* edgar-rft always thought that Portable Common Loops was superseded by CLOS
graphene has quit [Remote host closed the connection]
razzy has quit [Ping timeout: 252 seconds]
random-nick has quit [Ping timeout: 244 seconds]
<aeth> edgar-rft: Nowadays we recommend it, though
graphene has joined #lisp
<aeth> edgar-rft: You have to work through it first to appreciate CLOS
<whartung> Portable Common Loops!?!?
bmansurov is now known as bmansurov|ooo
<phoe> whartung: yep, portable common loops
<phoe> an object system for early Common Lisp
<whartung> yes, I knew that.
varjag has joined #lisp
dented42 has joined #lisp
rumbler31 has joined #lisp
housel has quit [Remote host closed the connection]
housel has joined #lisp
<beknoll> So work through loops (?) to appreciate CLOS?
loli has quit [Quit: WeeChat 2.2]
DGASAU has quit [Ping timeout: 252 seconds]
<aeth> no
<aeth> edgar-rft only speaks in jokes
<aeth> The original joke was that "PCL" = "Portable CommonLoops" and "PCL" = "Practical Common Lisp"
rumbler31 has quit [Remote host closed the connection]
<aeth> I then explained what "working through PCL" meant
LiamH has quit [Quit: Leaving.]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
<beknoll> Ah good to know. Sorry to kill the joke. :/
DGASAU has joined #lisp
lavaflow_ has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
<aeth> beknoll: That's fine, you were missing context: that edgar-rft always jokes
<aeth> The joke in Common Lisp would have made perfect sense because you would have been able to use the SLIME inspector to inspect edgar-rft
<AeroNotix> Does SBCL have an API somewhere that I can't find that will allow me to list all mutexes?
<no-defun-allowed> C-c I edgar-rft
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
lavaflow_ has quit [Ping timeout: 245 seconds]
varjag has quit [Ping timeout: 252 seconds]
<jasom> AeroNotix: almost certainly not, since make-mutex is just a constructor for a defstruct
<AeroNotix> jasom: yeah was worried about that
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
orivej has quit [Ping timeout: 272 seconds]
<aeth> I would ask in #sbcl
<AeroNotix> aeth: done
<jasom> It's a userspace mutex, so no syscalls even happen to create a mutex.
<jasom> well on targets that support CAS anyways
kooga has joined #lisp
<edgar-rft> In Lisp history PCL is a well-known acronym for "Portable Common Loops", one of the predecesor OO systems predating CLOS. The fact that Peter Seibel's book "Practical Common Lisp" shares the same acronym is a bad accident, because "Portable Common Loops" was first. But what I originally wanted to point out is that people using acronyms in communication are *begging* for being misinterpreted.
zhlyg` has quit [Ping timeout: 252 seconds]
<AeroNotix> Why *Loops* though? Seems a weird name for an OO system
<aeth> edgar-rft: It's generally called an "OO gauge" or an "OO scale", not an "OO system", and I'm not sure what PCL *or* CLOS has to do with model railway tracks. https://en.wikipedia.org/wiki/OO_gauge
loli has joined #lisp
<AeroNotix> aeth: what you did there, I see it.
<edgar-rft> aeth: and what have model trains to do with the Corel Linux Operating System?
beknoll has quit [Ping timeout: 240 seconds]
<edgar-rft> beknoll gave up :-)
beknoll has joined #lisp
pierpa has joined #lisp
<jasom> edgar-rft: Xandrod purchesed model trains and CLOS
<jasom> s/Xandrod/Xandros
<aeth> But does railway oriented programming work in Common Lisp? https://fsharpforfunandprofit.com/posts/recipe-part2/
<jasom> aeth: all forms of programming work in common lisp, it's pan-paradigm
acolarh has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jasmith has quit [Quit: Leaving]
<pjb> AeroNotix: Lisp Object Oriented Programming System. LOOPS.
<pjb> AeroNotix: Common Lisp Object System. CLOS.
<pjb> AeroNotix: Fine Lisp Addition Via Object Run-time System. Flavors.
<aeth> (afaik the CL equivalent to my link would be something like (lambda (x) (if (null x) nil (foo x))))
<pjb> (lambda (x) (ignore-errors (foo x)))
<aeth> pjb: both
<aeth> pjb: You'd want foo to return NIL on an error instead of throwing an error, but you'd also want to accept NIL as input and return NIL in that case. Except you'd probably want something like :FAILURE instead of NIL
<pjb> Note that lisp already implements rails, with conditions.
<pjb> Only nobody elaborated the type system including conditions and non-local exits.
<pjb> (tagbody (funcall (lambda () (go foo))) foo) ; what is the type of (funcall (lambda () (go foo))) ?
<pjb> of (lambda () (go foo)) I mean?
<aeth> GOTO: The Ultimate Lambda
FreeBirdLjj has joined #lisp
<no-defun-allowed> pretty sure if it will never return it's NIL
robotoad has quit [Quit: robotoad]
<aeth> (You also wouldn't want to ignore it, you'd probably want to log it or something. The important thing is to give it some failure return value rather than just fail.)
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<AeroNotix> pjb: gotcha, thanks
Pixel_Outlaw has joined #lisp
<Shinmera> makomo: beach: each page on the els website contains a footer that says: Authored by Didier Verna www@european-lisp-symposium.org Generated by https://github.com/european-lisp-symposium/els-web
Kevslinger has quit [Quit: Connection closed for inactivity]
zooey has quit [Ping timeout: 256 seconds]
Bike has joined #lisp
zooey has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
eschatologist has quit [Ping timeout: 240 seconds]
eschatologist has joined #lisp
Bike has quit [Client Quit]
Achylles has joined #lisp
Bike has joined #lisp
Achylles has quit [Remote host closed the connection]
robotoad has joined #lisp
Achylles has joined #lisp
fikka has joined #lisp
Essadon has quit [Quit: Qutting]
fikka has quit [Ping timeout: 272 seconds]
Fare has joined #lisp
<makomo> Shinmera: true, but that's because you two are in charge of the webpage and not in charge of the actual organization of the event, right?
<makomo> my point was that Ravenpack seems to be the organizer of 2018, but that's not stated explicitly anywhere
<makomo> Shinmera: oh also, the proceedings pdf lists 2 people as part of the "local chair", but the websites lists only 1
<makomo> website*
<makomo> i guess one could infer who the local organizer is by looking who the people within the "local chair" work for, but i wouldn't know about that if it wasn't for beach who mentioned Ravenpack