monokrom has quit [Remote host closed the connection]
johnjay has joined #lisp
Necktwi has joined #lisp
torbo has joined #lisp
makomo has quit [Ping timeout: 265 seconds]
X-Scale has quit [Ping timeout: 276 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
karlosz has quit [Quit: karlosz]
longshi has quit [Ping timeout: 246 seconds]
smokeink has joined #lisp
oxum_ is now known as oxum
jello_pudding has quit [Quit: Quit]
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
defaultxr has joined #lisp
anewuser has quit [Ping timeout: 268 seconds]
useful_illusion has quit [Quit: useful_illusion]
vms14 has joined #lisp
earl-ducaine has joined #lisp
keep-learning[m] has joined #lisp
earl-ducaine has quit [Ping timeout: 246 seconds]
ax-hack has joined #lisp
wiselord has quit [Read error: Connection reset by peer]
jadedctrl has quit [Quit: WeeChat 2.2]
khisanth_ has quit [Ping timeout: 250 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
khisanth_ has joined #lisp
EvW1 has quit [Ping timeout: 276 seconds]
ebrasca has joined #lisp
earl-ducaine has joined #lisp
ax-hack has quit [Ping timeout: 268 seconds]
space_otter has joined #lisp
poet has joined #lisp
varjag has joined #lisp
varjag has quit [Ping timeout: 250 seconds]
libertyprime has joined #lisp
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
pjb has quit [Ping timeout: 276 seconds]
minion has quit [Remote host closed the connection]
minion has joined #lisp
clothespin has joined #lisp
clothespin_ has joined #lisp
poet has quit [Ping timeout: 246 seconds]
gaqwas has quit [Ping timeout: 265 seconds]
ahungry has joined #lisp
<ebrasca>
Is there some method to control GC?
<Bike>
your implementation might expose an interface.
<ebrasca>
I don't see any in Mezzano.
<ebrasca>
Is there some cl stantard for GC control?
<Bike>
no, the standard doesn't even mandate garbage collection.
<Bike>
there is a trivial-garbage portability library, but i don't think it covers mezzano.
poet has joined #lisp
poet has quit [Client Quit]
pjb has joined #lisp
<ebrasca>
I think I need to control GC to manage properly my page cache in Mezzano.
<ebrasca>
How can CL work without GC?
<Bike>
not for very long, mainly
<no-defun-allowed>
It probably can't, honestly, but the option is there.
<pjb>
Depends. Lisp Machines were rebooted only weekly. They could work that long without a GC…
<Bike>
or with real aggressive block optimization, iunno
earl-ducaine has quit [Ping timeout: 276 seconds]
clothespin__ has joined #lisp
<drmeister>
This question is a bit off topic - but I want to use flock(2) to control generation of fasls in clasp compile-file.
<drmeister>
Has anyone used flock(2) before?
clothespin has quit [Ping timeout: 246 seconds]
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
<drmeister>
I've got questions about opening the file, cleaning it up and doing that while maintaining the lock.
Arcaelyx has quit [Read error: Connection reset by peer]
Arcaelyx has joined #lisp
payphone` has quit [Ping timeout: 240 seconds]
clothespin__ has quit [Ping timeout: 250 seconds]
clothespin_ has quit [Ping timeout: 250 seconds]
Bike has quit [Quit: Lost terminal]
clothespin has joined #lisp
clothespin_ has joined #lisp
shifty has quit [*.net *.split]
Guest55714 has quit [*.net *.split]
Lord_of_Life has quit [*.net *.split]
ebrasca has quit [*.net *.split]
grumble has quit [*.net *.split]
dddddd has quit [*.net *.split]
sauvin has quit [*.net *.split]
orivej has quit [*.net *.split]
SaganMan has quit [*.net *.split]
Posterdati has quit [*.net *.split]
froggey has quit [*.net *.split]
defaultxr has quit [*.net *.split]
fengshaun has quit [*.net *.split]
jlarocco has quit [*.net *.split]
MinnowTaur has quit [*.net *.split]
adolby_ has quit [*.net *.split]
theBlackDragon has quit [*.net *.split]
patrixl has quit [*.net *.split]
Colleen has quit [*.net *.split]
davr0s_ has quit [*.net *.split]
Blukunfando has quit [*.net *.split]
sammich has quit [*.net *.split]
rotty has quit [*.net *.split]
drainful has quit [*.net *.split]
thijso has quit [*.net *.split]
Kaisyu7 has quit [*.net *.split]
remexre has quit [*.net *.split]
bacterio has quit [*.net *.split]
kark has quit [*.net *.split]
nchambers has quit [*.net *.split]
moon-child has quit [*.net *.split]
loke has quit [*.net *.split]
v0|d has quit [*.net *.split]
niceplace has quit [*.net *.split]
eagleflo has quit [*.net *.split]
cracauer has quit [*.net *.split]
zigpaw has quit [*.net *.split]
wooden has quit [*.net *.split]
Xach has quit [*.net *.split]
flip214 has quit [*.net *.split]
ssake has quit [*.net *.split]
rumpelszn has quit [*.net *.split]
payphone has quit [*.net *.split]
alandipert has quit [*.net *.split]
zymurgy has quit [*.net *.split]
Mon_Ouie has quit [*.net *.split]
micro has quit [*.net *.split]
Intensity has quit [*.net *.split]
nightfly has quit [*.net *.split]
copec has quit [*.net *.split]
vsync has quit [Ping timeout: 276 seconds]
vsync_ has joined #lisp
<beach>
Good morning everyone!
earl-ducaine has joined #lisp
pfdietz27 has quit [Ping timeout: 260 seconds]
<equwal>
Good morning beach!
ahungry has quit [Remote host closed the connection]
earl-ducaine has quit [Ping timeout: 276 seconds]
poet has joined #lisp
sauvin has joined #lisp
zymurgy has joined #lisp
earl-ducaine has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
sauvin has joined #lisp
space_otter has quit [Remote host closed the connection]
oxum has quit [Remote host closed the connection]
space_otter has joined #lisp
torbo has quit [Remote host closed the connection]
gaqwas has joined #lisp
oxum has joined #lisp
vs has joined #lisp
gravicappa has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
oxum has quit [Ping timeout: 265 seconds]
oxum has joined #lisp
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
akoana has joined #lisp
clothespin__ has joined #lisp
quazimodo has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
clothespin has quit [Ping timeout: 245 seconds]
vs has quit [Ping timeout: 265 seconds]
hostile has joined #lisp
brown121407 has quit [Ping timeout: 252 seconds]
brown121407 has joined #lisp
oxum_ has joined #lisp
oxum has quit [Read error: Connection reset by peer]
oxum_ has quit [Remote host closed the connection]
oxum has joined #lisp
Necktwi has quit [Ping timeout: 265 seconds]
enrio has joined #lisp
Inline has quit [Quit: Leaving]
clothespin_ has quit [Ping timeout: 250 seconds]
clothespin has joined #lisp
oxum has quit [Remote host closed the connection]
vsync_ is now known as vsync
Bourne has joined #lisp
oxum has joined #lisp
libertyprime has quit [Quit: leaving]
davr0s_ has joined #lisp
davr0s has joined #lisp
davr0s has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
<pjb>
drmeister: flock works on the file descriptor wholesale (ie. the flock is in the i-node). So there should be no problem cleaning the file and rewriting it with the lock.
<davr0s_>
any news in "lisp land"
vlatkoB has joined #lisp
<beach>
davr0s_: Lots! McCLIM is being worked on daily, and it is getting very good.
<davr0s_>
thanks i must google..
<davr0s_>
i haven't followed anything in lisp circles for a long time
<no-defun-allowed>
I had just gotten the server for my distributed hash-table/object store mismash working a couple of hours ago, but McCLIM is cooler.
<beach>
davr0s_: Submission dates for ELS2020 have been announced.
<davr0s_>
ok i see it's a UI kit of sorts?
<davr0s_>
i did always think lisp macros would be pretty good at that sort of thing
<beach>
?
<no-defun-allowed>
Yes, it is an implementation of the Common Lisp Interface Manager standard, which does graphical interface things.
<beach>
CLIM is an excellent example of the use of standard classes and generic functions. There are *some* macros of course.
vms14 has quit [Remote host closed the connection]
<no-defun-allowed>
And sure, they're good at making layouts. I hated doing those when I had begun learning GUIs in macroless languages.
<beach>
davr0s_: At the level of implementing Common Lisp, jackdaniel is working on the ECL compiler, and he is giving an invited talk about it at ELS.
<beach>
davr0s_: And phoe has started maintaining CCL.
<davr0s_>
CCL , searching yields non lispy resupts.. what is it?
<no-defun-allowed>
(Then I'd like to guess the whole Electron thing is cause HTML is declarative, and so is much better at describing most layouts. Greenspun's tenth law and all.)
<beach>
davr0s_: scymtym is working on Eclector and the library for Concrete Syntax Trees. He has also worked on McCLIM, and especially on Clouseau.
<beach>
davr0s_: I guess you must have been out for some time.
<davr0s_>
i should add: i've only really dabled with lisps.. the most i've written is elisp emacs customizations, lol. years ago i went on some "new language" quest
<davr0s_>
i liked some aspects of some lisps (CL and clojure) but never really stuck with them and moved on
MichaelRaskin has quit [Quit: MichaelRaskin]
<beach>
OK, so I should start from the beginning. This channel is dedicated to Common Lisp which is a language that was standardized in 1994.
<davr0s_>
right
<davr0s_>
common lisp, not the other dialects
<beach>
It has several unique features, of which CLOS is a major one. It allows the user to define generic functions and classes.
skeuomorf has left #lisp [#lisp]
<davr0s_>
never actually touched CLOS but i'm aware it supports multimethods, interestingly
<beach>
This feature is part of what makes it possible for CLIM/McCLIM to be designed in layers where the application programmer can adapt how it works in each layer.
<beach>
Not only does it allow for multiple dispatch, it also allows for different method combinations with auxiliary methods.
shka_ has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
keep_learning has joined #lisp
keep_learning has quit [Client Quit]
enrio has quit [Ping timeout: 252 seconds]
ealfonso has joined #lisp
Colleen has joined #lisp
flamebeard has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
oxum_ has joined #lisp
oxum has quit [Remote host closed the connection]
oxum_ has quit [Remote host closed the connection]
Kevslinger has quit [Quit: Connection closed for inactivity]
ggole has joined #lisp
loskutak has joined #lisp
oxum has joined #lisp
scymtym has quit [Ping timeout: 276 seconds]
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
ealfonsoi has joined #lisp
igemnace has joined #lisp
ealfonso has quit [Ping timeout: 276 seconds]
hostile has quit [Quit: Leaving]
ealfonsoi is now known as ealfonso
<boeg>
Can somebody explain the me the use of @ in a macros? Or link me to something on it
makomo has joined #lisp
jprajzne has joined #lisp
<phoe>
boeg: if X is (3 4 5), `(1 2 ,x) is (1 2 (3 4 5)) but `(1 2 ,@x) is (1 2 3 4 5)
oxum has quit [Remote host closed the connection]
<phoe>
is that the use of @ that you seek? That character doesn't usually occur alone in standard CL.
<boeg>
phoe, well, to give you context, it's explained as if there a multiple "bodies" for example, so you do ,@body to include the "body" of the function. But then I also see this: ,@(mapcar #'cdr p) which I'm not sure I understand. The ,@body thing makes sense
<boeg>
I don't think of it being "expanded" to its value before ,@ did its things
<boeg>
now it makes sense
<boeg>
didn't*
<boeg>
thank you, jackdaniel and phoe
varjag has joined #lisp
<phoe>
the , part of the backquote makes sure it is "expanded" to its value
<phoe>
the @ part ensures to get rid of one level of its list structure
<boeg>
yes, now its clear :)
Duuqnd has joined #lisp
oxum has joined #lisp
scymtym has joined #lisp
Cymew has joined #lisp
karlosz has joined #lisp
longshi has joined #lisp
<pjb>
There's no part. There are 3 different syntax that are available inside a backquote expression: , ,@ and ,. that's all.
<pjb>
And it's totally unrelated to macros!
<pjb>
(besides, macros are just functions like any other function, so anything you could use in macros, you could use in normal functions).
count3rmeasure has joined #lisp
keep_learning has joined #lisp
enrio has joined #lisp
longshi has quit [Ping timeout: 276 seconds]
vs1 has joined #lisp
<boeg>
pjb: interesting, thank you
enrio has quit [Ping timeout: 268 seconds]
william1 has joined #lisp
william1 has quit [Client Quit]
earl-ducaine has quit [Ping timeout: 268 seconds]
william1 has joined #lisp
enrio has joined #lisp
hhdave has joined #lisp
ealfonso has quit [Ping timeout: 265 seconds]
loskutak has quit [Ping timeout: 265 seconds]
rgherdt has joined #lisp
space_otter has quit [Remote host closed the connection]
Davd33 has joined #lisp
loskutak has joined #lisp
Davd33 has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 252 seconds]
loskutak has quit [Ping timeout: 245 seconds]
enrio has quit [Read error: Connection reset by peer]
enrio has joined #lisp
enrioog has joined #lisp
<aeth>
oh, wow, I've never seen ,. before
<aeth>
it's basically a nconc, apparently
smokeink has quit [Remote host closed the connection]
enrioog has quit [Read error: Connection reset by peer]
enrio has quit [Ping timeout: 265 seconds]
smokeink has joined #lisp
enrioog has joined #lisp
oxum_ has joined #lisp
oxum has quit [Ping timeout: 250 seconds]
Posterdati has joined #lisp
flamebeard has quit [Remote host closed the connection]
flamebeard has joined #lisp
oxum_ has quit [Remote host closed the connection]
oxum has joined #lisp
flamebeard has quit [Remote host closed the connection]
flamebeard has joined #lisp
davd has joined #lisp
loskutak has joined #lisp
wooden has joined #lisp
loke has joined #lisp
Xach has joined #lisp
micro has joined #lisp
flip214 has joined #lisp
cracauer has joined #lisp
sammich has joined #lisp
ssake has joined #lisp
jlarocco has joined #lisp
thijso has joined #lisp
theBlackDragon has joined #lisp
wooden has quit [Changing host]
MinnowTaur has joined #lisp
wooden has joined #lisp
zigpaw has joined #lisp
froggey has joined #lisp
shifty has joined #lisp
copec has joined #lisp
nightfly has joined #lisp
bacterio has joined #lisp
ebrasca has joined #lisp
eagleflo has joined #lisp
rotty has joined #lisp
froggey has quit [Changing host]
froggey has joined #lisp
<phoe>
yes
payphone has joined #lisp
SaganMan has joined #lisp
Kaisyu7 has joined #lisp
bacterio has quit [Changing host]
bacterio has joined #lisp
Mon_Ouie has joined #lisp
v0|d has joined #lisp
<phoe>
pretty useless because it's equivalent to ,@ but mutates things instead of creating new ones - efficiency or something?
defaultxr has joined #lisp
earl-ducaine has joined #lisp
SaganMan is now known as Guest64260
<phoe>
it must be efficiency, because I cannot imagine using backquote for side effects
nchambers has joined #lisp
orivej has joined #lisp
adolby has joined #lisp
rumpelszn has joined #lisp
fengshaun has joined #lisp
remexre has joined #lisp
drainful has joined #lisp
kark has joined #lisp
Lord_of_Life has joined #lisp
niceplace has joined #lisp
jonatack has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
<tfb>
phoe: I think efficiency, yes, because nothing says it *must* use nconc I think.
oxum has quit [Remote host closed the connection]
stux|RC has quit [Read error: Connection reset by peer]
enrioog has quit [Read error: Connection timed out]
enrioog has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
oxum has joined #lisp
stux|RC has joined #lisp
<phoe>
tfb: > Anywhere ``,@'' may be used, the syntax ``,.'' may be used instead to indicate that it is permissible to operate destructively on the list structure produced by the form following the ``,.'' (in effect, to use nconc instead of append).
<phoe>
if ,@ is supposed to be appendlike then ,. is supposed to be nconclike
<phoe>
so their uses must be equivalent to calling the respectivese functions
<p_l>
BTW, anyone using CCL on latest MacOS? Seems to bring issues
<phoe>
p_l: which issues
<tfb>
phoe: yes, 'may' and 'permissable' is the point. Not 'must': (nconc a b) *must* modify a if it's a non-null list, but ,. only may use nconc.
pilne has quit [Quit: Beware of programmers who carry screwdrivers.]
<phoe>
we're aware that Catalina causes things to break, newest Xcode causes things to break, etc..
<tfb>
phoe: so, in particular, I don't think there is a guarantee that (let ((a (list 1 2))) `(0 ,.a 3) a) is (1 2 3)
jonatack has quit [Ping timeout: 276 seconds]
<p_l>
phoe: yeah, the big problem is that there's not enough bug reports
<p_l>
and an even bigger problem is that I can't catch something reportable
oxum has quit [Remote host closed the connection]
<p_l>
things fail to display properly or act properly but don't result in errors in code
rotucer has joined #lisp
oxum has joined #lisp
<phoe>
tfb: well then, in that case ,. must NOT be used for side effects if it may or may not use nconc
<phoe>
p_l: there is little doable if there are no bug reports
<p_l>
phoe: kinda hoping to coax more people to speak on them :)
<p_l>
since from my side, it feels like being gaslighted
<p_l>
something is /subtly/ wrong but doesn't leave obvious trace to follow
<tfb>
phoe: yes, I think that's right. Using ,. means 'I'm OK if you (the implementation) smash this list if you want to and you decide it's worth doing'
<p_l>
and I know that OpusModus folks got some serious errors but I haven't seen anything reported :(
oxum has quit [Remote host closed the connection]
p9fn has quit [Ping timeout: 250 seconds]
oxum has joined #lisp
<tfb>
p_l: I am getting ccl build errors on 10.14 now even. I'll have a look and report it on the mailing list if it looks reproduceable
Lord_of_Life_ has joined #lisp
enrioog has quit [Read error: Connection reset by peer]
Lord_of_Life has quit [Ping timeout: 250 seconds]
oxum has quit [Remote host closed the connection]
enrioog has joined #lisp
Lord_of_Life_ is now known as Lord_of_Life
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
<phoe>
p_l: we really need reports from them in that case.
cosimone has joined #lisp
rotucer has quit [Quit: Quit]
zotan has quit [Quit: ZNC 1.6.5+deb1+deb9u2 - http://znc.in]
wiselord has joined #lisp
zotan_ has joined #lisp
davd has quit [Ping timeout: 276 seconds]
ironbutt has joined #lisp
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
oxum has joined #lisp
froggey has quit [Quit: Reconnecting]
froggey has joined #lisp
je4i has joined #lisp
oxum has quit [Remote host closed the connection]
zotan has joined #lisp
zotan_ has left #lisp ["Konversation terminated!"]
<jmercouris>
the author has in my mind, made a compelling argument against arrays
<phoe>
> Of course the difference gets bigger if the list gets longer, but typically there will be also much more processing of the data than simple increments.
<Shinmera>
Arguments for implementation simplicity have not much place in a Common Lisp chatroom, I would say.
kritixilithos has joined #lisp
<phoe>
if you disregard access speed and memory usage, it is obvious that arrays are useless
<phoe>
and this post disregards access speed and memory usage, so it does arrive at that exact conclusion
<phoe>
> If there is a choice between arrays or lists, lists will clearly win.
<phoe>
this is as opinionated as an online post can get, other than you can easily implement lists with arrays of length 2 but you can't do it the other way
<phoe>
> Sure, there are typical cases like image rasterization. But when did you the last time implement Bresenham's line algorithm in application programming? Instead, you resort to a library, or write it in C or even assembly if a library is not available.
<eeeeeta>
🤔
<phoe>
"let me pretend that arrays aren't useful by forcing you to program in non-picolisp whenever array programming is actually required
<phoe>
"
<eeeeeta>
"our language doesn't have feature X, but it's fine, nobody wants to implement feature X anyway"
<phoe>
> In other cases - like two-dimensional maps - there are better ways. Look for example how the board in the PicoLisp chess program (and other games and many rosetta code solutions) is implemented with direct connection attributes (north, west etc.) between the fields instead of integer arithmetics for array indexes.
<jackdaniel>
picolisp has its niche and these points may be valid for picolisp, yet discussing picolisp and its niche belongs somewhere else ,-)
<phoe>
right - tl;dr that post is silly to me
<jackdaniel>
it is enough to say that common lisp has both lists and arrays and if someone decides that lists fit their needs then go for it!
* jackdaniel
waits for a CDR proposing conformant array displacement
<jackdaniel>
conformal
<jackdaniel>
damn
<eeeeeta>
a what now? :P
<jackdaniel>
conformal displacement is a kind of array displacement which respects original array dimensions
<jackdaniel>
right now if you displace at the array, the displaced array treats original memory as a single chunk, in case of conformal displacement you may have a slice of the original array
<eeeeeta>
jackdaniel: oh right, so it's essentially just array slicing (but for multidimensional arrays in row-major order)?
<jackdaniel>
I don't understand the part in parentheses :( it is displacing an array so the array you displace to is not treated as one-dimensional sequence
<eeeeeta>
hmmm
pfdietz has joined #lisp
<eeeeeta>
oh right I wasn't looking at coredump's answer, d'oh
<eeeeeta>
I understand it now
<eeeeeta>
heh, that's quite a niche feature >_<
<jackdaniel>
that's the most obvious thing (to me!) when I think about displacing arrays
<jackdaniel>
but sure, it is niche, still very cool though
<eeeeeta>
I've never encountered displaced arrays before
<eeeeeta>
but they seem pretty cool as a feature
Duuqnd has quit [Ping timeout: 248 seconds]
Bike has joined #lisp
<jackdaniel>
important note: displaced arrays *are* part of CL, conformal displacement is not
luna_is_here has joined #lisp
<eeeeeta>
ah right
akoana has left #lisp ["Leaving"]
flamebeard has quit [Remote host closed the connection]
niklas has quit [Remote host closed the connection]
oxum has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
oxum has joined #lisp
ljavorsk has quit [Ping timeout: 248 seconds]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
flamebeard has joined #lisp
gabiruh has joined #lisp
earl-ducaine has joined #lisp
flamebeard has quit [Remote host closed the connection]
flamebeard has joined #lisp
<jmercouris>
I just figured it was interesting for discussion since CL did make the choice keep in arrays
<phoe>
CL aims to be a practical language
<phoe>
and limiting the programmer's choices is hardly a practical thing to do
<jmercouris>
phoe: it *may* be a practical thing to do if limiting the choice results in better throughput
<phoe>
throughput for what exactly
<jmercouris>
programs over time
<phoe>
it's a bold claim that Lisp programs would happen quicker if we removed arrays from the language
dddddd has joined #lisp
<jmercouris>
it would be, if I had made it
<phoe>
good! you can write your Lisp programs without using any non-string arrays then
<pfdietz>
CL is also a product of its time (decades ago) and process (standardization of existing implementations). A clean sheet specification might do things differently, but also might be stillborn from lack of interest.
<p_l>
Interesting thing for me is that displaced arrays were considered controversial
<Xach>
lexical scope was controversial also
Inline has joined #lisp
<pfdietz>
Displaced arrays feel ok to me, but I would rather have a language where something like them could be added as a user extension, while maintaining good performance.
<Bike>
i don't think displaced arrays maintain good performance usually
<phoe>
they introduce one level of indirection for every displacement
<phoe>
and you can nest displacement anyway, sooo
<pfdietz>
I mean, an implementation in which such extensions can be added, while maintaining good performance of the "fast" versions of things.
<pfdietz>
I also dream of a CL where operations on standard objects are as fast as operations on structure objects.
<Bike>
seems impossible without adding similar redefinability constraints to the relevant standard classes
<Bike>
though things could definitely be faster than they are
<jackdaniel>
using lists to represent arrays of objects is a verbatim example from Norvig "style guide" of practices which flush performance down the toilet
<phoe>
pfdietz: I think you'd need to simplify the accessor protocol for cases where no custom CLOS behaviour is specified and so accessor calls can be simplified to standard-instance-access. And then be able to recompile all functions that use these accessors whenever a class definition changes.
<phoe>
A Lisp system could do that, in theory.
<phoe>
;; Or you could define DEFSTRUCT using DEFCLASS - both are going to have the same speed in that case, so your constraint will be satisfied.
<Bike>
beach's thing should make it possible
<Bike>
but it requires a lot of bookkeeping so i haven't tried it yet
<Bike>
should make it possible even when there is custom behavior, really
<pfdietz>
The challenge is what you do when stack frames from the recompiled code are on the stack, or in closures, when the redefinition occurs. The compiler would have to arrange things so that the code could be hot swapped without invalidating the frames.
oxum_ has joined #lisp
oxum_ has quit [Remote host closed the connection]
<Bike>
i think if you redefined a class while in a method specialized on that class that uses its accessors you'd probably lose
<jackdaniel>
the approach beach proposes uses a two-pointer structure for object where first pointer addresses the instance
<Bike>
hmmmmm
<jackdaniel>
and the second one the up-to-date class definition
<jackdaniel>
and they may be compared with a stamp
<Bike>
well, no, you'd still have objects with the old version of the class, i suppose... it might work
<jackdaniel>
(given I understand it correctly)
oxum has quit [Ping timeout: 246 seconds]
<Bike>
every class has a number ("stamp"). when you redefine a class it gets a new stamp. Each instance has a stamp and also a reference to the class. An instance is obsolete if the stamp in the instance doesn't match the stamp in its class.
<scymtym>
Bike: i think beach's plan is to hoist the rack access which would result in using the old version. have to make sure it is reloaded eventually, though - similar to safepoints
<Bike>
well, has beach has it now, any slot access in a method would be through a generic function, so it would just dispatch there and update the instance
<Bike>
as beach*
ironbutt has quit [Quit: Leaving]
oni-on-ion has joined #lisp
<Bike>
so it's perfectly safe but you do a lot of dispatching
<Bike>
(which is ok, since dispatching is pretty fast, but could possibly be better)
<Xach>
I don't want to jinx it but I think my quicklisp build server problems are behind me.
<pfdietz>
[server explodes]
poet has quit [Ping timeout: 268 seconds]
poet has joined #lisp
<phoe>
Xach: how do you solve them?
earl-ducaine has quit [Ping timeout: 248 seconds]
ljavorsk has joined #lisp
zmv has quit [Read error: Connection reset by peer]
<pfdietz>
I think one could use a one-pointer solution by allocating objects of a given class on their own pages, then protecting the page after redefinition. Accesses that cause traps would cause updates of pointers, or they could be updated at GC time.
fookara has joined #lisp
<pfdietz>
Many games can be played with the virtual memory machinery.
oxum has quit [Ping timeout: 265 seconds]
<phoe>
Is such detailed information about virtual memory available for a Unix process? Like, execute code when a single page fault has occurred?
<phoe>
And not a single one, but rather, a fault on a specific page?
<ggole>
The signal handler gets the faulting address, so that should be possible
brown121407 has quit [Read error: Connection reset by peer]
<ggole>
Probably not portably
brown121407 has joined #lisp
<phoe>
but the signal handler is set by the OS and not by the application - or is it? if the latter is the case, then a Lisp implementation would be able to do that
<ggole>
See sigaction(2)
rgherdt has quit [Remote host closed the connection]
<ggole>
This is actually used by some implementations of some languages, although not in the way that you describe
<Bike>
posix allows si_addr to be inaccurate, but hopefully in practice it's fine
<ggole>
iirc some JVMs implement null-pointer dereferences as a signal handler seeing accesses to page zero and converting them to an exception
<Bike>
implementations install signal handlers already, it's how if you manage to segfault sbcl you can see what address the fuckup was at, and go back to the repl
<pfdietz>
Also for implementing write barriers.
<pfdietz>
I understand the zgc garbage collector has tag bits in pointers that are effectively masked out by mapping all the possible addresses for them to the same physical page.
<ggole>
There was an interesting paper/talk on memory compaction (intended for C, iirc) without relocation that used a similar trick
smazga has joined #lisp
<pfdietz>
I saw that. Interleaving virtual pages on the same physical page if none of the allocated objects overlap.
<phoe>
> The main difference between Segmentation Fault and Bus Error is that Segmentation Fault indicates an invalid access to a valid memory, while Bus Error indicates an access to an invalid address.
<Bike>
pfdietz: it looks like that didn't actually pan out and you use userfaultfd instead
vms14 has quit [Remote host closed the connection]
<pfdietz>
2013 is old, I guess.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
flamebeard has quit []
<Bike>
sbcl just uses segv
poet has quit [Ping timeout: 248 seconds]
jonatack has joined #lisp
pjb has quit [Remote host closed the connection]
jfrancis has quit [Ping timeout: 245 seconds]
pjb has joined #lisp
heisig has quit [Quit: Leaving]
adolby has quit [Ping timeout: 252 seconds]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
pjb has quit [Remote host closed the connection]
pjb` has joined #lisp
je4i has quit [Ping timeout: 264 seconds]
adolby has joined #lisp
moon-child has joined #lisp
ljavorsk has quit [Ping timeout: 248 seconds]
MightyJoe has quit [Ping timeout: 268 seconds]
cyraxjoe has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
oxum has quit [Ping timeout: 268 seconds]
varjag has joined #lisp
shangul has joined #lisp
loskutak has quit [Ping timeout: 276 seconds]
rgherdt has joined #lisp
<p_l>
phoe: page fault is segfault
<p_l>
sigbus is for things like unaligned access on system that doesn't support it
<shangul>
Xach, When trying to use (quicklisp-quickstart:install) I get 503. What to do?
shka_ has quit [Ping timeout: 265 seconds]
je4i has joined #lisp
gxt has joined #lisp
jmercouris has quit [Remote host closed the connection]
amerigo has quit [Quit: Connection closed for inactivity]
<pjb`>
jmercouris: I would bet that even picolisp has (elt list index). ACL2 (which is more a theorem proven than a programming language) also doesn't have arrays, and use lists to represent them, but that's only in the purpose of proving theorems. Other languages such as Python don't have "arrays", but their lists are actually arrayss. You could (picolisp could, if it was a serious implementation) implement lists as arrays when pos
<pjb`>
and necessary. For example, on Lisp Machines, there was automatic cdr-coding, which in effect transformed lists into vectors (and sublists even!), which spared memory, and made possible O(1) accesses for functions such as elt.
je4i has quit [Ping timeout: 264 seconds]
<Bike>
well, it has nth
pjb` has quit [Quit: rename]
pjb has joined #lisp
cosimone has quit [Quit: Terminated!]
oxum has joined #lisp
hostile has joined #lisp
kritixilithos has quit [Ping timeout: 260 seconds]
amerlyq has quit [Quit: amerlyq]
hostile has quit [Client Quit]
hostile has joined #lisp
hhdave has quit [Quit: hhdave]
DGASAU has quit [Read error: Connection reset by peer]
<Xach>
shangul: hmm, do you get it if you try again?
kritixilithos has joined #lisp
ljavorsk has joined #lisp
DGASAU has joined #lisp
<ggole>
Cdr-coding doesn't make O(1) access possible because cdr-coded conses aren't always contiguous, only often.
<ggole>
It might be possible for the encoding to support skipping the contiguous part in one step - although I don't think the historical implementations did that.
<pjb>
right, it's missing a chunk length…
smokeink has joined #lisp
stzsch has quit [Ping timeout: 276 seconds]
ljavorsk has quit [Ping timeout: 248 seconds]
vaporatorius has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
slyrus__ has quit [Ping timeout: 265 seconds]
Kevslinger has joined #lisp
jfrancis has joined #lisp
earl-ducaine has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
cosimone has joined #lisp
smazga has quit [Quit: leaving]
slyrus__ has joined #lisp
earl-ducaine has joined #lisp
slyrus_ has quit [Ping timeout: 246 seconds]
buffergn0me has joined #lisp
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
smokeink has quit [Remote host closed the connection]
vs1 has joined #lisp
<fe[nl]ix>
jackdaniel: please publish pre-release binaries often
<fe[nl]ix>
that way we can use those in our CI setups and do some QA for you
fookara has quit [Remote host closed the connection]
<jackdaniel>
fe[nl]ix: what is the context? I'm not publishing prebuilt ecl binaries, mainly because ecl is dynamically linked with various system libraries
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
<fe[nl]ix>
the context is CI
<jackdaniel>
and that would lead to multiple support requests: my ecl doesn't start, because glibc bla bla, or - can't start ecl because libgc is missing
<fe[nl]ix>
basically all my projects fail on ECL because the only evailable binary is too old
<jackdaniel>
in other words that would be counterproductive. otoh building ecl is as "easy" as ./configure && make && make install
<jackdaniel>
if I may ask, where did you get prebuilt ecl binary for ci?
<jackdaniel>
(if not from the system repositories)
<jackdaniel>
in theory we could build a static binary, but that would be by no means representative functionality-wise
<fe[nl]ix>
I think Luis might have compiled it
shifty has quit [Ping timeout: 276 seconds]
<fe[nl]ix>
if you get support requests you can easily WONTFIX, etc...
oni-on-ion has quit [Remote host closed the connection]
alandipert has joined #lisp
<jackdaniel>
sure, my point is that the average case is that it won't work, what will give a very bad impression. otoh of course I'd appreciate additional qa
<jackdaniel>
I mean that i.e if I build ecl on my desktop and publish it, it will be quite likely, that it won't work on your CI
<fe[nl]ix>
it's easy to setup a Ubuntu chroot
* scymtym
usually builds the implementation as part of the CI process
<fe[nl]ix>
basically all CI environments are using Ubuntu 18.04 LTS
<jackdaniel>
fe[nl]ix: isn't it an option to get a source and compile it automatically?
<fe[nl]ix>
no because the free tier has low CPU time limits
space_otter has joined #lisp
<fe[nl]ix>
fine for most projects but compiling ECL would overrun
<buffergn0me>
fe[nl]ix: Is this GitHub specific?
cosimone has quit [Quit: Quit.]
<jackdaniel>
actually ecl compilation time is not that long (unlike the time ecl compiler + gcc take to compile things). either way, I'll think about it; we are closing to the release btw
<fe[nl]ix>
Travis has a hard 10 minute limit
<jackdaniel>
accidently that coincides with something I want to do for a long time -- set up ci for ecl itself, publishing artifacts shouldn't be a problem when I get to it, the problematic part is the "when I get to it"
cosimone has joined #lisp
<jackdaniel>
n.b, ECL compilation time on my host: ./make.sh /tmp/xxx 118,44s user 7,35s system 147% cpu 1:25,42 total
<jackdaniel>
below 2 minutes
<jackdaniel>
fe[nl]ix: ^ (on default settings) -- I suppose travis has slower machines though
orivej has quit [Ping timeout: 245 seconds]
gxt has quit [Ping timeout: 260 seconds]
igemnace has quit [Ping timeout: 246 seconds]
gravicappa has quit [Ping timeout: 265 seconds]
kritixilithos has quit [Quit: quit]
rpg has joined #lisp
<phoe>
disposable VMs, so I do not expect them to be very fast
je4i has joined #lisp
<phoe>
fe[nl]ix: I saw you pushed a commit into split-sequence - did it fix the warnings in question? (also, sorry for screwing up the function order during making the rewrite)
sauvin has quit [Ping timeout: 276 seconds]
igemnace has joined #lisp
doublex__ has joined #lisp
smokeink has joined #lisp
doublex_ has quit [Ping timeout: 250 seconds]
payphone` has joined #lisp
longshi has joined #lisp
buffergn0me has quit [Ping timeout: 250 seconds]
<fe[nl]ix>
phoe: disposable VMs with one virtual CPU and overall very slow
zmv has quit [Read error: Connection reset by peer]
gxt has joined #lisp
hiroaki has joined #lisp
gareppa has joined #lisp
gxt has quit [Client Quit]
<phoe>
fe[nl]ix: OK, I'll do that
<phoe>
Xach: thank is an honor, thank you
bitmapper has quit [Ping timeout: 245 seconds]
brown121407 has quit [Ping timeout: 246 seconds]
brown121407 has joined #lisp
<jackdaniel>
processing results: honor you
hostile has quit [Quit: Leaving]
vms14 has joined #lisp
efm has quit [Remote host closed the connection]
efm has joined #lisp
cosimone has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
brown121407 has joined #lisp
ljavorsk has joined #lisp
<pjb>
ebrasca: ISTR somebody rewrote the core git in CL…
<vms14>
there is a difference in performance while using let vs let*?
<pjb>
nope.
<jackdaniel>
no, you need to compute initialization forms anyway
<jackdaniel>
(i.e you can't parallelize them in case of LET in Common Lisp, so it is only about the names in the environment )
<jackdaniel>
n.b lparallel gives you parallel let afair
<vms14>
and if I'm using let* when I only need one of those "variables" being with let* and the others doesn't matter, it's more "correct" using two lets?
<jackdaniel>
no, some people prefer it though
brettgilio has joined #lisp
<jackdaniel>
other side of the coin is that using single let* reduces unnecessary nesting
<vms14>
it has two mapcars and two loops to generate the list
<vms14>
xD
<jackdaniel>
can't you call get-frame inside the inner loop?
<jackdaniel>
(loop for i from 0 to 3 do (loop for j from 0 to (1- fn) (get-frames whatever))
<jackdaniel>
do after fn)
<vms14>
hmm idk, but seems logic
<vms14>
what I'm doing is first generate a bunch of lists with lists of (x y)
<vms14>
4 lists with 3 lists, being the 4 lists the directions of the spriteset, and the 3lists the frames of every direction
<eeeeeta>
"code smell problems? just beat it with the MACROEXPAND-1 hammer until it all looks the same"
<vms14>
so the loops are creating stuff like ((0 0) (0 24) (0 48))
<vms14>
and the mapcar generate two pixmaps, one with the sprite and another with the mask
<jackdaniel>
once I saw a guy, who saw a lad, who saw two guys who were observing guy going down the street, and that guy was talking with a lad about number of guys who were observing the first lad
<vms14>
:O
<jackdaniel>
in other words, I'm lost with your explanation ;__)
<vms14>
yeah, sorry
<vms14>
nvm, it works, so meh
<vms14>
well I have to test it with different width and height to see if it really works fine
<Xach>
drmeister: it's broken right now and i'm going to have to drop it from quicklisp soon if it isn't fixed. i'm not sure if anyone will notice/care.
<Xach>
the author has not responded to bug reports in a while
jfb4_ has quit [Ping timeout: 245 seconds]
jfb4 has joined #lisp
Arcaelyx has joined #lisp
atgreen has joined #lisp
poet has joined #lisp
khisanth_ has quit [Ping timeout: 268 seconds]
varjag has quit [Ping timeout: 268 seconds]
igemnace has quit [Read error: Connection reset by peer]