<White_Flame>
is (stream-external-format *standard-output*) supposed to not crash in SLIME?
<mfiano>
I don't use SLIME, but it seems to return :UTF-8 on Sly
<no-defun-allowed>
srji: Somewhat late, but SETF came from SETFQ, which was something like "set function quoted" as the "function" place you'd set would appear quoted like SETQ.
Alfr has quit [Remote host closed the connection]
Alfr has joined #lisp
<lotuseater>
no-defun-allowed no I remember :)
Lycurgus has quit [Quit: Exeunt]
<White_Flame>
it seems that :EXTERNAL-FORMAT is passed into the dispatcher, which then ends up in an ECASE looking for :STREAM-EXTERNAL-FORMAT, all in sbcl's main code
<White_Flame>
(this call is being made by some old code I'm running, but crashes standalone in a clean image under slime as well)
Alfr has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 240 seconds]
Alfr has joined #lisp
miasuji has quit [Remote host closed the connection]
andreyorst has quit [Quit: WeeChat 2.9]
andreyorst has joined #lisp
miasuji has joined #lisp
andreyorst has quit [Client Quit]
andreyorst has joined #lisp
cosimone has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
save-lisp-or-die has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
rumbler31 has joined #lisp
ebrasca has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
wxie has joined #lisp
Lord_of_Life has joined #lisp
Lord_of_Life_ has quit [Ping timeout: 264 seconds]
froggey has quit [Ping timeout: 256 seconds]
froggey has joined #lisp
andreyorst has quit [Quit: WeeChat 3.0]
aaaaaa has quit [Quit: leaving]
kaftejiman_ has quit [Remote host closed the connection]
kaftejiman_ has joined #lisp
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
dbotton has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
kaftejiman_ has quit [Remote host closed the connection]
<dbotton>
is there a way to disable assertions? (I can't seem to find a way on both ecl and sbcl)
bocaneri has joined #lisp
<no-defun-allowed>
Why do you want to do that?
<dbotton>
performance
<dbotton>
in most languages assertions are turned off on deliverables
<dbotton>
I assume that is why assert doesn't return the value of the form it evaluates.
<no-defun-allowed>
"Thus, rather than having the software discover its own errors in a benign way, the discovery of such errors is left to the FAA or a Congressional committee."
<dbotton>
In theory once you have "proven" you application there is no reason to continue to run them.
<no-defun-allowed>
Okay, now prove it.
<dbotton>
In SPARK you do
<no-defun-allowed>
We don't have SPARK in Lisp.
<dbotton>
Not yet
<dbotton>
Although early versions did you Lisp of spark
<dbotton>
use
<no-defun-allowed>
They did now?
<dbotton>
Let me see if I can get the reference been awhile
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
<no-defun-allowed>
There are theorem provers in Lisp, but they are far detached from Common Lisp. ACL2 doesn't even have higher order functions.
galex-713 has quit [Ping timeout: 272 seconds]
<moon-child>
isn't the format used by most smt solvers a lisp dialect?
<moon-child>
it's sexpy at the very least
<no-defun-allowed>
Hilarious.
galex-713 has joined #lisp
<dbotton>
They used the Poplog environment
<dbotton>
Poplog Prolog was used to develop the original version of the SPARK toolkit by Praxis Systems, though they now use Sicstus Prolog, as that has features not in Poplog Prolog.
<dbotton>
I guess miskate was prolog
<no-defun-allowed>
Yes, that verifies Ada, not Lisp.
<dbotton>
I know
<no-defun-allowed>
ACL2 is written in Common Lisp, but it verifies a sort of first order logic with numbers and lists.
<dbotton>
So I take it no way to turn off. Why then have it return nil?
<no-defun-allowed>
What else should it return?
<dbotton>
the value for the form it evaluated
<dbotton>
the for example check-type could be used on a return value etc.
<no-defun-allowed>
If that returns a generalised boolean, you should treat it as such. So it only would return true.
<dbotton>
(on ecl "the" doesn't do anything)
<no-defun-allowed>
"The consequences are undefined if the values yielded by the form are not of the type specified by value-type."
<pillton>
It isn't required to do anything.
<dbotton>
I know
<dbotton>
ecl is not broken
<dbotton>
Just had to make a macro to get the check-type functionality on the return type
phantomics has joined #lisp
toorevitimirp has joined #lisp
<dbotton>
On ecl does "the" have any purpose beyond indicating the intent of the return value to human readers?
<no-defun-allowed>
It may help with type inference.
sm2n has quit [Read error: Connection reset by peer]
sm2n has joined #lisp
Bike has joined #lisp
Josh_2 has quit [Ping timeout: 265 seconds]
Kundry_Wag has joined #lisp
kiroul has joined #lisp
Stanley00 has joined #lisp
miasuji has quit [Ping timeout: 260 seconds]
kir0ul has quit [Ping timeout: 240 seconds]
pfdietz has joined #lisp
rumbler31 has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
<pillton>
G'day beach.
Nilby has joined #lisp
kir0ul_ has joined #lisp
rumbler31 has joined #lisp
kiroul has quit [Ping timeout: 240 seconds]
codewaffle has quit [Ping timeout: 256 seconds]
dbotton has quit [Quit: Leaving]
rumbler31 has quit [Ping timeout: 246 seconds]
codewaffle has joined #lisp
cosimone has joined #lisp
codewaffle_ has joined #lisp
codewaffle has quit [Ping timeout: 240 seconds]
wxie has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
miasuji has joined #lisp
cosimone has quit [Quit: cosimone]
semz has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
Alfr_ has quit [Ping timeout: 260 seconds]
wxie has joined #lisp
ggole has joined #lisp
Bike has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
miasuji has quit [Ping timeout: 260 seconds]
notandinus has quit [Quit: rcirc on GNU Emacs 27.1]
notandinus has joined #lisp
andreyorst has joined #lisp
Alfr has joined #lisp
narimiran has joined #lisp
kiroul has joined #lisp
kir0ul_ has quit [Ping timeout: 256 seconds]
frost-lab has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
andreyorst_ has joined #lisp
wxie has quit [Remote host closed the connection]
wxie has joined #lisp
madage has quit [Ping timeout: 240 seconds]
andreyorst_ has quit [Ping timeout: 264 seconds]
madage has joined #lisp
bilegeek has quit [Quit: Leaving]
Necktwi has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
Blukunfando has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
wxie1 has joined #lisp
wxie has quit [Quit: wxie]
wxie1 is now known as wxie
Kundry_Wag has quit [Ping timeout: 260 seconds]
MichaelRaskin has quit [Quit: MichaelRaskin]
aorst has joined #lisp
aorst has quit [Remote host closed the connection]
aorst has joined #lisp
gaqwas has joined #lisp
kiroul has quit [Ping timeout: 264 seconds]
saganman has joined #lisp
Cymew has joined #lisp
saturn2 has quit [Ping timeout: 256 seconds]
IPmonger has quit [Ping timeout: 260 seconds]
IPmonger_ has joined #lisp
_whitelogger has joined #lisp
IPmonger_ has quit [Ping timeout: 240 seconds]
notzmv has quit [Read error: No route to host]
notzmv` has joined #lisp
notzmv` is now known as zmv`
zmv` is now known as notzmv
notzmv has quit [Changing host]
notzmv has joined #lisp
Necktwi has joined #lisp
liberliver has joined #lisp
skapata has quit [Remote host closed the connection]
saturn2 has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
saganman has quit [Read error: Connection reset by peer]
saganman has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
random-nick has joined #lisp
toorevitimirp has joined #lisp
pankajsg has quit [Ping timeout: 240 seconds]
madage has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 240 seconds]
madage has joined #lisp
gxt has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
pve has joined #lisp
jprajzne has quit [Ping timeout: 256 seconds]
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
jprajzne has joined #lisp
saturn2 has quit [Ping timeout: 256 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
Kundry_Wag has joined #lisp
ljavorsk has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
saturn2 has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
supercoven has joined #lisp
galex-713 has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
scymtym has quit [Ping timeout: 256 seconds]
cl-arthur has joined #lisp
wxie has quit [Quit: wxie]
wxie1 has joined #lisp
wxie1 is now known as wxie
gaqwas has quit [Remote host closed the connection]
luna_is_here_ has joined #lisp
Lycurgus has quit [Quit: Exeunt]
luna_is_here has quit [Ping timeout: 240 seconds]
madage has quit [Remote host closed the connection]
madage has joined #lisp
scymtym has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
h11 has quit [Quit: Bridge terminating on SIGTERM]
autumn[m] has quit [Quit: Bridge terminating on SIGTERM]
MrtnDk[m] has quit [Quit: Bridge terminating on SIGTERM]
jonjitsu[m] has quit [Quit: Bridge terminating on SIGTERM]
lspr[m] has quit [Quit: Bridge terminating on SIGTERM]
etimmons has quit [Quit: Bridge terminating on SIGTERM]
cairn has quit [Quit: Bridge terminating on SIGTERM]
katco has quit [Quit: Bridge terminating on SIGTERM]
Dmytro[m] has quit [Quit: Bridge terminating on SIGTERM]
kinope has quit [Quit: Bridge terminating on SIGTERM]
no-defun-allowed has quit [Quit: Bridge terminating on SIGTERM]
santiagopim[m] has quit [Quit: Bridge terminating on SIGTERM]
ThaEwat has quit [Quit: Bridge terminating on SIGTERM]
camlriot42 has quit [Quit: Bridge terminating on SIGTERM]
even4void[m] has quit [Quit: Bridge terminating on SIGTERM]
Gnuxie[m] has quit [Quit: Bridge terminating on SIGTERM]
infra_red[m] has quit [Quit: Bridge terminating on SIGTERM]
loke[m] has quit [Quit: Bridge terminating on SIGTERM]
Codaraxis has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 240 seconds]
santiagopim[m] has joined #lisp
Necktwi has quit [Quit: Lost terminal]
Necktwi has joined #lisp
oni-on-ion has joined #lisp
Necktwi has quit [Client Quit]
no-defun-allowed has joined #lisp
etimmons has joined #lisp
MrtnDk[m] has joined #lisp
cairn has joined #lisp
ThaEwat has joined #lisp
katco has joined #lisp
infra_red[m] has joined #lisp
kinope has joined #lisp
even4void[m] has joined #lisp
camlriot42 has joined #lisp
autumn[m] has joined #lisp
h11 has joined #lisp
Dmytro[m] has joined #lisp
Gnuxie[m] has joined #lisp
loke[m] has joined #lisp
lspr[m] has joined #lisp
jonjitsu[m] has joined #lisp
pankajsg has joined #lisp
imode has quit [Ping timeout: 260 seconds]
seok has quit [Remote host closed the connection]
ecm has joined #lisp
ecm is now known as glenda
glenda is now known as obnoxious_glenda
galex-713 has quit [Ping timeout: 272 seconds]
Necktwi has joined #lisp
EvW has joined #lisp
* Xach
feels the excitement of a fresh day of Lisp hacking
Blukunfando has joined #lisp
cosimone has joined #lisp
galex-713 has joined #lisp
<_death>
cool, whatcha hacking?
aartaka_d has joined #lisp
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
ldb has joined #lisp
<ldb>
good evening
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 264 seconds]
aartaka has quit [Read error: Connection reset by peer]
Stanley00 has quit [Remote host closed the connection]
cosimone has quit [Quit: ERC (IRC client for Emacs 27.1)]
rumbler31 has joined #lisp
andreyorst has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
aorst has quit [Read error: Connection reset by peer]
andreyorst has joined #lisp
aorst has joined #lisp
Bike has joined #lisp
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Ping timeout: 264 seconds]
obnoxious_glenda has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
ldb` has joined #lisp
zaquest has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
ldb has quit [Ping timeout: 240 seconds]
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Client Quit]
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Client Quit]
enrio has joined #lisp
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Client Quit]
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Client Quit]
obnoxious_glenda has joined #lisp
IPmonger has joined #lisp
<pve>
Hi! I would like to give instances of my generic function class a default "function". Is the correct place to do this in "initialize-instance :after ((gf my-gf-class) ... " using set-funcallable-instance-function?
asdflkj has joined #lisp
asdflkj has quit [Client Quit]
asdflkj has joined #lisp
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
obnoxious_glenda has quit [Client Quit]
obnoxious_glenda has joined #lisp
<Bike>
that would make sense to me.
<phoe>
yes, if you only want to do that during instance initialization
Alfr has quit [Remote host closed the connection]
<pve>
phoe: hmm, I mean I would just like it to exist until the first method is added
Alfr has joined #lisp
<phoe>
pve: what after the first method is removed
<pve>
hmm, good point..
<pve>
It should revert to the "no methods" behaviour
<pve>
but that I can do separately
<jackdaniel>
so when you add /first/ method and /second/ method, and remove /first/ method.. :-)
Alfr has quit [Remote host closed the connection]
<pve>
when removing methods
<phoe>
sounds like you either need a general case for 0 methods or that you need to handle both cases, namely, in some sort of initialization code and then in your remove-method
Alfr has joined #lisp
<pve>
phoe: exactly, I only asked because I'm having some problems getting it to work using initialize-instance :after
<pve>
jackdaniel: I only need to check for 0 methods
<Bike>
problems like what?
Alfr has quit [Remote host closed the connection]
<jackdaniel>
that was a joke
Alfr has joined #lisp
<pve>
Bike: hmm actually if I replace the default function with something simple like (print 'hello) it does work.. so the problem is most likely elsewhere
hendursa1 has quit [Quit: hendursa1]
Alfr has quit [Remote host closed the connection]
hendursaga has joined #lisp
Alfr has joined #lisp
rumbler31 has joined #lisp
Alfr has quit [Remote host closed the connection]
<pve>
the point of this is to improve my "does-not-understand" functionality which uses no-applicable-method, but it only seems to work when the gf has at least one method
Alfr has joined #lisp
aartaka has joined #lisp
Alfr has quit [Remote host closed the connection]
Alfr has joined #lisp
Alfr has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 264 seconds]
Alfr has joined #lisp
Alfr has quit [Remote host closed the connection]
Alfr has joined #lisp
<obnoxious_glenda>
ugh, someone in #programming called lisp a broken toy left in the trash, leaving its stench off for ages
<phoe>
obnoxious_glenda: people arguing on the Internet, as always
<obnoxious_glenda>
some guy asked what programming lang he should start with
<obnoxious_glenda>
everyone went to war
<obnoxious_glenda>
as usual
aartaka_d has joined #lisp
<phoe>
:D
Alfr has quit [Remote host closed the connection]
hendursaga has quit [Remote host closed the connection]
Alfr has joined #lisp
<jackdaniel>
well, that description comes nice with "lisp is not dead, it just smells funny" :)
hendursaga has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
<Demosthenex>
ok, so i'm using clsql with sqlite, and trying to use the s expression based sql queries. i'm translating over some sql with subqueries, ie: select * from table1, (select * from tables2...) as subtable ... and can't see how clsql supports subqueries?
mokulus has quit [Read error: Connection reset by peer]
aeth has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
semz has quit [Quit: Leaving]
aeth has joined #lisp
mokulus has joined #lisp
Achylles has joined #lisp
luna_is_here_ has quit [Ping timeout: 260 seconds]
Achylles has quit [Max SendQ exceeded]
luna_is_here has joined #lisp
Achylles has joined #lisp
frost-lab has quit [Quit: Connection closed]
aartaka_d has quit [Ping timeout: 240 seconds]
Achylles has quit [Max SendQ exceeded]
Achylles has joined #lisp
EvW has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
yottabyte has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
loli has quit [Quit: WeeChat 2.9]
yitzi has joined #lisp
wsinatra has joined #lisp
loli has joined #lisp
mokulus has quit [Ping timeout: 260 seconds]
<pve>
ok now it works, also with remove-method.. thanks guys
aartaka has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
amb007 has joined #lisp
kiroul has joined #lisp
abbe__ has quit [Quit: “Everytime that we are together, it's always estatically palpitating!”]
oni-on-ion has quit [Read error: Connection reset by peer]
Nilby has quit [Read error: Connection reset by peer]
abbe_ has joined #lisp
iskander has joined #lisp
cosimone has joined #lisp
pankajsg has quit [Ping timeout: 244 seconds]
skapata has joined #lisp
iskander- has quit [Ping timeout: 260 seconds]
pankajsg has joined #lisp
tfb has joined #lisp
zaquest has joined #lisp
vegansbane has joined #lisp
<hhdave>
Is anyone here looking for a Common Lisp programming job?
toorevitimirp has quit [Remote host closed the connection]
<phoe>
hhdave: I assume yes; you might also post on /r/Lisp and /r/Common_Lisp and optionally ask Xach for publishing on Planet Lisp for more visibility
<jackdaniel>
generally speaking I'm sure that there are a few, but more details would make this question less vague
<hhdave>
I know, sorry...
cosimone has quit [Quit: cosimone]
<phoe>
or you can link us here in #lisp towards the details of the job offer and I'll do my best to distribute it across other channels
<hhdave>
I work for a small Insurance MGA (https://github.com/Virtual-Insurance-Products) in Devon, England and we're in need of another CL programmer (at least 1). The previous guy we had left to do Rust programming.
<hhdave>
Remote would be ok. We're all working remotely almost all the time at the moment.
<hhdave>
We have a web based CL application which is accessed by many brokers across the country (mostly - we had/have some clients in Ireland and some in Poland too) selling niche insurance products.
<jackdaniel>
if you won't find someone full time, let me know -- I'm available at smaller capacity as a consultant
<hhdave>
I've been uploading some of the libraries it uses to that github page.
<hhdave>
@jackdaniel: that's great, thanks. Even if we do find someone it could be useful to have you as a standby in case there's suddenly loads of work. I am, in fact, really busy.
<hhdave>
(maybe that @ isn't applicable here).
<obnoxious_glenda>
irc :)
<jackdaniel>
it usually isn't :) I'll send you my email on query
<hhdave>
CLIM knowledge would certainly be relevant, though my 'CLIM' implementation stuff is probably a bit mad compared to proper McCLIM or such
<jackdaniel>
the second is xlib and the third is a framebuffer
<jackdaniel>
(this is a matrix I've used for checking various features the verify if they work)
<hhdave>
Does it, in any way, make sense to have a McCLIM renderer that could generate actual HTML? I know that wouldn't cover everything and a lot of graphical stuff would need the canvas, but would there be any way to make it work do you think? I know you were playing with TUI renderers or something weren't you?
<jackdaniel>
as I've said, the first "window" is the actual output in firefox
<jackdaniel>
it is html5 document generated from mcclim
saganman has quit [Read error: Connection reset by peer]
<jackdaniel>
it would also make sense to write something more interactive, but that would be much more work and would involve javascript
saganman has joined #lisp
<jackdaniel>
also scymtym wrote a broadway backend, that works over gtk protocol that is capable of running in the browser (afair), and that one is truly interactive
arpunk has quit [Remote host closed the connection]
<hhdave>
It's really great that there seems to be so much more interest in McCLIM these days. A few years ago, about the time I discovered it and started looking into it, it seemed all but abandoned.
<phoe>
hhdave: that was years ago :D
<jackdaniel>
beach kept maintaining it over the years
<phoe>
hhdave: please ping me with the details - I'll do the cross-posting later today, but I need to disappear now
<hhdave>
phoe: I know. Now it's all the rage.
<hhdave>
phoe: will do.
aeth has quit [Ping timeout: 246 seconds]
<hhdave>
Good that he did.
aeth has joined #lisp
<hhdave>
What I would really like to do is to somehow replace (most of?) my 'strange' impementation of sort of CLIM with McCLIM and just make a backend (and whatever else is needed) to make it good for writing normal(ish) looking web applications Really Easily. I have almost no idea as to the feasibility of that though. I started off just adopting some of the ideas into my codebase, but then ended up gradually (and then less gradually) evolving it to be more
sjl_ has joined #lisp
enrio has quit [Quit: Leaving]
aartaka has quit [Read error: Connection reset by peer]
ljavorsk has quit [Ping timeout: 240 seconds]
<jackdaniel>
I have more modest wishes - I'd like to have the coordinate swizzling removed soon-ish :)
rixard_ has joined #lisp
hnOsmium0001 has joined #lisp
rixard has quit [Read error: Connection reset by peer]
tfb has quit []
obnoxious_glenda has quit [Quit: WeeChat 3.0]
obnoxious_glenda has joined #lisp
pankajsg has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
Cymew has quit [Ping timeout: 272 seconds]
Stanley00 has joined #lisp
aorst has quit [Quit: aorst]
Stanley00 has quit [Ping timeout: 272 seconds]
cosimone has joined #lisp
andreyorst_ has joined #lisp
JohnMS has joined #lisp
iskander- has joined #lisp
rippa has joined #lisp
iskander has quit [Ping timeout: 256 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
obnoxious_glenda has quit [Quit: WeeChat 3.0]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
zcheng3 has joined #lisp
cosimone has quit [Quit: cosimone]
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
aaa has joined #lisp
uniminin has quit [Max SendQ exceeded]
aaa has quit [Client Quit]
random-nick has joined #lisp
andreyorst_ has quit [Ping timeout: 246 seconds]
karlosz has joined #lisp
enrio has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
orivej has quit [Ping timeout: 256 seconds]
enrio has quit [Client Quit]
galex-713 has quit [Ping timeout: 272 seconds]
dbotton has joined #lisp
rippa has joined #lisp
enrio has joined #lisp
kir0ul_ has joined #lisp
orivej has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
andreyorst_ has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
kiroul has quit [Ping timeout: 265 seconds]
elflng has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Quit: Exeunt]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
luckless_ has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
elflng has joined #lisp
iskander has joined #lisp
iskander- has quit [Ping timeout: 272 seconds]
lucasb has joined #lisp
<dbotton>
Does anyone know what the built in packages "gray" and "walker" are in ecl? The manual is blank for them?
<White_Flame>
usually the walker goes through a source code form, distinguishing what's code vs data, what's a lexical variable name, etc
Cymew has joined #lisp
enrio has quit [Quit: Leaving]
Alfr has quit [Quit: Leaving]
JohnMS has quit [Quit: Konversation terminated!]
<jackdaniel>
yes, walker is the code walker adapted to understand ecl specual firms
<jackdaniel>
gray is gray streams implementation package
<phoe>
lots of implementations have Gray streams
Steeve has quit [Ping timeout: 240 seconds]
ldb` has quit [Remote host closed the connection]
<jackdaniel>
truvual-gray-streams us the preferred portability layer
<phoe>
http://portability.cl/ lists ABCL, ACL, CCL, Clasp, CLISP, ECL, LW, Mezzano, MOCL, and SBCL under t-g-s
<jackdaniel>
(on phone, hence typos)
<White_Flame>
s/u/i/g
<White_Flame>
need a regex bot
<dbotton>
Thanks
enrio has joined #lisp
Steeve has joined #lisp
enrio has quit [Quit: Leaving]
enrio has joined #lisp
gproto23 has joined #lisp
frgo has joined #lisp
kir0ul_ has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
galex-713 has joined #lisp
enrio has quit [Read error: Connection reset by peer]
aartaka_d has quit [Ping timeout: 240 seconds]
enrio has joined #lisp
liberliver has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
enrio has quit [Quit: Leaving]
dbotton_ has joined #lisp
kir0ul_ has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
jonatack has quit [Quit: jonatack]
saganman has quit [Quit: WeeChat 1.6]
yitzi has quit [Quit: yitzi]
dyelar has quit [Ping timeout: 260 seconds]
exit70[m] has joined #lisp
ebrasca has joined #lisp
jonatack has joined #lisp
dxtr has quit [Ping timeout: 264 seconds]
jonatack has quit [Ping timeout: 256 seconds]
andreyorst_ has quit [Ping timeout: 256 seconds]
bocaneri has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
enrio has joined #lisp
dyelar has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
trafaret1 has joined #lisp
ljavorsk has joined #lisp
yitzi has joined #lisp
Alfr has joined #lisp
imode has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
cosimone has joined #lisp
trafaret1 has quit [Read error: Connection reset by peer]
trafaret1 has joined #lisp
trafaret1 has left #lisp [#lisp]
Codaraxis has joined #lisp
gareppa has joined #lisp
luni has joined #lisp
luni is now known as Guest27791
Guest27791 has left #lisp [#lisp]
<pillton>
I have released a new system called data-flow (https://github.com/markcox80/data-flow). It is intended for applications which are composed of small independent components/units which interact with each other via ports or events.
luni has joined #lisp
luni has left #lisp [#lisp]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<White_Flame>
pillton: interesting. We have a pipeline scheme, which is pretty verbose. This might do something similar
<White_Flame>
and of course, every library has its own threadpooling system. It'd be nice for there to be a central threadpool for everything to compose into
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<pillton>
The system provides a scheduler which executes tasks if their resource requirements are satisfied. This should be fine to use with other systems.
lucasb has left #lisp [#lisp]
<White_Flame>
right, but many other systems have their own thread pool as well :)
vaporatorius__ has joined #lisp
<pillton>
It doesn't matter if they do.
<White_Flame>
if both are busy, then there's more thread contention
<White_Flame>
I mean, the entire point of a threadpool is to better gracefully handle the case when there's too much in flight
<White_Flame>
so they don't stack well
<pillton>
Only if you're an application developer that has no idea what is executing.
vaporatorius has quit [Ping timeout: 256 seconds]
<pillton>
You could use the sequential scheduler for the application and use the threadpool of the other systems for the individual computations.
<White_Flame>
well, that means manual allocation of resources between your libraries & other threadpool domains
<White_Flame>
I'd think a single threadpool that everything's dumped into would be desirable
<White_Flame>
(similarly, if all p2p bandwidth controls were centralized into a single system-wide config, as opposed to per application; that's a similar thing that's found in various domains)
gproto23 has quit [Ping timeout: 272 seconds]
<White_Flame>
it's definitely tangential to the actual dataflow stuff, though :)
andreyorst has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
ggole has quit [Quit: Leaving]
amb007 has joined #lisp
vaporatorius has joined #lisp
vaporatorius has joined #lisp
enrio has quit [Ping timeout: 240 seconds]
vaporatorius__ has quit [Ping timeout: 265 seconds]
yitzi has quit [Quit: yitzi]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
andreyorst has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<pillton>
I am not convinced yet but you may be right.
miasuji has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
izh_ has joined #lisp
choegusung has joined #lisp
jw4 has joined #lisp
izh_ has quit [Client Quit]
dbotton_ has quit [Quit: Leaving]
EvW has quit [Ping timeout: 260 seconds]
<_death>
pillton: looks interesting.. usually I'd use zmq for that kind of thing, or mailboxes or just queues.. or coroutines and such if single-threaded.. data-flow seems framework-y and lets the user specify a scheduler so I'm wondering what are the use cases..
<phantomics>
Interesting, I've got some projects coming up that will require dataflow, I'll give this a try
bilegeek has joined #lisp
EvW has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
<pillton>
_death: The factors which "tipped me over the edge" was a project at work and Paul Khuong's article titled "The unscalable, deadlock-prone, thread pool".
<White_Flame>
yeah, re the article, anything that can block should never be in a fixed-size threadpool
<pillton>
_death: I hate writing multithreaded software for the most part. What I wanted was something which executed loosely connected computations in parallel without me having to do anything i.e. locally sequential, globally parallel.
<aeth>
White_Flame: Speaking as a CL game engine author, you're simply not going to get a thread pool that satisfies every use case. You think that having one central thread pool means that libraries can interoperate with each other so more can use thread pools safely, but not really. I'll still have to avoid everything that uses a thread pool.
<aeth>
Anything real time is going to have to micromanage threads to some extent.
<White_Flame>
well, micromanage tasks
<aeth>
The thing is, a game engine is going to have to have its own threading system that handles things to its own requirements which are soft real time rather than batch-oriented. At best, you could just provide a common API and allow different implementations with different trade offs, but even the API is probably not going to really be the same with game engine vs. normal app stuff
<aeth>
Worse, some things need to synchronize every frame (probably physics, if "frame" means logic frame rather than rendering frame) and some things don't (e.g. AI).
<pillton>
_death: The project at work involved iterating a map-and-reduce task where each item in the map required performing I/O and then a hefty compute task. A lot of time was wasted waiting for I/O to finish because it wasn't executing in parallel with the compute.
<_death>
pillton: ok.. in the readme you mentioned non-blocking I/O.. how would you go about doing that with data-flow?
<White_Flame>
pillton: yeah, one the of the reason to have a grand central threadpool is that the priority, balancing, resource consumption, can ideally be well expressed in one place
<pillton>
_death: You can ask a scheduler if blocking is allowed using data-flow:blocking-allowed-p.
sjl has quit [Quit: WeeChat 2.2-dev]
<aeth>
White_Flame: That sounds like the responsibility for a framework, though
<pillton>
_death: All of the operations in the data flow system are non blocking. That predicate is meant for I/O.
<aeth>
(as an aside: confusingly, both game frameworks and game engines are software frameworks)
<White_Flame>
eh, it's additional metadata passed in with a function object
<White_Flame>
a threadpool is literally a scheduler
<White_Flame>
a non-preemptive one
<White_Flame>
(at least, in the common use)
<aeth>
White_Flame: right... in particular, it creates the inversion of control where the flow of control is the responsibility of the framework, rather than the caller, at least by Wikipedia's definition. https://en.wikipedia.org/wiki/Software_framework
<aeth>
White_Flame: Only one component of a framework, though.
miasuji has quit [Ping timeout: 272 seconds]
<White_Flame>
if you need external scheduling, because you don't know at the call site if/when/where something should run ... it still seems like a library to me
<aeth>
A language that does this directly (or that has some de facto standard library that everyone uses to do this, which might be what you're proposing) is one that gives less freedom to the software frameworks that should be micromanaging this sort of thing
<_death>
pillton: ok, I'll need to play with it some time ;)
<aeth>
Unless, of course, you go one level more meta and just provide an interface that anyone can implement (which is sort of a C++ or Java way of thinking)
shka_ has quit [Ping timeout: 256 seconds]
<pillton>
White_Flame: In my mind there are two types of multi-threaded software 1) same task different data (usually requires barriers for synchronisation) and 2) multiple arbitary tasks. The barrier algorithms I have seen require knowing the number of threads before starting the computation.
<aeth>
A game engine is kind of the worst case for this type of multithreading (which might be why so many games are still bottlenecked by a main thread even though we've had mainstream quad cores for over a decade now).
<pillton>
(Be back later. I need to go to work.)
<aeth>
The #2 type, the multiple arbitrary tasks type.
scymtym_ has joined #lisp
scymtym has joined #lisp
<aeth>
You have to parallelize stuff that's of pretty much every kind of data (even network data, if multiplayer) on the GPU and on the CPU. Some's async (doesn't matter when it finishes, e.g. loading something in the background) and some's with very tight timing requirements.
<White_Flame>
games & HPC tend to have very scrutinized, allocated pipelines
<White_Flame>
and probably games even moreso
<White_Flame>
100% utilization is fine for many tasks, but not for games
<White_Flame>
so it's really "realtime" as you mentioned that's the confounding factor for many throughput systems
<aeth>
HPC is mostly just linear algebra simulations, which is a subset of what games do, but games just require things to visually look plausible rather than to be actually accurate (with a bit of a caveat that with multiplayer you can't do things too badly or you might desync)
<aeth>
So games are harder and easier.
<aeth>
You can do 100% utilization on a game, if you wanted the simulation to get more realistic the more power you have, but generally games only care about 100% GPU utilization, i.e. just the visual simulation. Multiplayer games really can't let players with better CPUs get a different logic simulation, anyway.
<White_Flame>
that's because GPUs don't really do too much cross-frame parallel work
<aeth>
There are some games where you'll get a harder game if you have a better CPU, though. Most notably, timed chess. (The AI, called the "chess engine", will probably use 100% of everything until time's up, or some other constraint is up.)
<White_Flame>
I guess the same could be true on the CPU end, if everything's on a frame barrier
<aeth>
(Not like a slightly harder chess AI in 2020 would make an observable difference to a human...)
<White_Flame>
but really, those who are doing threadpool stuff are generally not doing hard realtime requirements
<White_Flame>
but rather don't want things jamming up or wasting time with thrashing
<White_Flame>
while trying to express things reasonably without requiring that level of hand-tuning
<aeth>
Yes, but... if you get everyone to standardize on a thread pool that isn't designed for hard real time requirements, you're basically forcing users with those requirements to not be able to use any library that uses that thread pool.
narimiran has quit [Ping timeout: 272 seconds]
<aeth>
Maybe fine for a scripting language, but I don't think CL should restrict domains like that.
<White_Flame>
as I said, threadpools aren't for hard realtime requirements
<White_Flame>
(generally speaking)
<aeth>
eh
<White_Flame>
having multiple very customized ones in some situations might, but again I would take "I'm using threadpools" as equivalent to "I'm not doing hard realtime"
choegusung has quit [Quit: leaving]
<aeth>
afaik, and I haven't looked into this in detail yet, you can just treat a game engine's thread situation like: "these n threads can return within a reasonable amount of time while these m threads have to synchronize every k frames"
<aeth>
i.e. the former are basically async but you need an answer of some sort "eventually" (which could be a few seconds, which is like an eternity to the game engine)
EvW has quit [Ping timeout: 264 seconds]
<aeth>
so even if a thread pool doesn't work for real time, well, you can still sort of thread pool the rest
<aeth>
I guess some of those things should be time limited (e.g. AI) and some of those things shouldn't (e.g. loading the next chunk of the world map in a Minecraft clone)
scymtym has quit [Remote host closed the connection]
scymtym_ has quit [Remote host closed the connection]
<aeth>
(and a game engine isn't hard real time, anyway... missing a frame or two isn't the end of the world)
<White_Flame>
right, but there's a framerate target, which means budgeting milliseconds for various tasks, as well as polygon/texture budgets, etc. It's still designed as realtime even if it doesn't kill 300 people if it fails its targets
EvW has joined #lisp
Khisanth has quit [Ping timeout: 265 seconds]
aartaka_d has quit [Ping timeout: 256 seconds]
<aeth>
White_Flame: that just means that the threads must synchronize by a certain amount of time. But if you have, say, 6 physics threads, then the physics work can still be distributed.
scymtym has joined #lisp
<aeth>
And modern desktops will have 12-128 threads, probably 12-24.
<White_Flame>
sure, which is often a hand tuned balancing act
<White_Flame>
measured against the load that the game needs, and affects level design, weapon firing rates, etc
<aeth>
You can't hand-tune now that everyone's moving on past quad cores.
<White_Flame>
but still, this falls more into the SIMD-ish style processing that pillton brought up
<White_Flame>
not the "bucket of tasks" one
Khisanth has joined #lisp
cosimone_ has joined #lisp
dxtr has joined #lisp
cosimone has quit [Ping timeout: 260 seconds]
cosimone_ is now known as cosimone
aartaka has joined #lisp
<aeth>
White_Flame: Only on insufficiently parallel machines
Lycurgus has joined #lisp
<aeth>
White_Flame: AMD has been selling 12c24t and 16c32t CPUs to the consumers/mainstream/gamers segment for well over a year now. And anything started now will probably take years to ship.
<White_Flame>
that doesn't change the distinction though
<White_Flame>
it only changes how games are written, not the rest of the industry
<aeth>
Some systems will be "bucket of tasks" systems, such as perhaps the AI system. And when you have 32 real hardware threads to work with, they might be allocated a decent number
<White_Flame>
or I should better say, the game industry is heavily affected by that, while the rest isn't as much
<White_Flame>
because of the distinction in coding style
<White_Flame>
which are because of the timing requirements
<aeth>
The thing about games is that they can do basically everything. And when it does "basically everything", the timing requirements differ, too.
<aeth>
To the point where some of them are probably best expressed as not really having a requirement. As long as the rest of the world can move on so the game doesn't hang.
<aeth>
console-first AAA games will probably spend all of the thread budget on rendering threads, but basically just those will, and none of them will be using Common Lisp
andreyorst has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 246 seconds]
sjl_ has quit [Ping timeout: 272 seconds]
pve has quit [Quit: leaving]
miasuji has joined #lisp
lotuseater has joined #lisp
leo_song has quit [Ping timeout: 240 seconds]
leo_song has joined #lisp
Jesin has quit [Quit: Leaving]
random-nick has quit [Ping timeout: 264 seconds]
pillton has quit [Read error: Connection reset by peer]
pillton_ has joined #lisp
<pillton_>
White_Flame: My primary goal was to enforce "component providers" to not require a particular scheduler in order to function. This should be chosen by the user.
<pillton_>
White_Flame: Which I think we are in agreement on.
gareppa has quit [Quit: Leaving]
pillton_ is now known as pillton
<White_Flame>
sure
Jesin has joined #lisp
Misha_B has joined #lisp
Steeve has quit [Quit: end]
hiroaki has quit [Ping timeout: 256 seconds]
ljavorsk_ has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
ljavorsk_ has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
miasuji has quit [Ping timeout: 256 seconds]
epony has quit [Remote host closed the connection]
<aeth>
In case someone's wondering why I brought up game engines... I think any "serious" language should consider a game engine, a web browser, and a database. Big, complicated applications that need some degree of performance and an unbounded number of features limited only by ambition and time.
<aeth>
Fairly non-overlapping, too, so just those three should span most application development concerns.
<aeth>
Maybe add something that heavily involves integers, but maybe that's already covered by the cryptography that's needed by networking...