<lerax>
There is a portable way to use threads with Common Lisp? Currently I'm using the sb-thread: package from sbcl, but this is not a nice solution because is SBCL only.
ArthurAGleckler[ has quit [Ping timeout: 276 seconds]
RichardPaulBck[m has quit [Ping timeout: 276 seconds]
dirb has quit [Ping timeout: 255 seconds]
mhitchman[m] has quit [Ping timeout: 255 seconds]
hdurer[m] has quit [Ping timeout: 240 seconds]
Jach[m] has quit [Ping timeout: 252 seconds]
hiq[m] has quit [Ping timeout: 252 seconds]
equalunique[m] has quit [Ping timeout: 265 seconds]
plll[m] has quit [Ping timeout: 255 seconds]
katco[m] has quit [Ping timeout: 255 seconds]
kammd[m] has quit [Ping timeout: 276 seconds]
emacsomancer has joined #lisp
rumbler31 has joined #lisp
z3t0 has quit [Remote host closed the connection]
openthesky has joined #lisp
z3t0 has joined #lisp
papachan has quit [Quit: WeeChat 2.0.1]
z3t0 has quit [Ping timeout: 240 seconds]
dieggsy has quit [Remote host closed the connection]
dieggsy has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
asarch has quit [Quit: Leaving]
borei has joined #lisp
Kaisyu has joined #lisp
kammd[m] has joined #lisp
antgreen has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
emacsomancer has quit [Remote host closed the connection]
emacsomancer has joined #lisp
python476 has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
Jach[m] has joined #lisp
RichardPaulBck[m has joined #lisp
mhitchman[m] has joined #lisp
hdurer[m] has joined #lisp
hiq[m] has joined #lisp
equalunique[m] has joined #lisp
CharlieBrown has joined #lisp
cryptomarauder has joined #lisp
plll[m] has joined #lisp
kfdenden[m] has joined #lisp
dirb has joined #lisp
ArthurAGleckler[ has joined #lisp
katco[m] has joined #lisp
Oladon has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
markong has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
mlf has quit [Ping timeout: 240 seconds]
mlf has joined #lisp
warweasle has joined #lisp
pagnol has quit [Quit: Ex-Chat]
Cymew has joined #lisp
xrash has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
ebzzry has left #lisp ["WeeChat 1.9.1"]
nullman has quit [Ping timeout: 256 seconds]
nullman has joined #lisp
nowhereman_ has joined #lisp
fikka has joined #lisp
fds has joined #lisp
nowhere_man has quit [Ping timeout: 264 seconds]
drewc has quit [Ping timeout: 240 seconds]
bmgxc9 has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
shrdlu68 has quit [Ping timeout: 260 seconds]
arescorpio has joined #lisp
aindilis has quit [Remote host closed the connection]
Arcaelyx has joined #lisp
Oladon has quit [Quit: Leaving.]
openthesky has quit [Quit: Leaving.]
openthesky has joined #lisp
d4ryus1 has joined #lisp
deng_cn1 has joined #lisp
kozy has quit [Remote host closed the connection]
deng_cn has quit [Ping timeout: 260 seconds]
deng_cn1 is now known as deng_cn
kozy has joined #lisp
d4ryus has quit [Ping timeout: 260 seconds]
kozy has quit [Remote host closed the connection]
kozy has joined #lisp
kozy has quit [Remote host closed the connection]
kozy has joined #lisp
jameser has joined #lisp
jameser has quit [Read error: Connection reset by peer]
jameser has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
katco[m] has quit [Ping timeout: 248 seconds]
kfdenden[m] has quit [Ping timeout: 248 seconds]
CharlieBrown has quit [Ping timeout: 248 seconds]
ArthurAGleckler[ has quit [Ping timeout: 240 seconds]
equalunique[m] has quit [Ping timeout: 240 seconds]
plll[m] has quit [Ping timeout: 255 seconds]
Jach[m] has quit [Ping timeout: 260 seconds]
kammd[m] has quit [Ping timeout: 260 seconds]
hiq[m] has quit [Ping timeout: 256 seconds]
mhitchman[m] has quit [Ping timeout: 240 seconds]
hdurer[m] has quit [Ping timeout: 240 seconds]
RichardPaulBck[m has quit [Ping timeout: 252 seconds]
cryptomarauder has quit [Ping timeout: 252 seconds]
dirb has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
jameser has quit [Max SendQ exceeded]
jameser has joined #lisp
damke_ has joined #lisp
damke has quit [Read error: Connection reset by peer]
warweasle has quit [Quit: Leaving]
milanj has quit [Quit: This computer has gone to sleep]
Pixel_Outlaw has quit [Quit: Leaving]
pierpa has joined #lisp
<lerax>
I have a asdf system on my quicklisp, but I have the same at ~/lisp-chat/lisp-chat.asd. There is a simple way to load it by the current path on sbcl repl instead of loading the global installed by quicklisp? (lisp-chat it's provided by the quicklisp dist)
<pjb>
symlink into ~/quicklisp/local-projects/
<lerax>
I saw on the docs something about doing hacky things on asdf:*central-registry*
<Bike>
local-projects is usually easier.
<pjb>
Or, of course, you can just (push #P"~/lisp-chat/" asdf:*central-registry*) ; nothing hacky in it.
<pjb>
It depends on whether it's a try-it-once basis or on a more permanent basis.
<lerax>
yes, I did that... but seems that in some way the quicklisp gives preference to the version from quicklisp (ql:quickload 'lisp-chat)
<pjb>
it should not. local-projects are normally tried first.
<Bike>
you might have to, what is it, (ql:register-local-projects) first though
<lerax>
I'll try again. Maybe I mess something
<lerax>
HMMM why Bike?
schoppenhauer has quit [Ping timeout: 268 seconds]
<Bike>
why? because that's how it works
<lerax>
ok
schoppenhauer has joined #lisp
<lerax>
Just for curiosity, this function search for .asd files and register at system-index.txt?
<lerax>
this worked, thanks Bike, indeed I needed to call (ql:register-local-projects) first
<Bike>
i think that's what the function does, yes
<Bike>
asdf has a deep api for specifying how it searches for systems, but hardly anyone understands it so we just use central registry and a text file list and so forth
orivej has quit [Ping timeout: 276 seconds]
bmgxc9 has quit [Remote host closed the connection]
z3t0 has joined #lisp
<pillton>
billitch: basic-binary-ipc works on BSD.
<pillton>
billitch: Well, FreeBSD.
solyd has joined #lisp
arescorpio has quit [Quit: Leaving.]
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
sjl__ has joined #lisp
shka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
sjl__ has quit [Ping timeout: 255 seconds]
solyd has quit [Quit: solyd]
<beach>
Good morning everyone!
damke has joined #lisp
Bike has quit [Quit: Lost terminal]
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
schoppenhauer has quit [Ping timeout: 256 seconds]
schoppenhauer has joined #lisp
smasta has quit [Quit: WeeChat 2.0.1]
lerax has quit [Remote host closed the connection]
drewc has joined #lisp
wxie has joined #lisp
z3t0 has quit [Remote host closed the connection]
epony has quit [Quit: QUIT]
<iqubic>
Morning beach.
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
orivej has joined #lisp
guen has joined #lisp
kajo has quit [Quit: WeeChat 2.0.1]
sjl__ has joined #lisp
dddddd has quit [Remote host closed the connection]
<borei>
im not happy to create arrays, because r-lane and c-lane are just pointers
<borei>
but it didn't find how to create pointers :-(
damke has joined #lisp
<|3b|>
depending on what you mean by "pointer", all bindings in CL might qualify
<borei>
basically i'd like to say that r-lane (and c-lane) has the type (simple-array double-float (4))
<borei>
without creating array(s)
<|3b|>
you could initialize it from elements-m1 or -m2
<White_Flame>
your (setf r-lane ...) replace the arrays you created up top
<White_Flame>
so the make-array is competely wasted
<|3b|>
(though if you are running at safety 0, you probably should verify they actually contain that type first)
<|3b|>
White_Flame: not /completely/ since it makes the type declarations correct :)
fikka has joined #lisp
ahungry has quit [Remote host closed the connection]
<White_Flame>
you could put the LET inside the LOOP, making the declarations valid & properly scoped, as that's where the variable is actaully used
<|3b|>
though they could easily be a literal or constant or something instead of allocating every time
<White_Flame>
at least for r-lane and c-lane
<|3b|>
yeah, that's probably a better solution there
<|3b|>
borei: also, don't put the DO in LOOP at the end of the previous clause
<White_Flame>
a definite shift from C-style languages to Lisp is that you scope variables much tighter, instead of just declaring them all up at the top of the function
<|3b|>
makes it harder to read correctly easily
<borei>
wait wait
<White_Flame>
(loop for blah blah
<White_Flame>
do (let ((r-lane ..) (c-lane ..))
<White_Flame>
(declare (type ...r-lane c-lane))
<borei>
ok
<borei>
within loop ?
<White_Flame>
yep
* |3b|
would just (loop for blah .. for r-lane of-type ... )
<White_Flame>
and yeah, LOOP itself migh tbe able to iterate the arrays for you, instead of dealing with indexes manually
<borei>
let me try
<|3b|>
actually yeah, missed that they were just directly iterating a vector, was thinking FOR = rather than FOR ACROSS
fikka has quit [Ping timeout: 255 seconds]
Jach[m] has joined #lisp
* |3b|
would just do the whole thing on a GPU though, even with the horribly crippled double precision on consumer nvidia cards, recent midrange stuff does 50-100gflops :)
<borei>
true
<borei>
i read some paper - peak on iCore 7 > 300Gflops
<borei>
so i do some "research" how much can i squize from it using lisp
<borei>
hoping (and crossing fingers about) that compiler will use SIMD
* |3b|
suspects you would need to do it manually :(
<borei>
is it possible to do from lisp ?
mhitchman[m] has joined #lisp
ArthurAGleckler[ has joined #lisp
<|3b|>
depends on your definition of "possible" and "from lisp" :)
<k-hos>
from c from lisp
SaganMan has joined #lisp
<borei>
yeah, that is what im trying to avoid
<|3b|>
CL as specified doesn't have anything like that, but most implementations have some sort of lower-level APIs that would for example let you write asm or extend the compilers
<|3b|>
(in the "write asm/extend the compiler" range, but with some of the supporting parts already done)
hdurer[m] has joined #lisp
katco[m] has joined #lisp
dirb has joined #lisp
<borei>
wrapping my head - interesting reading
hiq[m] has joined #lisp
python476 has joined #lisp
CharlieBrown has joined #lisp
<|3b|>
there is also the option of using something like opencl on CPU... not sure if it would be any easier, but would at least be different problems :p
wxie has joined #lisp
<|3b|>
also, at that scale of matrix multiplies, you might want to start looking at algorithms that take better advantage of memory access patterns
pierpa has quit [Quit: Page closed]
<White_Flame>
borei: there's some game engine stuff out there in Lisp which does on-the-fly shader interactive coding while the program runs
fikka has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
Karl_Dscc has joined #lisp
LocaMocha has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 256 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
quazimodo has joined #lisp
wxie has quit [Ping timeout: 255 seconds]
mishoo_ has joined #lisp
Tobbi has joined #lisp
fikka has joined #lisp
vyzo has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 240 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
dec0n has joined #lisp
flamebeard has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
emacsoma` has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
emacsoma` has joined #lisp
impulse has quit [Ping timeout: 256 seconds]
deng_cn has quit [Quit: deng_cn]
vyzo has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
impulse has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
hiroaki has joined #lisp
vyzo has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
vyzo has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
mishoo_ has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
vyzo1 has joined #lisp
vyzo1 has quit [Client Quit]
vyzo1 has joined #lisp
vyzo1 has quit [Client Quit]
Chream has joined #lisp
vyzo has quit [Ping timeout: 276 seconds]
vyzo1 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
vyzo1 has quit [Client Quit]
vyzo has joined #lisp
varjag has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
angelo|2 has quit [Remote host closed the connection]
vyzo has quit [Remote host closed the connection]
shka has quit [Ping timeout: 240 seconds]
python476 has quit [Ping timeout: 255 seconds]
mingus has quit [Remote host closed the connection]
<jmercouris>
Ah right, the new clim curses backend lol
<jackdaniel>
why lol? either way, this tutorial is about cl-charms, not clim
<jmercouris>
I'm not laughing at you, don't get me wrong
<jmercouris>
I just fully appreciate the fact that it is possible for clim to be loaded into a terminal, blows my mind
<jackdaniel>
it can't right now
<jmercouris>
Ah well, the ascii demo made it look like
<jmercouris>
cool stuff
<loke>
Curses backend for clim would be cool, but kinda unfeasibile
<jackdaniel>
some concepts in tutorial are modeled after clim
<jmercouris>
that cursor you are moving, I assume it is with the keyboard right?
<jackdaniel>
no, real mouse
<jackdaniel>
read the post, you'll find out how to do that
<jmercouris>
and this is in a terminal?
<jmercouris>
man, mind blown
<jmercouris>
ok, will do, thanks :D
<jackdaniel>
loke: depends on use - displaying images or non-rectangular shapes won't be pretty for sure
<jmercouris>
charms looks like a pretty thin wrapper over ncurses
<jmercouris>
at least the commands look extremely similar to those I am familiar with in C
<jackdaniel>
it is. there is high-level interface, but it requires some work if you ask me
JenElizabeth has joined #lisp
<jmercouris>
jackdaniel: not sure if you are interested, but I found a small grammatical issue in your article
<jackdaniel>
and what would that be?
m00natic has joined #lisp
<beach>
jmercouris: The reason McCLIM uses CLX is that, when I wanted a GUI library for Gsharp (score editor), I wanted to have as little foreign code as possible, and CLX is mostly written in Common Lisp. That is also the reason why McCLIM exists at all. I was not willing to use any GUI library written in some other language.
aindilis has joined #lisp
flamebeard has quit [Read error: Connection reset by peer]
<beach>
jmercouris: So, I would be very unhappy, if the CLX backend was dropped in favor of a single SDL-based solution, since SDL is not Common Lisp code.
shifty has joined #lisp
solyd has quit [Quit: solyd]
wxie has quit [Ping timeout: 248 seconds]
flamebeard has joined #lisp
* |3b|
suspects a lot of the work involved in a SDL backend could be shared with a glop backend... not sure a glop backend would be all that good of an idea either though :)
<|3b|>
arguable whether it is as "pure cl" than CLX, since it does FFI on the user side rather than hidden behind implementation-specific networking APIs
jmercouris has quit [Ping timeout: 252 seconds]
<beach>
That actually looks appealing if what it states is true, i.e., that system functions are used directly.
<jackdaniel>
bookmarked
<|3b|>
it is on linux and windows. i think OSX needs a C or ObjC shim to work correctly
* |3b|
doesn't have any OSX though, so all my knowledge of that is second hand at best
<beach>
Well, if system functions are used directly, they could be hidden behind an abstraction layer that would allow someone to replace the FFI layer by some native implementation of the system functions.
flamebeard has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
<jackdaniel>
well, it didn't load here because "libxrandr" can't be find
<jackdaniel>
and probably that is about xrandr-dev files
<jackdaniel>
(speaking of not using c libraries)
<jackdaniel>
and after installing lib it loaded fine
<|3b|>
beach: well, arguably you could replace sdl bindings with lisp code too :)
<beach>
Sure. I suspect it would be a wee bit harder.
<beach>
I may be wrong of course.
orivej has joined #lisp
<|3b|>
probably depends on the sdl bindings
* beach
should be quiet since we are entering a territory of which he knows very little.
<|3b|>
i'm guessing that none of the options (glop or either of the sdl bindings) was particularly designed with that in mind though
* |3b|
is probably wrong too, and mostly speculating :)
<jackdaniel>
either way this is an interesting project
<jackdaniel>
thanks
<jackdaniel>
(for the link)
<beach>
It does look very interesting.
<|3b|>
yeah, not sure i'd completely recommend it at this point though
* |3b|
uses it, but doing so frequently makes me want to rewrite it :/.
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
groovy2shoes has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
groovy2shoes has quit [Client Quit]
<jmercouris>
beach: Ultimately CLX must have some non-lisp code if only to interface with the OS
<jmercouris>
makes some syscalls at least no?
groovy2shoes has joined #lisp
<|3b|>
CLX has lisp code, implementation has the non-lisp code inside its networking lib
<|3b|>
same way lisp code doing file IO calls non-lisp code inside the implementation
fikka has joined #lisp
smurfrobot has joined #lisp
EvW has joined #lisp
pfdietz has quit [Ping timeout: 260 seconds]
<jmercouris>
Okay, I see
<jmercouris>
so theoretically, CLX could be ported to every OS?
<|3b|>
shouldn't even need ported
<jackdaniel>
it will load even on windows
<jmercouris>
Then why the desire for SDL?
<jackdaniel>
given you have Xserver running, you can connect to it
<jmercouris>
because X is dying?
<|3b|>
most windows machines don't have X servers
<jmercouris>
you can bundle it in your application installer
<jackdaniel>
because X is default only on Unices (and wayland is slowly taking over)
<|3b|>
X programs tend to mix with 'native' things on windows even worse than GTK or whatever :p
<|3b|>
also hard to get good GL performance out of things using CLX (admittedly not something everyone cares about)
fikka has quit [Ping timeout: 240 seconds]
markong has joined #lisp
solyd has joined #lisp
Cymew has joined #lisp
papachan has joined #lisp
<Shinmera>
GLOP is a good idea, but unfortunately as it is right now it's pretty severely broken
smurfrobot has quit [Remote host closed the connection]
<jmercouris>
too bad it is broken, that does seem like a good idea
<Shinmera>
if I remember correctly on Windows it's a fixed size window that doesn't show in the taskbar and can't be moved (??), and on OS X it doesn't work at all on recent versions.
deng_cn has quit [Read error: Connection reset by peer]
* |3b|
doesn't have that problem on windows, possibly it has some bad defaults that i don't use though
<|3b|>
does have plenty of other problems though :)
smurfrobot has joined #lisp
<|3b|>
or possibly there are some ways of using its APIs that aren't as well tested
<Shinmera>
I don't remember doing anything out of the ordinary.
deng_cn has joined #lisp
<|3b|>
well, i'm not sure there really is any "ordinary" :p
* |3b|
isn't trying to suggest you didn't have problems, or that you did something unreasonable if you did... just that there is a way to use it that works
<|3b|>
and that way may or may not be an obvious one
<Shinmera>
It was also like a year ago, so I don't know what happened since then
<|3b|>
probably not much :)
<|3b|>
pretty sure i've been mostly on windows for longer than that
smurfrobot has quit [Ping timeout: 240 seconds]
* |3b|
should probably make sure i'm not using any important fixes that haven't been pushed
<Shinmera>
I can test it again later
<Shinmera>
cooking for dinner right now
<|3b|>
hmm, does look like there was stuff merged in jun 2017, so could be
dec0n has quit [Read error: Connection reset by peer]
<Shinmera>
The vsync stuff doesn't work and I'm aware of that, but the problems I encountered were independent of that
fikka has joined #lisp
<|3b|>
yeah, still seems to be something wrong with glop vsync stuff on windows
aindilis has quit [Read error: Connection reset by peer]
* |3b|
has it using dwm instead of wglSwapInterval where appropriate, but still not getting it initialized correctly somewhere i think
jameser has joined #lisp
aindilis` has joined #lisp
JenElizabeth has quit [Ping timeout: 252 seconds]
JenElizabeth has joined #lisp
dddddd has joined #lisp
nullman has quit [Remote host closed the connection]
nullman has joined #lisp
<|3b|>
Shinmera: i suspect your window would be created in wrong thread on OSX (if you manage to run glop on OSX in the first place), not really sure exactly what's going on there though
<|3b|>
and does look like someone removed asdf-install links from cliki, so probably hasn't worked in a while (and probably many of the links were dead by then anyway)
killerstorm has joined #lisp
openthesky has quit [Quit: Leaving.]
<tfb>
Cthulhux: LW's price is only insane if your time is very cheap (which, for someone doing something for themselves it is: I am not trying to suggest it's not expensive). It's less than four days of a contractor's daily rate for instance, so maybe 2% of their annual cost. If it makes them more than 2% more efficient it's paid for itself.
iqubic has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
<killerstorm>
Hi people, does anyone have experience with cl-yacc? Specifically, you do you deal with optional productions.
<killerstorm>
Manual says it's easy, but not how exactly to do it...
<beach>
killerstorm: I think drmeister used it. But he is very likely busy today.
<killerstorm>
I'm trying to fix a library which uses (empty) production as an alternative for optional productions. but that doesn't seem to work, and I think I know why...
<Shinmera>
beach: He used yacc straight up, not cl-yacc.
python476 has quit [Quit: b]
moei has joined #lisp
<beach>
Oh! Sorry.
<Cthulhux>
tfb: Lisp is a free time hobby for me, so I'm really not in a position to judge here.
<Cthulhux>
I just thought Lisp is not really "popular" enough anymore to justify this
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
<tfb>
Cthulhux: this probably doesn't belong here, but commercial SW that's not popular has to be expensive: if I sell only n copies of product x per year, I need to charge at least (salary + costs)/n per copy, and if n is small ...
SuperJen has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
SuperJen has joined #lisp
<Cthulhux>
I see a spiral here
deng_cn has quit [Read error: Connection reset by peer]
SaganMan has quit [Quit: WeeChat 1.6]
<Cthulhux>
Delphi was popular before it became too expensive, now it's rather dead(ish)
deng_cn has joined #lisp
mnoonan has quit [Remote host closed the connection]
<beach>
Cthulhux: That's why software is a winner-takes-all market. Bigger market share means price can be lower, which means increased market share.
__rumbler31 has joined #lisp
Tristam has joined #lisp
killerstorm has quit [Quit: Page closed]
smurfrobot has joined #lisp
Tristam has quit [Ping timeout: 240 seconds]
warweasle has joined #lisp
mishoo has quit [Ping timeout: 252 seconds]
python476 has joined #lisp
oleo has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 248 seconds]
<Cthulhux>
Which also means that it is weird that SBCL hasn't spawned an enterprise-grade IDE yet.
scymtym has quit [Ping timeout: 255 seconds]
<dlowe>
emacs already existed :)
<jackdaniel>
sbcl project goals was to get rid of all unnecessary baggage
<jackdaniel>
like X integration
<jackdaniel>
(which is still present in cmucl)
<jackdaniel>
so I don't think bundling IDE fits SBCL way of doing things
<Cthulhux>
Emacs is not really a business-grade IDE in my opinion.
<Cthulhux>
YMMV.
<|3b|>
it is probably closer than you would have gotten from sbcl devs by now :)
<beach>
Cthulhux: What does enterprise-grade and business-grade mean to you?
Okami has joined #lisp
<Cthulhux>
I thought the general opinion is that LispWorks is an "enterprise-grade IDE" which is why they can take "enterprise-grade prices"
<Cthulhux>
Emacs is obviously different
* |3b|
doesn't have that impression
<beach>
Is it "can be handled by developers with almost no training, neither in computer science, in software engineering, nor in programming"?
jmercouris has joined #lisp
<jmercouris>
I'm trying to come up with a good scenario for where you'd use hooks in your browser, so far I've come up with a ficticious scenario where every time you set a bookmark, you want to append the web page to a file on your computer with some keywords as part of a journal or something
<jmercouris>
this scenario will be used as part of a blog post promoting next, so any ideas that play to the strengths of CL and offer some wow factor are appreciated
<|3b|>
price is for support, gui libs and other libs, and running existing expensive code that depends on them :)
<beach>
jmercouris: CLX does have a small amount of non-Lisp code. But I don't see why you say that it would "have to".
<jackdaniel>
beach: does it? where?
<beach>
I think for opening the socket.
<jackdaniel>
I'm working with CLX for quite long now and there is no foreign code afaik
<|3b|>
jmercouris: seeing what the JS on pages is doing maybe?
<jackdaniel>
well, it uses implementation-specific functionality
<beach>
Oh? I am sure I have seen it.
<jmercouris>
beach: Well, it's not turtles all the way down is it? ultimately we have to interact with something that isn't lisp
<beach>
jmercouris: I don't see that.
<jmercouris>
|3b|: can you expand on that?
<beach>
jmercouris: Can you explain why you think so.
<jmercouris>
beach: sure, you have to have some knowledge of which syscalls are available on a system, those have to be embedded into your CL system
FreeBirdLjj has quit [Remote host closed the connection]
<jackdaniel>
beach: to my best knowledge there is no ffi usage nor foreign code (there are some implementation-specific bits of course)
<beach>
jmercouris: Right, so it could be all Lisp.
<beach>
jackdaniel: Let me look again, then.
<jmercouris>
You're the best kind of right in this case "technically" :D
<jmercouris>
I see it as still containing foreign code, but you are indeed correct
<jackdaniel>
jmercouris: clx "talks" with X server via a socket, it doesn't perform syscalls or library calls on it
<|3b|>
jmercouris: after running firefox for a while, it tends to take up lots of ram, and sometimes CPU. would be nice to be able to dig into things and see which pages are causing problems. or see which pages try to use various features (camera or webvr or whatever)
<jackdaniel>
and there were non-C X11 protocol implementations
<tfb>
jackdaniel: but it needs to be able to open a socket
<jackdaniel>
tfb: sure, for instance with sb-bsd-sockets:open-socket
<jackdaniel>
that's what clx does
<tfb>
yes, sorry, I was confusing implementation-dependence with foreign code, ignore me
rippa has joined #lisp
<jmercouris>
|3b|: That would be interesting, I'll keep that in mind, but for now I'm looking for a cool way to use hooks basically
nowhere_man has joined #lisp
FreeBirdLjj has joined #lisp
<|3b|>
jmercouris: yeah, that's what i meant (assuming your definition of hooks would let me do that sort of thing) :)
<jackdaniel>
beach: there are files two with ".c" extension but they are not loaded with the system (they are legacy files)
<jmercouris>
|3b|: You can hook into literally any type of function, question is moreso, how would I determine when to check, like after which events? every time I open a page? to issue a warning that a page has very slow js?
<tfb>
jmercouris: can you hook things in the way that (say) Stylish does / did, to control how things render?
deng_cn has quit [Read error: Connection reset by peer]
<jmercouris>
tfb: You may hook to literally any event, so you may inject css or js or whatever before a page load
<jmercouris>
not sure what stylish does, but that sounds like the idea
<|3b|>
jmercouris: yeah, now that i think about it, probably too late to use hooks by the time i decide i want to find out what's happening :/
<tfb>
right, well that's a terribly useful thing to do
<tfb>
ie 'I'm about to render something from Wikipedia.org, insert this CSS to make it look like I want'
<|3b|>
yeah, modifying styles and injecting (something nicer than) JS are useful features
dec0n has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
<jmercouris>
then you need something like an alist as well for different JS on different sites
<jmercouris>
I guess I could demo a mini version of that plugin
drewc has quit [Remote host closed the connection]
mishoo has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
<beach>
jmercouris: So I was wrong. CLX not only does not have to use foreign code, not even "technically". And it doesn't.
Jesin has joined #lisp
fikka has joined #lisp
solyd has joined #lisp
sjl__ is now known as sjl
attila_lendvai has quit [Quit: Leaving.]
<pjb>
that's the advantage of socket APIs…
<pjb>
Implementations provide "native" socket access, so you don't have to do any FFI.
heisig has quit [Quit: Leaving]
Jesin has quit [Quit: Leaving]
damke has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 265 seconds]
damke_ has quit [Ping timeout: 264 seconds]
markong has quit [Read error: Connection reset by peer]
billitch has quit [Ping timeout: 260 seconds]
markong has joined #lisp
deng_cn has joined #lisp
<Xach>
I am a little surprised by the implementation results.
fikka has joined #lisp
<Xach>
I'd like to make a chart of the trends over time. CCL and SBCL used to be closer (I think)
<phoe>
Xach: what's surprising?
<dlowe>
I've often thought that what would be neat would be an app server that was able to take a higher-level widget description with a socket protocol.
<dlowe>
I think tcl kind of is that, sort of.
<dlowe>
er, tcl/tk
<dlowe>
and web browsers more recently, though they're a bit overpowered for what I was thinking.
<Xach>
phoe: that sbcl is close to 10x more active, quicklisp request-wise, than ccl
<phoe>
Xach: active request-wise? what do you mean?
<phoe>
that you get 10x more projects running on SBCL than ones running on CCL also?
<jackdaniel>
people using SBCL download projects 10x more often than people using CCL
<phoe>
ooh, like that. I see.
lerax has joined #lisp
flamebeard has quit [Quit: Leaving]
<lerax>
Hey guys, how I can fetch all the symbols on a package? I know that I can use (apropos <string-designator> :package), but there is a string-designator like a wild card for all symbols?
<pjb>
lerax: but one use normally do-symbols and do-external-symbols
<lerax>
I liked this apropos-list, thanks pjb
<pjb>
lerax: however, (apropos-list "") is probably non-conforming: it wil give you results depending on the implementation.
<pjb>
Well, prehaps not. It may be ok.
<pjb>
Case-sensitivity and extensions such as regular expressions are implementation dependent.
<pjb>
But since "" is a substring of any symbol name, it should be ok.
sjl has quit [Quit: WeeChat 1.9]
sjl has joined #lisp
drewc has joined #lisp
dieggsy has quit [Ping timeout: 255 seconds]
porky11 has joined #lisp
aindilis` has quit [Read error: Connection reset by peer]
deng_cn has quit [Read error: Connection reset by peer]
kajo has joined #lisp
deng_cn has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<sjl>
jackdaniel: small typo in the charms tutorial post: in the First Application section it says it makes a 50x15 window, but the call is (charms:make-window 50 50 10 10)
aindilis` has joined #lisp
<sjl>
which I think is 50x50
<jackdaniel>
right, in code I have 50 15 10 10, thanks
jmercouris has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
<sjl>
In later code it's 50 15 10 10, I think it's just that one section
<jackdaniel>
right, already fixed, thank you
JenElizabeth has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
SuperJen has quit [Ping timeout: 255 seconds]
nowhereman_ has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
deng_cn has joined #lisp
smurfrobot has joined #lisp
HDurer has quit [Ping timeout: 264 seconds]
HDurer has joined #lisp
jmercouris has quit [Ping timeout: 255 seconds]
jmercouris has joined #lisp
khisanth_ has quit [Ping timeout: 240 seconds]
raynold has joined #lisp
Cymew has joined #lisp
smurfrobot has quit [Remote host closed the connection]
aindilis` has quit [Remote host closed the connection]
dieggsy has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
jmercouris has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
<Xach>
lerax: hello!
<Xach>
lerax: projects in ~/quicklisp/local-projects/ will be loaded before projects quicklisp provides itself!
<beach>
Hmm, no there is a method for it: documentation (x function) (doc-type (eql 'function))
<phoe>
look at the possible lambda lists for "Functions, Macros, and Special Forms"
<phoe>
Exactly.
kajo has joined #lisp
<phoe>
Not really a bug, because "An implementation is permitted to discard documentation strings at any time for implementation-defined reasons. "
<phoe>
but still confusing
Trystam has joined #lisp
Tristam has quit [Ping timeout: 240 seconds]
Trystam is now known as Tristam
<Bike>
documentation is unfortunately a function that does more than one thing
dieggsy has quit [Remote host closed the connection]
smurfrobot has joined #lisp
ig88th has joined #lisp
random-nick has quit [Ping timeout: 255 seconds]
JenElizabeth has joined #lisp
lonjil has quit [Quit: WeeChat 2.0.1]
d4ryus1 is now known as d4ryus
ig88th has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
<ecraven>
are any slime/swank developers here?
<jackdaniel>
most likely, why?
ovidnis has joined #lisp
<ecraven>
would it be possible to properly export swank::inspector-call-nth-action from swank, so that it is accessed by swank:inspector-call-nth-action (single colon)?
<ecraven>
I have a mostly-working swank for r7rs schemes, but :: does not work at all under kawa, its reader dies (it is used for type annotations there)
<ecraven>
I know that scheme is not at all a priority, but it would be a simple change and should not influence anything else much
<ecraven>
I can send a patch, if that helps
<jackdaniel>
I don't see technical problems with that - make a PR and see what maintainers say
<jackdaniel>
luis: are you around? ↑
<ecraven>
where should I send it? is there any place but the mailing list?
<ovidnis>
that's the version in the ubuntu artful repos
<ovidnis>
i'll see if there's a ppa with a newer version
<jackdaniel>
ah, it's even already exported, just call to it was clumsy
<ecraven>
jackdaniel: yes, maybe that was different before. I tried it locally, works fine
<ovidnis>
or, eh, i'll just get the bin
Kaisyu has quit [Quit: Connection closed for inactivity]
<Xach>
ovidnis: i usually download the latest binary if i'm starting from scratch, or build from git if i already have a binary
vtomole has joined #lisp
ovidnis has quit [Remote host closed the connection]
ovidnis has joined #lisp
<ovidnis>
hmm, still fails compiling static-vectors impl
<ovidnis>
on 1.4.4
Tobbi has joined #lisp
<jmercouris>
What is roswell?
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
<phoe>
theoretically, a Lisp implementation manager.
<phoe>
practically, it still tends to fail here and there, but it makes for a very nice SBCL installer.
JenElizabeth has quit [Remote host closed the connection]
<jmercouris>
why do we need it?
JenElizabeth has joined #lisp
<phoe>
I don't know
JenElizabeth has quit [Remote host closed the connection]
<phoe>
Some people like having a tool that can switch between different Lisp implementations and versions
<phoe>
Some people have a use case for it.
rumbler31 has quit [Remote host closed the connection]
<jmercouris>
I am having a real hard time imagining it
<jmercouris>
but whatever, live and let live :D
hiroaki has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 276 seconds]
fourier` has joined #lisp
ebrasca has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
<ebrasca>
Can I format 3 as "03" instead of " 3". I am using someting like (format t "~2x" i)
fourier` has quit [Client Quit]
<dlowe>
(format nil "~2,'0d" 5)
damke_ has joined #lisp
<dlowe>
well, it works for ~x too
BitPuffin has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
<ebrasca>
dlowe: Thank you.
damke has quit [Ping timeout: 264 seconds]
<phoe>
the "~N,'0D" format control is something I use so freaking often
vyzo has joined #lisp
vtomole has joined #lisp
hiroaki has joined #lisp
knicklux has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
ig88th has joined #lisp
borei has quit [Quit: Leaving.]
<shrdlu68>
When comparing two bit vectors with #'equal, I notice it does not immediately return nil if the bit vectors are of different lengths.
nowhereman_ has quit [Ping timeout: 256 seconds]
klltkr has joined #lisp
<Xach>
ovidnis: dang! what is the error message?
<Xach>
shrdlu68: "it"?
<shrdlu68>
Xach: #'equal, at least on SBCL.
nowhere_man has joined #lisp
<Xach>
shrdlu68: interesting. how did you observe that?
<Bike>
both the definition and transform for bit-vector-= check for length equality before looking at the actual bits, as far as i see
<shrdlu68>
Xach: By a method which I now realize is flawed.
<Xach>
shrdlu68: phew
fourier has joined #lisp
<fourier>
ebrasca: (format t "~2,'0d" 3)
fikka has joined #lisp
EvW has joined #lisp
fourier has quit [Changing host]
fourier has joined #lisp
Cymew has joined #lisp
Cymew has quit [Ping timeout: 252 seconds]
Okami has quit [Quit: mujeres libres!]
Cymew has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
mishoo_ has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
<stacksmith>
Greetings. Am I correct about this: if a macro has an optional or keyword parameter with an init-form, and the init-form relies on another parameter, such init-form needs to be backquoted with said parameter unquoted to expand correctly... Yikes.
Cymew has joined #lisp
<stacksmith>
Example: (demacro foo (a &optional (b `(+ 1 ,a))...)
shka has quit [Ping timeout: 260 seconds]
mishoo has quit [Ping timeout: 276 seconds]
<_death>
what about multiple evaluation
<stacksmith>
_death: there is that.
<_death>
it suggests that the interface may be wrong
vtomole has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 252 seconds]
<stacksmith>
It can be implemented with an conditional that selects one of two expansions - one using a provided parameter, another into a let form to evaluate it once, I suppose.
<stacksmith>
_death, I am not sure about the inference about the interface... Technically, one should be able to _use_ a macro or a function without knowing which one it is...
<ig88th>
where am I supposed to put .config/common-lisp/source-registry.conf.d/projects.conf on windows?
<ig88th>
I've tried my home directory C:\Users\ig88t\ as well as C:\Users\ig88t\AppData\Roaming\ (which is where emacs wants it's .emacs.d folder, so I thought asdf might be the same)
<pjb>
stacksmith: initforms are evaluated at the time of function (or macro) call.
<stacksmith>
ig88th: a question like that just invites abuse :)
<pjb>
stacksmith: this means, for macros, at macroexpansion-time, which is usually at compilation-time.
<Bike>
what? it's a reasonable question
<ig88th>
stacksmith: what do you mean?
<stacksmith>
Just kidding. I mean questions in the form of "where am I supposed to put ..."
fourier has quit [Ping timeout: 265 seconds]
<Bike>
The manual says "For Windows users, and starting with ASDF 3.1.5, start from your %LOCALAPPDATA%, which is usually ~/AppData/Local/ (but you can ask in a CMD.EXE terminal echo %LOCALAPPDATA% to make sure) and underneath create a subpath config/common-lisp/source-registry.conf.d/."
<pjb>
stacksmith: whether you need to quote or not the initform depends on what you what to evaluate!
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 248 seconds]
<ig88th>
Bike: awesome! is that the manual for asdf?
<ig88th>
Bike: I came across that page earlier but I guess I didn't check the footnotes! thank you!
<stacksmith>
pjb: indeed it does... A bit confusing with multiple evaluation issue, as it is not immediately obvious how many times ,a gets expanded..
<pjb>
stacksmith: and indeed, as _death mentionned, macros can be expanded any number of times, and not necessarily while compiling or intepreting (eg. they can be called by the editor or some other tools). Therefore expressions evaluated by the macros, including their initforms, must be prepared to be evaluated in strange environments.
<stacksmith>
pjb: - is there a preferred way to deal with this? I haven't seen anything mentioned about this... I suppose the wisest approach is to use &key to be certain about the argument being supplied, and expand a let form evaluating the original argument, then the 'optional one'...
_cosmonaut_ has quit [Ping timeout: 264 seconds]
z3t0 has joined #lisp
<pjb>
stacksmith: what's your problem? The specification is perfectly deterministic there.
orivej has joined #lisp
<pjb>
stacksmith: the only thing is that if your macro has side effects, then you must ensure that it still give the same results for it to be conforming.
smurfrobot has joined #lisp
<pjb>
You're given a lot of freedom, don't complain!
<stacksmith>
pjb: Not complaining at all! Just trying to understand if (defmacro foo (a &optional (b `(+ 1 ,a)) `(values ,a ,b)) should be implemented differently because of uncertainty about the number of ,a expansions...
<pjb>
stacksmith: in this case it doesn't matter, since (+ 1 a) will always return the same thing, without side effect. (loop with result repeat (1+ (random 10000)) do (setf result (+ 1 a)) finally (return result)) will always do the same thing as (+ 1 a).
groovy2shoes has quit [Quit: moritura te saluto]
<pjb>
Oh, but you mean, a could be bound to an expression with side effects.
<stacksmith>
yes
z3t0 has quit [Remote host closed the connection]
<pjb>
Yes, in this case, either you document your macro, and let the user deal with it, or you write it otherwise, so that the expression bound to A is evaluated only once.
<phoe>
(foo (incf a))
<pjb>
yes.
<Bike>
there's no uncertainty. if you pass one form, it'll be evaluated twice, if the + doesn't signal an error etc
<pjb>
Bike: macro calls can be evaluated more than once. if foo evaluates a once, then (foo (incf a)) may increment a 1 or more times.
<Bike>
LOCALAPPDATA no good, huh
<phoe>
take a look at ALEXANDRIA:ONCE-ONLY
<ig88th>
Bike: yeah LOCALAPPDATa doesn't seem to work for me
<stacksmith>
phoe: true, but I don't think it makes sense in the init-form...
shrdlu68 has quit [Ping timeout: 240 seconds]
<Bike>
honestly, having anything very complicated in lambda list defaults is unusual
<ig88th>
is anyone else here developing on Windows?
<phoe>
stacksmith: you'll need to pull the initform from the lambda list and put it in the body.
z3t0 has joined #lisp
<stacksmith>
phoe: I certainly do...
shrdlu68 has joined #lisp
fikka has joined #lisp
<stacksmith>
There is little advantage in macros having anything complicated in init-forms, I suppose. Functions in SBCL wind up having multiple entry points, for efficiency.
<Bike>
macro functions don't usually have to be efficient
hiroaki has quit [Ping timeout: 255 seconds]
<Bike>
unless you're doing something really weird, i guess
<pjb>
Depends on the complexity of the language/syntax implemented by the macro.
<Bike>
well, don't have to be efficient about something like calls
vtomole has joined #lisp
<Bike>
destructuring a list is chump change compared to compilation
<stacksmith>
I am surprised I haven't come across this - personally or in literature...
<stacksmith>
Again - not complaining, just amused by all things not written about concerning Lisp - it's been around long enough that when encountering an issue you _know_ you are not the first one.
<pjb>
stacksmith: it's assumed programmers have brains. There's no need to write all the trivial consequences and deductions.
<pjb>
And it would be misleading, since the applicability conditions would be bigger than the code involved!
jmercouris has joined #lisp
<jmercouris>
when I write :fish in CL, what exactly am I writing? what does the ":" symbol do?
<stacksmith>
keyword.
<pjb>
jmercouris: it's not a symbol. It's basic syntax of the symbols.
<pjb>
jmercouris: read the Chapter 2.
<jmercouris>
chapter 2 of...?
<pjb>
clhs
<_death>
jmercouris: it's just a shorthand for keyword:fish
<jmercouris>
_death: Thank you for the succinct explanation
<jmercouris>
I'm trying to explain the hook code I wrote in a blog post, and I'm trying to be accurate
<pjb>
you have to know the properties of the keyword package, to understand what :foo means.
<jmercouris>
I'm listening
<stacksmith>
pjb: It is possible I am a moron, and now that I see it clearly - it's not too complicated... However, there is much repetition about much more obvious stuff in Lisp literature - mentioning "watch out for macro init-forms" could not really hurt.
<pjb>
stacksmith: that said, there's a perspective problem here.
<pjb>
stacksmith: for people who've known lisp a long time and who've seen it evolve along the way, all those things are obvious.
<stacksmith>
pjb: it is pretty fucking obvious _now_ that I am so much wiser :)
<pjb>
stacksmith: for newbies, it may be surprising, and foremost, there may be a shorter path than to read all the historical document (it happens that I just like to do that, but it takes a lot of time).
<jmercouris>
aha, so we can use :fish in all packages
z3t0 has quit [Remote host closed the connection]
<jmercouris>
interesting
z3t0 has joined #lisp
<stacksmith>
pjb: however, when I converted a function to a macro having stayed up too long, not so obvious...
<pjb>
stacksmith: but it's hard for old timers to see what indications the new generations need to walk the short path. So you should take notes while you're doing it, and then write a tutorial for your fellow newbies.
<pjb>
stacksmith: well, keep the function, and call it from the macro ;-)
hiroaki has joined #lisp
<pjb>
(defmacro foo (args…) `(foo* ,args…))
<pjb>
basically.
<stacksmith>
pjb: with all due respect to you old timers - I no longer consider myself a newbie...
<stacksmith>
pjb - although I suppose it's all relative.
<pjb>
jmercouris: yes, the keyword package is a global resource, so it's useful to pass symbols across packages without having to export and import them.
<pjb>
jmercouris: on the other hand, since it's a global resource, you also need to be careful when using keywords.
<pjb>
jmercouris: for example if your library uses symbol-plist, it should not use keyword as keys, since other packages doing the same could be using the same keyword for different thing: collision. Instead, use a symbol from your own package.
<_death>
the clhs gives advice on when to use and not use keywords.. it's that great :)
<jmercouris>
clhs maybe reads easy for you guys
<jmercouris>
but feels super terse to me
<pjb>
stacksmith: yes, you're in the middle, the best place to better understand the needs of the newbies, and still with enough knowledge of lisp to explain them (and ask us).
<pjb>
stacksmith: perfect time to write a book or a tutorial ;-)
<jmercouris>
All the time I'm reading it and going "what the does that even mean"?
<_death>
jmercouris: what about cltl2
<jmercouris>
and I find myself going down a rabbit hole
<jmercouris>
_death: what is cltl2?
<pjb>
the pre-common-lisp book.
<_death>
minion: tell jmercouris about cltl
<minion>
Sorry, I couldn't find anything in the database for ``cltl''.
<pjb>
It's: Common Lisp The Language ed. 2
<stacksmith>
common lisp the language
<_death>
ignorant minion
<jmercouris>
lol
<pjb>
So it's interesting because it contains prose and explaination, but it's misleading because it's pre-CL, so it contains things that are not true in CL.
<pjb>
And it also gives you bad habit such as #'(lambda …) instead of just (lambda …).
<pjb>
But knowing that, you could still read it and profit from it.
<_death>
pjb: but it contains more elaborate explanations and I found it very useful to read when I started
<pjb>
Sure. You just have to take them with a grain of CL salt.
smurfrobot has joined #lisp
<jmercouris>
What's the best way to download the contents of a web page as a string in CL?
<phoe>
jmercouris: make a HTTP request with drakma, :want-stream t
<phoe>
then read from that stream until the end
<phoe>
or just drakma:http-request
<phoe>
it'll give you a string by default, or an octet-vector if it detects that the contents aren't human-readable (which it misinterprets, sometimes, for JS for example)
<_death>
it's an ill-conceived problem
<jmercouris>
http-request seems simpler
<jmercouris>
thank you
smurfrobot has quit [Ping timeout: 252 seconds]
<_death>
phoe: this behavior, by the way, I detest
porky11 has quit [Ping timeout: 265 seconds]
<phoe>
_death: I am with you there, it should either uniformly return octetstreams or uniformly return strings or signal things
<_death>
phoe: so I always use force-binary and do the encoding myself if I need it
<phoe>
just not this crazy thing
<phoe>
_death: yes.
<jmercouris>
it seems to have like 5 return values
<jmercouris>
how is that even possible?
smurfrobot has joined #lisp
<jmercouris>
multiple-value-bind
<jmercouris>
hmm
<jmercouris>
this is a part of CL I need to learn more about
<_death>
I also discovered the other day that dexador leaks connections unless you manually tell it to clear the pool.. it ate up all available file descriptors for the process so I did something like (sb-posix:close (+ 10 (random 1000))) (ok, not that smart, but you get the idea ;)
<_death>
just to get a free fd to save state..
smurfrobot has quit [Ping timeout: 248 seconds]
emaczen has joined #lisp
<emaczen>
Is there a condition for using up all the heap?
warweasle has quit [Quit: later]
<emaczen>
I am using SBCL
<emaczen>
and I wish to free a lot of memory and then "start over"
DeadTrickster_ has quit [Remote host closed the connection]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
smurfrobot has joined #lisp
<jmercouris>
Shinmera: I have an #<ELEMENT> how can I get the "innerHTML" of that?
<jmercouris>
plump:serialize does seem to in fact serialize the object, but I'd like a string of the inner html
<Bike>
emaczen: there's storage-condition, but it's hard to use normally.
<k-hos>
I assume the same applies to macros as well? would it be possible then to iterate over the arguments and emit code then for each one?
<Bike>
sure.
<Shinmera>
Sure
<jmercouris>
k-hos: yes
<jmercouris>
Shinmera: What is "thing"?
<Shinmera>
jmercouris: your thing
<Bike>
indubitably
<White_Flame>
macros are basically just functions that are called at compile-time, that take source code & return source code in sexpr format
<k-hos>
they will run anything that isn't quoted at compile time correct?
<jmercouris>
Shinmera: right, let's say I've started here: (defparameter docy (lquery:load-page "<html><body>Lol some text</body></html>"))
<k-hos>
or do I have that backwards
<Bike>
"anything"? like, their arguments?
<Shinmera>
That variable is freezing in the cold!
<White_Flame>
they will run, and their return value will be used as replacement source code for the original macro call
<jmercouris>
Shinmera: then I went here: (defparameter body (lquery:$ docy "body"))
<jmercouris>
so now I have an "element" object
smurfrobot has quit [Ping timeout: 256 seconds]
mishoo_ has quit [Ping timeout: 240 seconds]
<jmercouris>
but what is that exactly? how do I know which slots it has?
<jmercouris>
does it have an innerHTML slot?
karswell has joined #lisp
<Shinmera>
describe it?
nowhere_man has quit [Ping timeout: 248 seconds]
<White_Flame>
k-hos: so yeah, many times the body of a macro is just a sexpr template that runs embedded bits of code to transform the parameters to the output code
<jmercouris>
Ah, yes, let me try that
<jmercouris>
Okay, it says "Class: #<BUILT-IN-CLASS CCL::GENERAL-VECTOR>"
<White_Flame>
k-hos: including iterating over list-based parameters or the &rest of the argument list
<k-hos>
what can I use to get information about the variable arguments?
<jmercouris>
Shinmera: So I assume I have to pass around this vector to some other function to get the data?
<Bike>
the variable arguments are just a regular list
<jmercouris>
I just want to get "Lol some text"
<Shinmera>
jmercouris: You don't have an element, you have an array of elements.
<Bike>
(defmacro foo (&rest vargs) ...) say you have (foo a (+ 1 3) 9), then vargs is a list of the symbol A, the list + 1 3, and the number 9
<White_Flame>
k-hos: in (defmacro foo (&rest params) ...), or defun, params is just a normal list that you can take the length of, map over, etc
<Shinmera>
jmercouris: If you just want the text, and not the inner html, you can just use TEXT
<k-hos>
alright, thanks
<Shinmera>
If you want the inner HTML, call serialize on the children of the element.
<jmercouris>
Shinmera: I'm sorry, I'm a little bit dense, can you spell it out exactly?
z3t0 has joined #lisp
<stacksmith>
phoe: since you mentioned alexandria:once-only - do you know of a way to make the gensyms it creates ignorable?
<jmercouris>
What is text? like this? (lquery:$ (lquery:$ docy "body") "text")?
<Shinmera>
Why would I capitalise a string and not include quotes
<Shinmera>
If that was indeed what I meant
<jmercouris>
Maybe you meant a javascript function, and you are used to capitalizing things
<stacksmith>
LOL
<jmercouris>
IDK man, I have literally no idea, because I don't see a function TEXT within lquery
<Shinmera>
Why would I say anything about JS
DeadTrickster has joined #lisp
<jmercouris>
because the package is called lquery?
<Shinmera>
TEXT is like, literally in the docs and in the examples even!
<Shinmera>
Are you reading the same page as I?
<jmercouris>
I don't think we are reading the same page no
<aeth>
jmercouris: Does it support markdown, though?
<jmercouris>
Shinmera: o the arguments are evaluated in order?
nowhere_man has joined #lisp
<Shinmera>
jmercouris: Which arguments are you talking about
<jmercouris>
"foo" and bla
<jmercouris>
what are those entities exactly?
<aeth>
jmercouris: I use org-mode for lots of things but I find markdown to be easier for things that people have to read. (And I'd probably host the site in a public repo.)
<jmercouris>
aeth: It supports all input and output supported by pandoc
<aeth>
ah
<aeth>
So it's actually a Haskell application :-p
<jmercouris>
Lol sure
dxtr has joined #lisp
<jmercouris>
there's some logic about parsing post files and templates
<jmercouris>
only the body of my posts are actually ran through org mode
<Shinmera>
($ (a) (b "c")) <==> (b (a #()) "c")
billitch has joined #lisp
<jmercouris>
okay
<jmercouris>
that makes a lot more sense
<jmercouris>
why this strange syntax?
<Shinmera>
Because it's convenient and what jQuery does
<Shinmera>
Sort of.
<jmercouris>
Really threw me for a loop
<jmercouris>
thank you for explaining though
<Shinmera>
I don't think the docs are particularly unclear about how it works.
<_death>
aeth: I hacked a static blog generator with a friend some months ago.. it took two days or so to get something sane and workable.. I looked at coleslaw a while ago and it was similar
<Shinmera>
YOu can also just, like, macroexpand $ and see what it does
<jmercouris>
the docs aren't unclear
<jmercouris>
it is my mind that is unclear :D
z3t0 has quit [Quit: Leaving...]
<Shinmera>
Anyway, did you see the examples I posted that should answer your initial question or did you skip over that?
<aeth>
_death: It doesn't sound like a hard project (I already generate GLSL, which is a more syntactically complicated language), but it also doesn't sound like a good use of my time. I have 5 issues open, but if I translated all of my designs into feature requests in my issue tracker, it's probably closer to the 100 to 999 range.
<jmercouris>
I thought you were implying there were some examples in the documentation that covered it
<jmercouris>
I didn't read the documentation cover to cover, just looked through the API to try to figure it out
<aeth>
(Translating to time, I'd say roughly 2 years to completion)
<Shinmera>
aeth: That's just stream announcements.
<aeth>
ah
porky11 has joined #lisp
msb has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
<Shinmera>
Though I've been wondering if I should even bother posting those too since I don't really seem to get extra visitors aside from the regularls anyway
<Shinmera>
*regulars
<aeth>
Keep posting. r/lisp is one of the few Lisp places on the Internet
<aeth>
It needs content
msb has quit [Ping timeout: 256 seconds]
Murii has quit [Quit: WeeChat 1.4]
pmc_ has joined #lisp
<phoe>
^
LiamH has quit [Quit: Leaving.]
<shrdlu68>
What was that function for reporting memory stuff in an implementation-defined manner?
<shrdlu68>
Kind of like "free" in bash.
<shrdlu68>
Oh, #'room.
<rme>
ccl has ccl:object-direct-size and ccl:heap-utilization as well as regular old room.
<Shinmera>
SBCL recently got a function to get the size of an object. Can't recall what it's called, though
<sjl>
sb-introspect::object-size
<sjl>
it's not external, so probably not meant for general use (yet?)
<shrdlu68>
Does an N-bit unsigned-integer consume as much memory as an N-bit simple-bit-vector?
<phoe>
shrdlu68: depends
<phoe>
integers can be bignums
<phoe>
integers would most likely be stored in boxes, be it fixnums or bignums, and vectors also need boxes
<Shinmera>
On the other hand a simple-bit-vector might not fit into a register.
<phoe>
so I'd think it's... hm, don't know
<Shinmera>
Either way
<Shinmera>
the answer, as always, is: test it
<aeth>
Oh... As far as forum-style things with Lisp content, I'm aware of comp.lang.lisp, r/lisp and r/common_lisp on reddit, the lisp and common-lisp tags in stackoverflow, and at least one traditional-style phpBB forum (the one I can find right now is LispForum, but I'm not sure if there is more than one because all phpBB looks the same). If anyone wanted me to elaborate on "one of the few Lisp places"...
damke has joined #lisp
<pjb>
There are several country-specific lisp newsgroups too.
<pjb>
eg. fr.comp.lang.lisp, etc.
<rme>
I miss when comp.lang.lisp (and usenet generally) wasn't a cesspool.
* shrdlu68
should start one for his country
jonh has joined #lisp
<aeth>
Only reddit (and maybe comp.lang.lisp if it's major?) seem suitable for announcements rather than tech support
<pjb>
But gavino and other spammer essentially killed usenet.
<phoe>
this is pretty experienced shitposting indeed
<aeth>
pjb: you're not kidding, gavino is... all but one of the February content (as far as thread creators goes)
<pjb>
Yeh, he's been at it for more than 10 years!
<rme>
I really think he (and others like him) must be mentally ill.
<phoe>
how can you kill that which has no life
damke_ has quit [Ping timeout: 264 seconds]
<aeth>
People who actually spend time doing other things cannot possibly compete with someone who literally lives on the Internet.
<Shinmera>
Is this the time to mourn Naggum?
<pjb>
Yes, he's like the neutron star replicator bots in StarGate Atlantis.
<pjb>
Or like the end-of-universe replicator boots in Andromeda.
<shrdlu68>
Hmm, why isn't SBCL cleaning up some unused heap space?
<aeth>
pjb: One day, all of the content on the Web will be created by spam bots and trolls (and it will be increasingly hard to tell them apart) as people move on to the next thing.
<pjb>
shrdlu68: it doesn't need. He's got 99% of the downloads ;-)
<aeth>
(And the precedent for this prediction *is* Usenet.)
damke_ has joined #lisp
<pjb>
aeth: might occur sooner than later. I'm already envisioning the day I'll disconnect.
vtomole has quit [Ping timeout: 260 seconds]
<pjb>
I'm confusing, I mean another story than Andromeda…
damke has quit [Ping timeout: 264 seconds]
<pjb>
Right; LEXX!
<aeth>
I've already stopped using a lot of the Web because it has lowered in quality to essentially nothing. e.g. I don't read news articles anymore. (And it doesn't help that a significant fraction of shared news articles aren't even available without a paywall... The WSJ is probably the worst offender here. People probably share it based on the headline alone.)
<pjb>
It's in LEXX that theuniverse is close to its destruction by replicating boots.
<aeth>
But I just go to other websites instead. Nothing has really threatened it except apps, which are like modern websites, but worse and without easy adblocking.
pareidolia has joined #lisp
<pjb>
git, youtube, wikipedia; that's about it.
<shrdlu68>
After I run a function, #'room tells me that there are all these objects taking up memory that weren't there before.
<shrdlu68>
Why isn't the space being recycled?
openthesky has joined #lisp
openthesky has quit [Client Quit]
<aeth>
shrdlu68: disassemble that function and look for allocations, which is especially easy in SBCL
__rumbler31 has quit [Ping timeout: 240 seconds]
<pjb>
shrdlu68: because the garbage collector is only called when the memory is full.
<aeth>
No need to guess with things like room, you can get exact results with disassemble or sb-profile (one method reads and looks for allocations, the other detects consing)
<pjb>
shrdlu68: also, if you work in the REPL, the variables * ** *** / // /// - + ++ +++ keep references to previous stuff.
<pjb>
shrdlu68: even dynamic-extend data doesn't need to be collected on exit.
<aeth>
pjb: but would that show up in room? I don't think it does
<shrdlu68>
That might be it, because running the function twice with the same large input exhausts heap the second time.
DeadTrickster has quit [Read error: Connection reset by peer]
DeadTrickster has joined #lisp
<aeth>
shrdlu68: Is it possible to preallocate something and setf parts of that preallocated thing?
<pjb>
aeth: right dynamic-extend data should not show in room outside of the scope.
<aeth>
You could even make it external to the function, put it in a *foo* and recycle it each call. (foobar *foo* 1 2 3) or something
<shrdlu68>
aeth: Possibly, by modifying some code.
<pjb>
shrdlu68: perhaps you are mutating (and adding references) to persistent data.
nowhereman_ has joined #lisp
nowhere_man has quit [Ping timeout: 248 seconds]
sjl has quit [Ping timeout: 260 seconds]
<shrdlu68>
The function creates a large hash-table, but it's not persistent. Should not be around after the function exits.
<pjb>
shrdlu68: you can also call the garbage collector in most implementations.