<mfiano>
maphash cannot be faster than loop as they are only specifications for implemention. however sbcl does behave significantly faster with maphash than loop
<caltelt_>
pillton: thanks for the link, I'll have to see what other goodies are in there I might be missing out on
skapata has joined #lisp
FreeBirdLjj has joined #lisp
<Xach>
NO
<Bike>
no?
<Xach>
try sb-ext:set-sbcl-source-location
<Xach>
oh i see it in small print
<Bike>
pillton has already maintained your honor
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<pillton>
I find the SBCL manual hard to read now. I must be old.
<Beep-Lord>
I have a DEFINE-SETF-EXPANDER that takes two CFFI C variables. When I get the store variables for both of the places, the evaluate to the same GENSYM'd symbol. Is this intended behavior?
<Beep-Lord>
s/the evaluate/they evaluate/
<Bike>
store variables are usually gensyms. i'm not sure i understand the question though.
<Bike>
You mean the store variables returned by (get-setf-expansion [some cffi place])?
<Beep-Lord>
I have two separate CFFI vars that have the same gensym'd symbol
sz0 has quit [Quit: Connection closed for inactivity]
<Beep-Lord>
Yeah, by that function
<pillton>
Beep-Lord: Are you using cffi:mem-ref or cffi:mem-aref ? What do you mean by CFFI C variables?
<Beep-Lord>
CFFI:DEFCVAR
<Bike>
so you get back like (#:G19) and (#:G19), and they're actually eq symbols?
<Beep-Lord>
That's what the macroexpansion says
<Bike>
macroexpansion?
<Beep-Lord>
C-c RET in SLIME.
<Bike>
macroexpansion of what?
<Beep-Lord>
Of a (SETF FOO)
<Bike>
what is foo... maybe you should just paste some code.
<Bike>
so you're saying (eq temp-store-1 temp-store-2) => T?
<Beep-Lord>
Yes
<Beep-Lord>
I could set them both separately, but this behavior seems weird to me.
<Bike>
it is strange.
<Bike>
incidentally, what is the point of your store? That seems messed up.
caltelt_ has quit [Ping timeout: 240 seconds]
megalography has quit [Ping timeout: 240 seconds]
<Bike>
defcvar apparently makes the variables symbol macros for a function call, including a setf function
<Beep-Lord>
Yeah, it does
<Beep-Lord>
But I have a mess for parsing the registers and I'm working around it until I think of a better way to refactor it.
Oladon has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
<Bike>
on my sbcl, with basic setf function accessors i get two distinct symbols that happen to have the same name
Oladon has joined #lisp
eschatologist has joined #lisp
<Beep-Lord>
What version are you on?
<Bike>
1.3.15. lil old.
<Beep-Lord>
I'm on 1.3.14 on Debian
<Bike>
are you sure that they're eq and not just named the same?
<Beep-Lord>
No, they set the same place though.
<Bike>
...huh??
<Bike>
they're just variables. they don't set anything
Tordek has quit [Ping timeout: 255 seconds]
<Beep-Lord>
If I set the second variable, it sets the first too.
vert2 has quit [Ping timeout: 264 seconds]
vert2 has joined #lisp
<Bike>
i think you might be confused about how setf works.
caltelt has joined #lisp
<Bike>
you don't set the variables. setf does. they're just the variables used by the storing form.
bend3r has quit [Ping timeout: 255 seconds]
<Bike>
this is why i asked you about your 'store' symbol. i don't think this setf expansion is sensible.
<Beep-Lord>
What would be a better way?
Kundry_Wag has quit [Ping timeout: 276 seconds]
<Bike>
let me see if i understand what you want to do. reg1 and reg2 are places holding 8 bit unsigned integers. (pair reg2 reg1) is the sixteen bit integer that is their concatenation.
<Beep-Lord>
Yes
<Bike>
(setf (pair reg1 reg2) one-value), where one-value is a sixteen bit integer, results in reg1 being set to the high byte of one-value and reg2 to the low byte of one-value.
fikka has joined #lisp
vert2 has quit [Remote host closed the connection]
<Bike>
setting two places based on one value.... lil weird. I think I would do, uh
megalography has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<aeth>
You don't need define-setf-expander for that. defsetf will work and is simpler
<Beep-Lord>
Well, both the upper and lower byte end up being the same value.
<Beep-Lord>
I just assumed they were eq because of that, I guess
<Bike>
your expansion ignores the value it's actually passed, so it has screwy behavior of some kind
edgar-rft has quit [Quit: edgar-rft]
Tordek has joined #lisp
bend3r has joined #lisp
Beep-Lord has quit [Ping timeout: 245 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
Kundry_Wag_ has joined #lisp
Beep-Lord has joined #lisp
quazimodo has quit [Ping timeout: 264 seconds]
dddddd has quit [Remote host closed the connection]
quazimodo has joined #lisp
megalography has quit [Ping timeout: 264 seconds]
zachk has quit [Quit: Leaving]
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
pierpa has joined #lisp
acolarh has quit [Ping timeout: 256 seconds]
graphene has quit [Remote host closed the connection]
markoong has quit [Ping timeout: 268 seconds]
graphene has joined #lisp
housel has joined #lisp
megalography has joined #lisp
<Beep-Lord>
Bike, I've got it sorted out now. Thanks.
<Bike>
great
<Beep-Lord>
I was ignoring the value I was passed just as you said.
CrazyEddy has joined #lisp
acolarh has joined #lisp
graphene has quit [Remote host closed the connection]
shifty has joined #lisp
graphene has joined #lisp
terpri has joined #lisp
robotoad has joined #lisp
fikka has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
mathZ has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
brettgilio has joined #lisp
buffergn0me has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
robotoad has quit [Remote host closed the connection]
Pixel_Outlaw has joined #lisp
Kundry_Wag has joined #lisp
Jesin has quit [Quit: Leaving]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
Jesin has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
Lord_Nightmare has quit [Ping timeout: 256 seconds]
rpg has joined #lisp
fikka has joined #lisp
nicht has joined #lisp
nicht has quit [Max SendQ exceeded]
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
Lord_Nightmare has joined #lisp
smaster has joined #lisp
Beep-Lord has left #lisp ["WeeChat 1.6"]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ealfonso has joined #lisp
<ealfonso>
how do I make a lisp text file executable? When I use !#/usr/bin/sbcl --script, the quicklisp user file is not loaded and I get "package ASDF does not exist."
<ealfonso>
can I avoid hard-coding the location of the user init file?
<Bike>
the --script option turns off the init files
<ealfonso>
yeah. so I want exactly the script option, but without turning off the init files, and something that is a single argument so it can be used in the interpeter line
<ealfonso>
I guess this is not possible
AetherWind has joined #lisp
<ealfonso>
I wanted to avoid either wrapping this script in a shell script, or hard-coding the location of the user init file
<ealfonso>
I guess I can manually load ~/.sbclrc and still use --script
<Bike>
the manpage explains what options --script implies
<Bike>
so you can just put those sans the ones abrogating initialization
<ealfonso>
yes, but can I use more than one argument in an interpreter line
<ealfonso>
another problem is that this exits when threads are still alive (e.g. http server handler threads)
brettgilio has quit [Remote host closed the connection]
krid has quit [Ping timeout: 248 seconds]
<White_Flame>
you should be able to (require 'asdf) from inside --script as well
<White_Flame>
plus, if you have quicklisp installed in your .sbclrc, that's only 1 or 2 lines to copy in if you want to init quicklisp, however it's a hardcoded path
Kundry_Wag has joined #lisp
eschatologist has joined #lisp
<White_Flame>
the commandline & parameters are in sb-ext:*posix-argv*, which is in the sbcl manual as well
<White_Flame>
so you should browse through the various sections on commandline args, creating executable images, and OS extensions
smaster has quit [Ping timeout: 255 seconds]
<White_Flame>
there are also small portability libraries that help you access OS specifics like that; UIOP is one and is part of ASDF, so it should be readily available
<ealfonso>
White_Flame hardcoded path may work for me in one machine but may break. also (require 'ql) doesn't work. I've used buildapp, I was looking for a simple, somewhat "portable" way to create a script from a lisp source text
Kundry_W_ has joined #lisp
<White_Flame>
REQUIRE from a raw --script only sees implementation built in stuff
<White_Flame>
QL isn't loaded that way. If you look at your sbclrc, you'll see how it's loaded, by specifically pulling in a .lisp file from your ql directory
<ealfonso>
White_Flame yes, but it seems very system-specific
<White_Flame>
well, you were asking about sbcl :)
<White_Flame>
there are toos like cl-launch for shell scripting lisp a bit easier, but I'm not sure what the latest & greatest of those is currently
<ealfonso>
yeah. I can take a python script and just run it. I don't need to worry about interpreter line, or about the paths of user init files, etc... I wish this was possible with sbcl
skapata has quit [Read error: Connection reset by peer]
<White_Flame>
it's the same thing
<White_Flame>
if you want it "with SBCL" you can certainly do that
<White_Flame>
and Python has its own environment variables, executables on the path, and other things that it needs, too
<White_Flame>
especially once you get into pip and venv
<White_Flame>
and the whole python2 vs python3 separtion
<White_Flame>
python is a real pain to run varieties of scripts from
Kundry_W_ has quit [Ping timeout: 268 seconds]
<White_Flame>
if you hardcode it to your own personal directory, then it's easy
<ealfonso>
yeah. I still wish I could take a run.lisp script and add a simple interpreter line and just run it, even if sbcl specific, and be able to send this run.lisp to a collage without relying on them having anything in their personal directories or init files
<ealfonso>
colleage
brendyn has joined #lisp
<White_Flame>
again, it's just as painful as if you send them a .py file that wanted a bunch of dependencies
<ealfonso>
colleague
<ealfonso>
White_Flame with setuptools they can simply clone a repo, and issue "python setup.py --install"
<White_Flame>
....right
<pillton>
How did we go from sending a single file to cloning repos?
<White_Flame>
at least with QL, a single launch can pull down everything needed wthout a separate step
<ealfonso>
White_Flame yes. I guess maybe I just wish QL was officially supported to remove the burden of loading ql
<ealfonso>
from the scripts
<White_Flame>
right, the --script option in sbcl is older than quicklisp
<pillton>
Just create an executable containing quicklisp.
<White_Flame>
actually, looking at the ql init stuff from my .sbclrc, it's not a hardcoded path. It reads from (user-homedir-pathname), so it's safe to deploy unless they did weird customization to their QL install
rumbler31 has joined #lisp
<White_Flame>
just copy those lines out into your script if you want QL
<ealfonso>
pillton I appreciate it, but my goal is not just to create an executable, but to simulate the ease with which python and bash can define executable scripts as text files
<pillton>
sbcl-ql is just SBCL with QL already loaded. You can invoke it the same way you invoke SBCL.
<ealfonso>
not just for me, but especially for others who may just want to execute a simple text file
<White_Flame>
(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname))) to reduce it to its minimum
<White_Flame>
but still, python is NOT easy to define executable scripts
<White_Flame>
there's a ton of environmental baggage
Bike has quit [Ping timeout: 260 seconds]
<ealfonso>
White_Flame yeah, I could do that. but it is really a hard-coded path, and doesn't feel right to make assumptions about where/how ql has been installed on a system
<ealfonso>
White_Flame and I agree about the python 2 vs 3, especially with some OS package managers, but for the most part, I can take a python file and execute it
<White_Flame>
I've written a bunch of python utilities that are called from Lisp and other launchers. Deployment is always a nightmare
rumbler31 has quit [Ping timeout: 256 seconds]
<White_Flame>
ensuring all the envvars are intact, ensuring it's in the right venv container, ensuring libraries are already installed, etc
<White_Flame>
lisp is much more self-contained. of course, it has a heritage as an OS
<ealfonso>
yeah, I do like that. But maybe I look forward to ql or something similar being officially supported like asdf is. or at least to be able to write "#!/usr/bin/sbcl --script" and get the expected behavior, including the script not exiting when there are live daemon threads
<White_Flame>
hmm, does sbcl even make a distinction between daemon and non-daemon threads?
<White_Flame>
also, organized user shutdown barriers are a good thing in general with multithreaded programs
pierpa has quit [Quit: Page closed]
<ealfonso>
I was basically trying to replace a bash-script wrapper of a single sbcl command to basically load an .asd file and start a hunchentoot service, with a lisp file. But even after loading ~/.sbclrc explicitly, it didn't work because the script exited right away
<ealfonso>
I'm assuming it is one of the implications of --script, I don't understand which one. In the end, I gave up and returned to the bash script wrapper
<ealfonso>
<White_Flame>
"Causes the system to load the specified file instead of entering the read-eval-print-loop, and exit afterwards. "
<White_Flame>
how would you expect/wish to shut down your server, Ctrl-C?
rpg has joined #lisp
<ealfonso>
I guess I don't really expect to shut it down and I expect the http service to run "forever", but I expect to be able to kill the process like any other or interrupt the foreground job on the terminal, etc
Kundry_Wag has quit [Ping timeout: 268 seconds]
rpg has quit [Client Quit]
shifty has quit [Ping timeout: 255 seconds]
robotoad has joined #lisp
<White_Flame>
a simple (loop do (sleep 1)) is breakable via Ctrl-C from a --script launch
<White_Flame>
but any actual server/daemon should ideally have a proper shutdown request mechanism
<White_Flame>
(though I'm pretty sure you can intercept SIGINT to trigger that, too)
<ealfonso>
yeah, I was thinking of that but I didn't try it, it does work, but it feels like another hack, just like manual ql loading via hard-coded path. I know my coworkers, who don't know anything about lisp, will be skeptical if I ask them to run a script containing (let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))) (when (probe-file quicklisp-init) (load quicklisp-init)))
<White_Flame>
if they didn't know python, would they be comfortable running a bunch of pip install or python setup.py steps beforehand?
<ealfonso>
I guess I could support providing quicklisp/setup.lisp path via env var, but it feels like it's something that sbcl itself should handle eventually
<White_Flame>
especially if sudo is involved
<White_Flame>
also, if you have a long-running .py script, Ctrl-C also dumps out a stack trace, too
<ealfonso>
well, there are options for the end-user to configure pip, and the developers don't have the burden of figuring out where in the system are the init files
<ealfonso>
I don't mind the stack trace, but I don't need to introduce an infinite loop in a python script that runs a rest service
<White_Flame>
ql is in a well-known place
<White_Flame>
it's not somethign that floats around like pip and venv
<White_Flame>
as a general theme, python makes the easy easy
<White_Flame>
that's why it got so popular
<White_Flame>
but at some point, it just turns into whining that something isn't exactly python, and things "should" magically hbe
<White_Flame>
*be
<ealfonso>
maybe CL would be more popular if it was easy to write scripts and distribute them
<White_Flame>
CL hasn't historically focused on cmdline scripting
<White_Flame>
it's REPL-oriented
<White_Flame>
consequently, a Lisp user has a bajillion complaints about the utter weaknesses of python's repl and how you can't do half the things in it that you can from python files, so it sucks
<White_Flame>
why can't it do what lisp can?
SeinfeldS07E22 has joined #lisp
<White_Flame>
also, where are the pointers? as a C programmer, this language sucks
<White_Flame>
etc
fikka has joined #lisp
<ealfonso>
I don't see cmdline vs REPL as a conflict, an end-user could run an executable script, and possibly fall-back into REPL if trouble arises. I see no inherent reason why a simple script couldn't be written in CL like python/bash scripts are.
<White_Flame>
the "lisp way" is to start your lisp, then load in your script
<White_Flame>
that's what end-users do
<White_Flame>
and all the environment is there
<White_Flame>
python isn't REPL oriented. As you say, it's just a fallback and a bit of a testing playground
<White_Flame>
and yeah, there's SBCL --script, there's cl-launch, deploying executables, and all other manners of getting Lisp running on a deployment
<ealfonso>
just like a python program may be a small single-file script, or it may be a large package, either one is supported. yeah, but I don't see being REPL-oriented as an impediment to being script-friendly
<White_Flame>
it's just different to what you're used to
<White_Flame>
nothing in python should be an impediment to being REPL-friendly, but it's not REPL friendly nonetheless
<ealfonso>
it is different to what I'm used to and from what most people are used to, and it is not as convenient
<White_Flame>
the convenience is all there, and it's more convenient than python
<White_Flame>
by literal example here
<White_Flame>
you're just used to the inconveniences of python s simply being the cost of doing business there and don't see it
fikka has quit [Ping timeout: 264 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
<ealfonso>
All I can say is that I wish I could write a single-file script in CL as easily as I do in bash or python
<White_Flame>
you can
<White_Flame>
and without all the massive environmental setup that python requires
<White_Flame>
literally the only idffernece is that you're used to the massive python machine that you're blind to its configuration complexity
<White_Flame>
so the differences to lisp happen to stick out to you more
<ealfonso>
as a user, all I see is ./script.py, and as a developer, all I see is chmod +x ./script.py and adding !#/usr/bin/env python as the first line
<ealfonso>
the same for bash
<White_Flame>
also, if your shared work environment with the people you're sending scripts to is already established, then you already have a sunk cost invested in settling on a very specific configuration that lets you "just launch a script" because all the prepwork is already done and assumed to exist in the environment
<White_Flame>
how does running a ./script.py pull in dependencies that are not installed in your system?
<White_Flame>
I mean, I'm not super familiar with python admin, so there might be a way
<White_Flame>
but I do know that QL will do that
<White_Flame>
it's a very basic scenario
<White_Flame>
especially when you're focusing on literally a single script file
<ealfonso>
I was comparing single-file script in python, where I can import some standard libraries like re, etc, whereas in CL I probably need to load QL to then load cl-pccre, etc
<White_Flame>
yes, python has a larger stdlib
<White_Flame>
but you often need to reach outside of it, even for single-file scripts
<ealfonso>
even with non-standard dependencies, I can still simply ask users to issue python setup.py --install
<White_Flame>
ah, exactly
<White_Flame>
externalized sunk cost infrastrctural complexity that you assume is already part of the environment
<White_Flame>
and if it's setup.py scripts, then it's not even integrated with the environment like pip
<White_Flame>
but anyway, yes, the user needs a bit of stuff installed
<White_Flame>
lisp seems to offer less complexity, but you have to literally add in one short line to load QL
<White_Flame>
QL is relatively new to the ecosystem, and didn't come from the implementations
<White_Flame>
Python is also a dictatorship model, not a distributed industry
<White_Flame>
but none of these really matter to the issue; you find offense in one particular nit to pick
<White_Flame>
so whatever, if your preferences preclude you from using lisp for such a small thing, I'm not going to sit and try to convince you
charh has quit [Ping timeout: 245 seconds]
<ealfonso>
setuptools it is built-in and bundled with python, whereas I would need to ask users to install QL, and then I may need to make assumptions about where it was installed and just hope the assumption is right, all while adding extra code to every script
jinkies has joined #lisp
<White_Flame>
and that's inflating the problem
<White_Flame>
if I don't have a current python, you'd expect me to upgrade a bunch of stuff
<White_Flame>
you're waging a religious war at this point. The specifics are negligible
<White_Flame>
and it's merely the specifics and pragmatics I wished to communicate
<ealfonso>
I've never had to upgrade python. I appreciate your points, but I still look forward to a future where there is less overhead and less guessing, it doesn't have to be dictatorial, but let's be honest, everyone uses QL
nsrahmad has joined #lisp
nsrahmad has quit [Read error: Connection reset by peer]
<White_Flame>
and everyone uses QL in the default location that QL installs to
<White_Flame>
it's a standard load/init process
<White_Flame>
the one place that differs is local-projects, but that's under user control anyway
<pillton>
Couldn't you just ship the setup.lisp that QL offers?
<ealfonso>
I really dislike having to make an assumption that something exists on a hard-coded path in an unknown system, and having my script fail it that assumption fails
<ealfonso>
pillton maybe, but that's adding more overhead to me as a developer
<White_Flame>
python breaks on the assumptiuon that dependencies are installed, too, unless the user runs some external configuration
<pillton>
What about /usr/bin/env?
<White_Flame>
I don't think either python or QL use that. I do see node stuff in mine, though
<White_Flame>
then again, our python usage is through venv, as it's a nightmare without
<White_Flame>
(and a hairball of complexity with)
<pillton>
I'm sure python stuff hardcode links to shared libraries like some libraries in QL do.
<White_Flame>
you start venv relative to some known directory, and it has .venv/ or something it drops its things into
<White_Flame>
however, I believe venv, pip, and python have "default" global system-wide isntallations as well. It's just dangerous to do that
<White_Flame>
It smells like ealfonso is in that sort of scenario, though, where there's a very fixed assumption of what "python" is and means on their installed machines
shka_ has joined #lisp
<ealfonso>
most of this could be solved if sbcl had a flag similar to --script respected the user-init. at that point, it is the user's responsbility to have installed QL, which is supposed to add lines to user-init, and not the script's author
<ealfonso>
s/respected/that respected
<ealfonso>
s/it is the/it would be the/
<White_Flame>
even if --script pulled in .sbclrc, if they hadn't installed QL, it would still fail (unless you bundle in quicklisp.lisp as pillton mentioned, which doesn't make it a "simple" script anymore)
SeinfeldS07E22 has quit [Quit: Leaving]
<White_Flame>
certainly having a baseline environment is expected. But at least the expectation is only QL, not the individual packages it installs
<White_Flame>
ie, no external apt get, pip install, setup.py, npm install, etc is necessary before launch. QL will lazily do it
<ealfonso>
White_Flame yeah, but at that point it would be the user's fault if they haven't installed QL
orivej has quit [Ping timeout: 276 seconds]
<White_Flame>
just like everything else
<White_Flame>
I really dont' understand the argument anymore
<White_Flame>
as I said before, I'm interested in communicating the specifics & pragmatics so you know how to launch things and how it compares technically to launches in other langauges
<ealfonso>
loading ~/quicklisp/setup.lisp manually on every script is basically to duplicate part of the quicklisp installation process.
<White_Flame>
no, that's the QL startup, not the installation
<White_Flame>
it's equivalent to (require 'asdf) or import foo
<ealfonso>
White_Flame that's fair. but as the final step of installation, QL knows where it has been installed better than any script that doesn't know anything about the system
<ealfonso>
and offers an option to automatically add some lines to user-init
<ealfonso>
my whole point is that finding and loading QL should be a burden of the user, not of the scripts
<pillton>
Can't you just require your users to use an executable with QL bundled in?
pierpal has joined #lisp
<ealfonso>
pillton so now on my README it is not just, "obtain sbcl: http://www.sbcl.org/", but something probably more complicated and less standard
<White_Flame>
of course, that's what you originally asked about and were answered
<beach>
Good morning everyone!
<White_Flame>
and again, the 2nd answer points to cl-launch as a solution for simplifying shell scripting if you're not working with REPL users
<ealfonso>
White_Flame basically loading ql via ~/quicklisp/setup.lisp is not acceptable to me, even if I had to ask users to install quickload. (require 'ql) would be
<White_Flame>
again, that's a religious war. If it's too offensive to you, I won't try to convince you
<White_Flame>
use cl-launch
<pillton>
ealfonso: You could alsoe use a logical pathname.
<White_Flame>
QL is much newer than Lisp, which has huge industrial legacy
<White_Flame>
hence, modifications into the standardized ecosystem are rare
<White_Flame>
I often equate it to C before C99 and other extensions finally came about
<White_Flame>
the language was fixed and the ecosystem built around it
<White_Flame>
and heck, C isn't meant to be scriptable as ./foo.c either, and that was never considered a problem even though it *originated* in Unix!
<White_Flame>
so again, religious wars on "it's not python" aren't useful. There are tools to do what you want that are simply different to what you're used to
fikka has joined #lisp
<ealfonso>
yeah, C isn't scriptable like bash/python, and there's a lot of complexity to build on a given system. But SBCL could easily be made easily scriptable
<White_Flame>
sure, and it is
<White_Flame>
if you want external, non-standard libraries, you have to pull them in yourself
<White_Flame>
and/or expect them to be preinstalled by the user
Inline has quit [Quit: Leaving]
<White_Flame>
same as every single other language,
<White_Flame>
.
<White_Flame>
also, there's nothing preventing C from being a scriptable language, either
<White_Flame>
and there are C interpreters
fikka has quit [Ping timeout: 260 seconds]
<ealfonso>
I'm going to finish this work and leave my co-workers a POC written in lisp in my last week and then go home... White_Flame pillton thanks for the discussion
jinkies has quit [Remote host closed the connection]
fikka has joined #lisp
maarhart has joined #lisp
<White_Flame>
ealfonso: btw, REQUIRE is officially deprecated, so (require 'ql) would not be newly supported at any point
maarhart has quit [Client Quit]
fikka has quit [Ping timeout: 268 seconds]
SaganMan has joined #lisp
jinkies has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
smaster has quit [Ping timeout: 264 seconds]
xrash has quit [Read error: Connection reset by peer]
<jackdaniel>
will be removed in a next version of the standard (snh snh)
Guest34814 has quit [Read error: Connection reset by peer]
itruslove has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
* loke
actually has a rather difficult problem of trying to figure out how to distribute Climaxima to regular Maxima users.
eschatologist has quit [Ping timeout: 276 seconds]
<jackdaniel>
can't you distribute lisp image with all systems loaded and the entry function being run-frame-top-level ?
<jackdaniel>
or having this call after some sanity checks
<loke>
jackdaniel: Possibly. I'm not sure what problems can be had when underlying libraries change, and things like that.
<loke>
Perhaps bundle a massive binary package that contains everything.
eschatologist has joined #lisp
<ealfonso>
got "don't know how to load ASDF" on sbcl on macos. also tried to install quicklisp behind commpany proxy and failed
<ealfonso>
had to install quicklisp but remove (require 'asd)
giraffe has joined #lisp
giraffe is now known as Guest56583
itruslove has joined #lisp
hph^ has joined #lisp
fikka has joined #lisp
<_death>
why would you want to use quicklisp in that scenario.. it just creates more potential for failure.. better to have all dependencies available locally
mindCrime has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
<ealfonso>
_death not sure what that means. obviously I can't bundle every dependency in my repo
<_death>
actually, you can.. but if you're talking about a "repo" (for development purposes) then you can just provide it as other quicklisp projects?
caltelt has quit [Ping timeout: 264 seconds]
vlatkoB has joined #lisp
<jackdaniel>
loke: if you have a system image, libraries are already loaded in it
<jackdaniel>
there is no risk of mismatch after you confirm it works
<jackdaniel>
think of it as of static linking
<jackdaniel>
(ECL allows dynamic linking with compiled libraries, but this is irrevelant here)
buffergn0me has quit [Ping timeout: 256 seconds]
habamax has joined #lisp
fikka has joined #lisp
montxero has joined #lisp
gector has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
gector has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
shifty has joined #lisp
zaquest has quit [Remote host closed the connection]
fikka has joined #lisp
habamax has quit [Remote host closed the connection]
lnostdal has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
bigfondue has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
ealfonso has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 265 seconds]
brettgilio has joined #lisp
makomo has joined #lisp
<aeth>
Does anyone define uint8 as (unsigned-byte 8), int32 as (signed-byte 32), etc.? For a shorter name and to match CFFI. I wonder how unusual it would seem to a reader. This would be in files that have to deal with the CFFI so an exact name match int32 with :int32 probably won't be confusing.
<pillton>
Some people use octet for (unsigned-byte 8).
ebzzry has joined #lisp
<ebzzry>
with the risk of sounding like a broken record, what is currently the community-recommended way with interfacing to java?
<pillton>
Sockets?
<pillton>
Or using ABCL.
mathZ has quit [Remote host closed the connection]
<aeth>
pillton: What I'll probably do is have a util/types and provide a bunch of shortcuts all in one place. You're right that I should probably use "octet" in some contexts instead of "int8", but both are probably valid, just in different contexts.
<pillton>
ebzzry: Yeah one of usocket, iolib, cl-async, (or basic-binary-ipc).
shrdlu68 has quit [Ping timeout: 256 seconds]
<aeth>
(If I'm making a byte vector, octet probably makes more sense. If I'm making a struct to store data directly copied from CFFI, int8 would probably make sense if that's the foreign type.)
<LdBeth>
ebzzry (IRC): CL+J
<ebzzry>
pillton: ok. is there something open source like that.
<aeth>
CFFI doesn't use the _t (or -t) so I wouldn't, either
<pillton>
ebzzry: I suspect the runtime of Lispworks can run alongside the runtime of Java i.e. in the same process.
<pillton>
ebzzry: I don't think SBCL can do that.
<aeth>
pillton: I guess I'll also have octet. Are any others common?
<ebzzry>
pillton: yes. i think so, too. however, i'm looking for a solution that i can use with sbcl, at least.
<LdBeth>
ebzzry (IRC): just put into quicklisp’s local project path and quickload it
<ebzzry>
LdBeth: ok. what name should i use?
milanj has joined #lisp
<pillton>
ebzzry: Good luck. It would be great if you came in here periodically (and other forums) and jumped up and down about how communities make run-times that don't compose.
<ebzzry>
LdBeth: did you mean to say that it is currently not distributed with quicklisp, and that the tarball should be downloaded manually?L
<ebzzry>
pillton: i may need to that.
<LdBeth>
ebzzry: yes
<ebzzry>
is lispforum.com a good forum to frequent?
varjag has joined #lisp
<loke>
jackdaniel: are you sure that's the case in SBCL? I was pretty sure it reloads the native libraries when an image is restored
<loke>
I guess I need to test
<pillton>
aeth: I don't know of any others.
<pillton>
loke: Yes it does. It is such a pain.
<loke>
Or perhaps I should distribute with ECL, where these things are easier to control.
fikka has quit [Ping timeout: 245 seconds]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
robotoad has quit [Quit: robotoad]
fikka has joined #lisp
fikka has quit [Client Quit]
fikka has joined #lisp
<SaganMan>
Morning Peeps
<pillton>
loke: Use (sb-alien:load-shared-object my-shared-object-path :dont-save nil) or (setf sb-align:*shared-objects* nil).
Kundry_Wag has joined #lisp
<pillton>
loke: sb-alien sorry.
* pillton
is off home.
<loke>
pillton: thanmks!
Kundry_Wag has quit [Ping timeout: 245 seconds]
<pillton>
loke: BTW I got the argument to :dont-save wrong.
<White_Flame>
everything will eventually converge into something docker-like (which would hopefully actually work)
mooshmoosh has joined #lisp
jinkies has quit [Ping timeout: 276 seconds]
shka_ has quit [Ping timeout: 264 seconds]
<loke>
pillton: How so?
<jackdaniel>
loke: I thought you talk about lisp libraries
<jackdaniel>
in case of sbcl you need to unload them when you dump the image and load the back again when you start it
nowhere_man has quit [Ping timeout: 256 seconds]
<jackdaniel>
that way you'll avoid problems due to mismatches on different systems
<loke>
jackdaniel: No. I was talking about dynamic native libraries.
brettgilio has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
edgar-rft has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
quazimodo has joined #lisp
heisig has joined #lisp
_cosmonaut_ has joined #lisp
doesthiswork has quit [Quit: Leaving.]
lnostdal has joined #lisp
hhdave has joined #lisp
MoziM has joined #lisp
pagnol has joined #lisp
hhdave has quit [Ping timeout: 276 seconds]
merodix has joined #lisp
swflint has quit [Ping timeout: 264 seconds]
shenghi has quit [Ping timeout: 264 seconds]
ym has quit [Ping timeout: 264 seconds]
ym has joined #lisp
swflint has joined #lisp
shenghi has joined #lisp
schweers has joined #lisp
dddddd has joined #lisp
<ebzzry>
Is there a foundation or something equivalent that supports Quicklisp?
<beach>
The Common Lisp foundation supported it once, but it is not regular.
<beach>
So you need to make a donation to Xach.
littlelisper has joined #lisp
<ebzzry>
beach: OK. Has there been an informal discussion about what to do, in the event that Xach will no longer be able to maintain it, for example he dies.
<beach>
No, but I would welcome such a discussion.
Kundry_Wag has quit [Ping timeout: 256 seconds]
<ebzzry>
beach: it may be wrong to assume, that at least one person knows the internals of quicklisp very well, other than xach himself.
svillemot has quit [Ping timeout: 256 seconds]
<beach>
Indeed, maybe nobody does.
<ebzzry>
unless forced
<ebzzry>
is quicklisp 100% open?
<beach>
I would hope so.
<ebzzry>
hm. ok.
<beach>
Ask Xach.
<ebzzry>
beach: yup. i will.
<ebzzry>
xach: ping me when you get back.
<beach>
The situation might not be as bad as you might fear. I think I have understood in the past that there are a few people running independent Quicklisp servers. But I don't remember the details.
svillemot has joined #lisp
<shka>
Shinmera has it's own server for his own stuff
rafadc has joined #lisp
montxero has quit [Ping timeout: 248 seconds]
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
<jackdaniel>
quicklisp and quicklisp-controller are both open source, codebase is quite readble as well
wigust- has joined #lisp
<jackdaniel>
but software is very little, main adventage of QL is cuartion and trust build by Xach
<_death>
you can always go back to asdf-install ;) ;) ;)
<jackdaniel>
ASDF-install could be considered QL without human
<jackdaniel>
exactly
nowhere_man has joined #lisp
wigust has quit [Ping timeout: 260 seconds]
kajo has quit [Remote host closed the connection]
lnostdal has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
karswell has quit [Read error: Connection reset by peer]
karswell_ has joined #lisp
rafadc has quit [Read error: Connection reset by peer]
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
<schweers>
I just noticed that one can use MAKE-INSTANCE on a DEFSTRUCT name. I assume this is because SBCL implements structs as classes? Is it portable to rely on this? My guess is, that it is not, but I’d like to know if I’m wrong.
nowhere_man has quit [Remote host closed the connection]
<beach>
schweers: As you can see, there are two methods, one specialized to STANDARD-CLASS and one to SYMBOL.
<schweers>
sorry, I don’t follow. what exactly does that tell me? That I can pass a symbol (for instance a quoted literal) or a class-object?
<schweers>
oh, it even says so in clhs.
<schweers>
the second form invokes FIND-CLASS
Kundry_Wag has joined #lisp
<schweers>
so this boils down to: are structs (necessarily) classes?
hph^ has quit []
<schweers>
I thought they were not, at least not in general
<beach>
No, that is not what it boils down to. Even if FIND-CLASS return a class, it would not be a STANDARD-CLASS for the name of a structure.
<schweers>
ahhh
<schweers>
now I understand!
<schweers>
thanks!
<beach>
Sure.
<beach>
schweers: Every object in Common Lisp is the instance of some class.
<schweers>
but not necessarily standard-class?
<beach>
Correct.
<schweers>
wait a minute ... isn’t STANDARD-CLASS MOP terminology? I thought MOP was not part of the standard? how come it is mentioned in the hyperspec?
<beach>
Anyway, try (defstruct foo) (class-of (make-foo)) and you will see that even struct instances are instances of some class.
Kundry_Wag has quit [Ping timeout: 260 seconds]
<schweers>
so a STRUCTURE-CLASS is not a STANDARD-CLASS, so using MAKE-INSTANCE on a struct is probably not-portable
<beach>
Right.
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<schweers>
thanks for helping me understand this.
lima4_ has joined #lisp
_cosmonaut_ has quit [Ping timeout: 240 seconds]
lima4_ has quit [Client Quit]
<beach>
Anytime.
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
flamebeard_ has joined #lisp
flamebea_ has joined #lisp
flamebeard_ has quit [Read error: Connection reset by peer]
flamebeard has quit [Ping timeout: 240 seconds]
flamebea_ is now known as flamebeard
thodg has joined #lisp
dmiles has quit [Ping timeout: 276 seconds]
_cosmonaut_ has joined #lisp
dmiles has joined #lisp
vap1 has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: No route to host]
orivej has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<flip214>
beach: when you've got a version of the GC doc including the thread interaction and locking logic, please alert me - best way would be an email. I'd love to read your thoughts!
anddam has left #lisp ["WeeChat 2.2-dev"]
<beach>
Will do. I am currently working on the details of the global collector.
_whitelogger has joined #lisp
<schweers>
How do I best check for two objects of my class to be equal? equalp does not seem to work
<beach>
schweers: There is nothing built in, for the simple reason that equality is defined by the application.
<schweers>
so there is no generic function on which to define a method?
<beach>
schweers: For example, the phone company thinks me and my wife are equal, because we have the same phone number.
<schweers>
true
<schweers>
also, cool example ;)
<beach>
schweers: Correct, there isn't. Such a function would have to take a third argument, namely some representation of the application.
<schweers>
good point. So I’ll have to devise my own. Fair enough. Thanks for the info.
<flip214>
beach: equality is built-in in France ;) liberte, >>egality<<, fraternite or so, right?
<schweers>
I have to go for a while, I’ll look into it. thank you for the pointer.
<beach>
schweers: Anytime.
<beach>
flip214: Only for people. :)
orivej has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Quit: Leaving.]
kuribas has joined #lisp
<kuribas>
is it possible to define a generic method on a type?
jkordani has quit [Read error: Connection reset by peer]
Kaisyu has quit [Quit: Connection closed for inactivity]
patrix has joined #lisp
<kuribas>
or only on classes?
<loke>
kuribas: Every Lisp object is a class.
<kuribas>
so if I define a type, it's also a class?
<loke>
kuribas: And you're probably asking about specialising a method on a generic function.
<kuribas>
yes
<loke>
kuribas: You mean using DEFTYPE? No.
karlosz has quit [Quit: karlosz]
<loke>
There are built-in classes (such as integer, string, cons, etc...) and there are cutom classes defined using DEFCLASS
gorgor_ has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
<loke>
you can also specialise on object identity (using EQL qualifiers)
patrix is now known as patrixl
knobo has quit [Ping timeout: 260 seconds]
<loke>
(and MEMBER qualifiers, which is just an extension of the EQL one)
<kuribas>
what's the class of a deftype'd object?
<antoszka>
EQL or EQ?
shaftoe_ has quit [Ping timeout: 248 seconds]
<loke>
EQL
m00natic has joined #lisp
<loke>
kuribas: None. Deftype does not create classes.
<kuribas>
loke: you just said every lisp object is a class
<jackdaniel>
type system is separate from class system in Common Lisp
<jackdaniel>
you may associate arbitrary predicate with a type
<loke>
kuribas: Correct. But a deftype definition is not an object
<kuribas>
loke: if I create an object of such type, it's an object?
<jackdaniel>
for instance number 3 is of class integer while its type could be positive-integer or integer-less-than-four
<jackdaniel>
(both in principle)
<kuribas>
hmm
<loke>
jackdaniel: Or even more specific: the number 1 is simultaneously of type BIT, INTEGER and FIXNUM.
<kuribas>
what about defstruct?
<kuribas>
does it define a class?
<loke>
kuribas: According the the spec, no. In prcatice, yes.
<jackdaniel>
loke: rather class fixnum and integer (and also type of course), but bit? hmm
<loke>
I believe all common Lisp implementations allow you to specialise on a struct.
<jackdaniel>
kuribas: defstruct defines class, but it is not a standard-class
<loke>
(typep 1 'bit) → T
<jackdaniel>
you may specialize on objects which are not of class tandard-class
<jackdaniel>
loke: (typep 3 'bit) -> nil
<jackdaniel>
ah, you've changed the number
<loke>
jackdaniel: Yes. :-)
thodg has quit [Ping timeout: 256 seconds]
<kuribas>
so I could write a generic method on a type?
<loke>
kuribas: No.
<jackdaniel>
kuribas: you may specialize on any class, but you can't specialize on a type
<jackdaniel>
you may use filtered-functions library to wrap something of your own (it adds some preprocessor step for dispatch)
<kuribas>
is it possible to create a unique value? Like a symbol, but unique
<jackdaniel>
gensym creates symbol which is not interned
<Xach>
kuribas: make-symbol will make a new symbol
<kuribas>
okay, thanks
<loke>
to be very specific: (eq (make-symbol "FOO") (make-symbol "FOO")) → NIL
patrixl has quit [Remote host closed the connection]
<shka>
hmmm
<jackdaniel>
<heavy mind muscle manipulation>
bjorkintosh has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
<kuribas>
what's the use for deftype then?
<kuribas>
typechecks?
karlosz has quit [Quit: karlosz]
<jackdaniel>
types are useful for many things, typechecks is one, code branch dispatch (for optimization or else) is another
karlosz has joined #lisp
<jackdaniel>
classes are just a subset of possible types, some types are even not decidable
<Xach>
deftype gives you type abstraction
<Xach>
you can change the details of the underlying type without changing the name you use everywhere
<kuribas>
is that like a type synonym in haskell?
<Xach>
i don't know anything about haskell, sorry.
<jackdaniel>
kuribas: type may be associated with *any* predicate which is a function
<jackdaniel>
in degenerated case you could put call to random in this function and see world burning
bjorkintosh has quit [Ping timeout: 256 seconds]
AetherWind has quit [Quit: Leaving]
<jackdaniel>
or something like `(solves x^3 - 2x^1 = 0) ; of course you would have to code the method to find the solution
patrixl has joined #lisp
<kuribas>
ah cool
<jackdaniel>
kuribas: I wouldn't concern with types very much for now if I were you, just stick to classes. think of a type system as of some generalization which you don't need (until you'll need it) – class names are also type names so work on that level (check-type and other will work with it)
<kuribas>
jackdaniel: I am trying to make lazy streams for sbcl
<kuribas>
as subclass of sequence
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
<jackdaniel>
delimited continuations would definetely help you with that
<flip214>
kuribas: (incf *counter*) should be "unique" as well
<kuribas>
jackdaniel: how?
<jackdaniel>
(don't take that lead – delemited continuations are not implemented in any CL implementation afaik, nor they are part of the standard)
<kuribas>
I now just have a thunk structure which encapsulates a lambda
<kuribas>
so "evaluating" the thunk just calls the lambda, then replaces the thunk by its value.
paule32 has quit [Read error: Connection reset by peer]
<kuribas>
simple but effective.
<kuribas>
probably not efficient though
<jackdaniel>
OK
<kuribas>
but the idea of lazyness is convenience, not performance
<shka>
kuribas: it can be surprisingly effective
<shka>
i use similar approach, it works great
<jackdaniel>
kuribas: have you heard about library `clazy'?
<shka>
the only issue is that i have to explicitly maintain stack of cons cells
<shka>
sometimes
<shka>
but i can deal with it
<kuribas>
jackdaniel: yeah. It's not a sequence though, or is it?
fikka has quit [Ping timeout: 265 seconds]
<loke>
flip214: You'd need a mutex to ensure uniqueness :-)
<loke>
kuribas: Yiou might also want to look at the SERIES library, which implements that.
<kuribas>
does (declaim (inline ...)) work outside a package?
_cosmonaut_ has joined #lisp
<kuribas>
will the function be inlined when importing the package?
<beach>
kuribas: Packages are only about symbols.
<shka>
kuribas: it should work
<beach>
kuribas: Only the reader cares about packages.
<shka>
kuribas: but you probabbly should think twice before doing something like this
<shka>
because compiler will attempt to inline this function everywhere from now
milanj has quit [Quit: This computer has gone to sleep]
<kuribas>
shka: that's what I want :)
thodg has quit [Read error: Connection reset by peer]
<shka>
so basicly if your project is a library
<shka>
you will change behavior of other library for all your clients
<shka>
and this is not what you should be doing
<shka>
as for thunk vs stream fusion
<shka>
i personally prefer thunks
<kuribas>
shka: stream fusion can eliminate intermediate structures, so put less stress on the GC.
<kuribas>
thunks are easier
<shka>
well, thunks can do the same thing, without magical keywords
<shka>
or at least with less magical words
<kuribas>
yes, semantically it's the same
<kuribas>
but each thunk needs to be garbage collected
<kuribas>
anyway I could try both and compare the performance
<shka>
well, that's acceptable cost
<shka>
IMHO
<shka>
unless you want to go real time
<kuribas>
well, it's just an experiment now
<kuribas>
coming from haskell I find streams very handy
fikka has quit [Ping timeout: 240 seconds]
<beach>
Does anybody know how the object sets (white, gray, black) in a tri-color tracing garbage collector are typically represented?
ebrasca has quit [Read error: Connection reset by peer]
knobo has joined #lisp
ebrasca has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
<flip214>
beach: ISTR that black=01 white =10 gray=11 so that a simple bit-IOR makes gray
<flip214>
or am I misunderstanding the question in some way?
<beach>
Ah, I should have explained my problem a bit more...
<beach>
How do I find an arbitrary gray object.
<beach>
?
<flip214>
if you don't have a list of gray objects, by exhaustive search?!
<flip214>
or you store _a_ gray object when it's marked as such
<beach>
I can't very well scan the bitmap in each iteration.
<flip214>
I thought you walk the object headers in a well-defined order... wouldn't traversing them show a gray object or none?
<beach>
I don't understand.
<beach>
I could have a small set of gray objects, but that set can't be too big.
acolarh has quit [Ping timeout: 255 seconds]
<beach>
flip214: When a gray object is being processed, the white objects that it refers to are colored gray and then the object itself is colored black.
<beach>
So, sure, I can set the bits for the gray objects and clear the bit for the object itself. But how do I select the next gray object to process?
<flip214>
well, wikipedia says "The grey set is kept as a separate list or using another bit." ;)
<shka>
ok, so basicly you want to have some sort of index
nowhere_man has joined #lisp
lumm has joined #lisp
<beach>
flip214: Very informative. Where do I get the additional space for a list?
<flip214>
(CONS ) .... sorry, but you had that one coming ;)
<beach>
shka: Yes, something like that. I considered a multi-level bitmap.
<beach>
flip214: What Wikipedia article are you reading?
<flip214>
but the question is.... "first" as in "first in printed representation (MSB)" or as in "lowest set bit"? ;)
fikka has joined #lisp
<beach>
Excellent! Thanks.
rpg has joined #lisp
shangul has joined #lisp
EvW has joined #lisp
milanj has joined #lisp
<beach>
So, using a multi-level index, as shka suggested, I could have a bitmap covering the entire heap, and then a secondary bitmap with one bit for every 64 bits in the primary bitmap, etc, until there is a single word left.
<beach>
The number of levels would have to vary, but there would rarely be more than 5 or so.
kajo has quit [Remote host closed the connection]
<beach>
flip214: It doesn't matter. I can use any bit that is set.
kajo has joined #lisp
<beach>
OK, this technique could be pretty fast.
thodg has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
scymtym has joined #lisp
wildbartty has quit [Remote host closed the connection]
<beach>
To mark an object as gray, compute the 64-bit word containing the gray bit for that object. Check and remember whether this word is zero before setting any bits. Set the bit corresponding to the object. If the word was zero before, move to the next level of bitmaps and repeat. If the word was not zero before, stop.
<beach>
To remove a gray object from the set, compute the 64-bit word containing the gray bit for that object. Clear the bit corresponding to the object. If the word is now zero, move to the next level of bitmaps and repeat.
Myon has joined #lisp
Kundry_Wag has joined #lisp
<beach>
In general to find an arbitrary gray object, start from the top bitmap, find the first bit set, move one level down and repeat until the lowest level is reached.
<beach>
shka: Something like that?
thodg has quit [Read error: Connection reset by peer]
shaftoe_ has joined #lisp
<beach>
Nothing prevents us from combining this scheme with a small cache of gray objects, of course.
Kundry_Wag has quit [Ping timeout: 256 seconds]
<beach>
But it might not be worth it.
<shka>
beach: sorry been AFK
<beach>
shka: Sure, no problem.
<shka>
beach: multilevel bitmap sounds like clever solution, but i am wondering if anyone else does it this way
<shka>
MPS for instance
<beach>
I don't know. Most GC systems are not concurrent and parallel anyway.
<shka>
that is true
<shka>
well, anyway, it may be unusual, but very well may be efficient
<shka>
honestly, i don't think anyone can be certain before prototype
<beach>
Yes, of course. GC performance is notoriously hard to predict.
graphene has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 264 seconds]
<LdBeth>
What’s gray object by definition?
<beach>
A live object that may refer to untraced (white) objects.
pierpal has quit [Read error: Connection reset by peer]
thodg has joined #lisp
<flip214>
beach: ain't it good enough to have one bitmap bit per 4KB of data? do you really want to go down to a per-word granularity? sounds overkill to me.
<beach>
Well, if I have one word granularity, I can find a gray object in 5 or so iterations. If I have one bit per 4KB, I would have to search hundreds of words to find one.
<beach>
And the extra space for my suggested technique is very modest.
<beach>
flip214: Or am I missing something with your suggestion?
<LdBeth>
Looks like GPU accelerated GC
<flip214>
beach: no, you're right. but I thought your smallest object is 2 words (object header) anyway, so at least 16 bytes, that means 256 objects per 4kB page
<flip214>
256 objects == 32 bytes bitmap
<flip214>
for 4GB heap == 32MB bitmap, if I'm not mistaken
<flip214>
these 32MB could be used for better purposes IMO
pagnol has quit [Read error: Connection reset by peer]
jkordani has joined #lisp
<beach>
32MB is almost nothing. Time is more critical.
<beach>
Also, are you saying no additional levels of bitmaps?
<beach>
That won't fly.
<beach>
You may have to search an arbitrary number of pages before you find a gray object then.
<beach>
Anyway, I am off for an appointment.
lnostdal has quit [Ping timeout: 264 seconds]
<beach>
I'll be back in a few hours.
doesthiswork has joined #lisp
Bike has joined #lisp
<LdBeth>
A tri-color bitmap could be compressed to two array of x y coordinates
<flip214>
beach: No, I was just talking about the lowest, per-word level of the bitmap tree. This I would avoid. And as I estimated only _one_ 4KB page with at most 256 objects needs to be looked at to find "the" gray object in there.
<flip214>
LdBeth: and stored as JPEG in memory?
LiamH has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
kajo has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
<LdBeth>
Ha, arrays enable multiple threads processing
eschatologist has joined #lisp
kerframil has joined #lisp
g_SG has joined #lisp
g_SG has quit [Client Quit]
nowhere_man has joined #lisp
escapist has quit [Ping timeout: 255 seconds]
graphene has quit [Remote host closed the connection]
sjl has joined #lisp
graphene has joined #lisp
Murii has quit [Remote host closed the connection]
warweasle has joined #lisp
sendai_ has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
azimut has quit [Ping timeout: 255 seconds]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
escapist has joined #lisp
escapist has quit [Client Quit]
nowhere_man has joined #lisp
thodg has quit [Read error: Connection reset by peer]
jack_rabbit has quit [Ping timeout: 264 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
cage_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
skapata has joined #lisp
mangul has joined #lisp
shangul has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Zhivago has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
samla has joined #lisp
Younder has joined #lisp
nxtr` has joined #lisp
<shka>
if anything, i would love GC that can semi-efficiently handle very large heaps
<shka>
because that's what i am dealing with most of the time
<shka>
jackdaniel: well, fortunatly many lisp implementations are under development
<Bike>
i'm a clasp developer. there's no "compile on load" and at the moment we only support x64. don't lie on our behalf.
<shka>
but i am wondering how usable clasp is
<jackdaniel>
shka: I mean – it is under heavy development, that is features are added actively
<shka>
yes, there are commits on git daily
FreeBirdLjj has joined #lisp
<jackdaniel>
recently compilation time was cut noticeably afaik
<shka>
that's nice
<Younder>
Bike. I know and I don't intentionally lie, at least not in this case.
<jackdaniel>
shka: then what metric of "current status" are you asking for?
fikka has joined #lisp
<shka>
well, that's a good question i guess
nxtr` has quit [Remote host closed the connection]
<shka>
anyway, I am trying to track development on git but it is not that easy if you lack expertise in compilers
<Bike>
we haven't made major changes to the compiler lately. mainly trying to clean up the runtime
<shka>
still, fascinating stuff
<Younder>
Bike, Anyhow 32 bit is pretty much dead. The key is to support GPU's and other support chips say FPGA's.
<shka>
Younder: that does not make any sense
<Bike>
it really doesn't
<jackdaniel>
but is a buzzword™ compliant, so pay attention
<Younder>
Two lib's one for GPU one for CPU. you pick and balance at runtime and adapt to the machine you are running on. That doesn't make sense to you?
<shka>
Younder: no
<shka>
not on the lisp implementation level anyway
<Younder>
Well If you are developing form a supercomputer from a laptop and you wan't to debug you code you would want a slower bur runnable version.
<Younder>
for
<shka>
Bike: well, since you are around, how work on clasp is going?
<shka>
any interesting problems lately?
<Bike>
many problems of various levels of interest
<Bike>
nothing too flashy lately, i don't think
<Bike>
we've been working on getting source tracking with dwarf info and beach's cst library
<shka>
oh
<shka>
i seen cst library
<shka>
it will be added to ql probabbly soon
<Bike>
right, people were using it for non compiler things
Inline has joined #lisp
<shka>
yes, it is useful all around library
lumm_ has joined #lisp
hhdave has joined #lisp
lumm has quit [Ping timeout: 256 seconds]
lumm_ is now known as lumm
wheelsucker has joined #lisp
wheelsucker has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
lumm has quit [Read error: Connection reset by peer]
wheelsucker has joined #lisp
surya has joined #lisp
shangul has joined #lisp
mangul has quit [Ping timeout: 260 seconds]
lumm has joined #lisp
graphene has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
shrdlu68 has quit [Ping timeout: 265 seconds]
thodg has joined #lisp
robotoad has joined #lisp
fikka has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
lumm has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
al-damiri has joined #lisp
nanoz has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Ping timeout: 264 seconds]
littlelisper has joined #lisp
<beach>
flip214: Yes the lowest level bitmap has one bit for each dyad (CONS cell or header). I don't think I have suggested anything different for the global collector.
<beach>
shka: The GC I am planning would handle very large heaps.
Satou has joined #lisp
<Satou>
Hello, I have a question regarding quickloading caveman2, it seems that I cannot, I get an "Error while trying to load definition for system static-vectors from pathname"
fikka has joined #lisp
<Satou>
I'm on Debian stretch, I've tried installing sbcl and cl-asdf from testing, but that doesn't seem to work.
<shka>
beach: i would love that
littlelisper has quit [Read error: Connection reset by peer]
<jackdaniel>
Satou: standard Debian packaging and SBCL doesn't play well usually. you may try downloading sbcl from sbcl.org
<shka>
as i am one of the foolish few that attempt to handle large ammounts of data in lisp
<jackdaniel>
prebuilt binary should have asdf compiled
<Satou>
thanks jackdaniel.
<beach>
shka: That is not foolish. Sorry that existing implementations let you down.
<jackdaniel>
shka: how is lisp unsuitable now for handling big quantities of data? i'm curious about problems you have encountered
<shka>
works mostly great but GC in sbcl is substandard
<jackdaniel>
in what regard?
<shka>
jackdaniel: lisp as a language is fine, sbcl as implementation is also MOSTLY fine
<shka>
GC is the only problem
<jackdaniel>
in what regard its gc is substandard? is it too slow?
<beach>
How does the problem manifest itself?
ealfonso has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
<shka>
jackdaniel: first of, it is slow
<shka>
or at least
<shka>
not very fast
<shka>
not java fast at least
<beach>
Do you see long pauses?
<shka>
beach: yeah, but oddly enough i am mostly fine with that part
<shka>
it does not add all that much time
<shka>
problem is different
<shka>
when it pauses, everything pauses
<shka>
all my 24 threads munching data
<jackdaniel>
"not java fast" doesn't tell me much, sorry
<shka>
so it bottlenecks whole process
<shka>
jackdaniel: i don't have benchmarks at the moment unfortunatly
<shka>
sorry
<jackdaniel>
as of pausing world – is your GC going to avoid that somehow beach ?
<shka>
otherwise, i find sbcl to be very good tool for the task
<beach>
jackdaniel: Of course. :)
<jackdaniel>
shka: java gc stops the world afaik
<jackdaniel>
beach: do you follow some existing algorithm to do that, or you have rolled up your own?
<jackdaniel>
I think that XCL developer had a presentation about such algorithm
<beach>
jackdaniel: A bit of both.
<jackdaniel>
uhm
<shka>
jackdaniel: not exactly stop the world
<beach>
jackdaniel: I am using an old compacting algorithm for the nursery, except that I improved it so that it is much more efficient.
<beach>
jackdaniel: The nursery collector should take only a few milliseconds. That is a requirement for handling things like sound processing.
<shka>
you can say many things about jvm, but GC is the strong point
<jackdaniel>
I'm confused, are we talking about java or jvm? I find the latter very appealing (to a limited extent I know about jvm)
<beach>
jackdaniel: And the global collector is parallel and concurrent with the application threads.
<jackdaniel>
either way JVM's GC stops the world
<jackdaniel>
beach: thanks
Smokitch has joined #lisp
<shka>
jackdaniel: it has to, obviously
<shka>
anyway, i'm feeling like i am ranting at this point
<shka>
in a very non constructive way
<beach>
shka: "has to"? Why?
<jackdaniel>
well, "Java is better than Lisp" is a common complaint ,p
<shka>
SBCL is very good, and THE ONLY major practical shortcoming i encountered is GC
<beach>
jackdaniel: I am not doing anything magic. All those algorithms already exist. For the global collector, I do take advantage of the fact that all SICL heap-allocated objects are either 2 words, or have a 2-word header. That way I can use a mark-and-sweep collector for the global heap.
<beach>
shka: Are you saying that the GC has to stop all the application threads?
<shka>
for such complex piece of software as lisp implementation it is a excelent score
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<jackdaniel>
beach: I'm afraid I don't know enough about garbage collecting to understand the implication here, but I'll take your word for that :) and maybe after reading this article I'll know more
<shka>
beach: as for JVM, it has more then one algorithm
EvW has quit [Ping timeout: 276 seconds]
<shka>
and new version should have yet another GC that i don't know much about
<Bike>
yeah i thought the azure jvm didn't stop the world
<shka>
but at least by default java stops the world
<shka>
Bike: azure is special ;-)
merodix has quit [Remote host closed the connection]
<beach>
Paul is a better writer than Jones. That's why I recommend starting with that one.
flamebeard has quit []
ealfonso has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
lnostdal has joined #lisp
<shka>
beach: btw, from what i googled java is switching to so called G1GC
<shka>
by default
<beach>
I see.
<shka>
there is rather lenghty discussion on the mailing list discussing merrits of it
fikka has quit [Ping timeout: 264 seconds]
<shka>
unfortunatly it is way beyond my level
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
<shka>
from what i understand G1GC is expected to have limited real time guaranteens
scymtym has joined #lisp
_cosmonaut_ has quit [Ping timeout: 240 seconds]
<beach>
Great!
<beach>
I wonder how they avoid scanning an arbitrarily big stack.
<beach>
But I don't wonder enough to go find out.
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
brendyn has quit [Ping timeout: 256 seconds]
josemanuel has joined #lisp
pfdietz has quit [Ping timeout: 245 seconds]
pfdietz has joined #lisp
<shka>
beach: majority of people would prefer overall shorter pauses over real time guaranteense anyway
shifty has quit [Ping timeout: 245 seconds]
<shka>
though #lisp-games may disagree
<shka>
sicl is interesting concept in few ways anyway
<shka>
the only drawback is that I can't run it :D
fikka has joined #lisp
Satou has quit [Quit: exit();]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kundry_Wag has joined #lisp
graphene has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 245 seconds]
<TMA>
shka: it really depends on the use case -- realtime requirements are not ubiquitous, but they are surprisingly common -- playing sound, having consistent gui response, ...
<shka>
yes, it is true
graphene has joined #lisp
<shka>
i should leave my box more often
<TMA>
even a SLA for a web service makes your system bound by realtime guarantees
igemnace has joined #lisp
buffergn0me has joined #lisp
edgar-rft has quit [Quit: edgar-rft]
milanj has joined #lisp
fikka has joined #lisp
andrei-n has joined #lisp
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
fikka has joined #lisp
<beach>
shka: Yeah. Sorry about that. I am making progress, but not nearly fast enough.
Kundry_Wag has quit [Remote host closed the connection]
<shka>
beach: nobody can blame you
<shka>
besides, parts of SICL bleed into CLASP already
<beach>
True.
<beach>
And CLISP now as well.
<shka>
CLISP?
<shka>
which part?
<shka>
cleavier?
Kundry_Wag has joined #lisp
<beach>
Yes, karlosz is writing a Cleavir-based compiler for CLISP.
<shka>
oh
<shka>
this is cool
<shka>
so CLISP will become compiled language
<beach>
And, perhaps jackdaniel will use some stuff as well.
<shka>
*implementaiton
<beach>
shka: Nah, he is still generating code for the bytcode interpreter.
<shka>
btw, what about using Cleavir for something that is not common lisp?
<shka>
how viable would that be?
<beach>
I haven't given it much thought, but it ought to work.
<shka>
hmmm
fikka has quit [Ping timeout: 265 seconds]
<Bike>
you'd have to basically replace cst-to-ast
<shka>
ok:-)
<shka>
Bike: and what if i want to still use lisp syntax?
<Bike>
i assumed you meant something like scheme
<shka>
ok
<shka>
does not sound all that bad i think
<shka>
ok, i got to go
<shka>
see ya all!
megalography has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
pjb has joined #lisp
nxtr has joined #lisp
littlelisper has joined #lisp
buffergn0me has quit [Ping timeout: 256 seconds]
hhdave has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 248 seconds]
Baggers has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
buffergn0me has joined #lisp
megalography has joined #lisp
rippa has joined #lisp
Lauven has joined #lisp
surya has quit [Ping timeout: 248 seconds]
littlelisper has quit [Ping timeout: 255 seconds]
eli_oat has joined #lisp
fikka has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
shangul has quit [Quit: sudo rm -rf /usr/*]
quazimodo has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
megalography has quit [Ping timeout: 245 seconds]
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
fikka has joined #lisp
lumm has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
m00natic has quit [Remote host closed the connection]
mflem has joined #lisp
nxtr has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
buffergn0me has quit [Ping timeout: 268 seconds]
eli_oat has quit [Quit: Leaving.]
lumm has quit [Ping timeout: 256 seconds]
megalography has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
shka_ has joined #lisp
orivej has joined #lisp
fikka has joined #lisp
thodg has quit [Ping timeout: 268 seconds]
EvW1 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
nanoz has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 245 seconds]
schweers has quit [Ping timeout: 240 seconds]
lumm has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
sctb has joined #lisp
Domaldel has joined #lisp
zaquest has joined #lisp
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
patrixl has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
makomo has quit [Quit: WeeChat 2.0.1]
MichaelRaskin has joined #lisp
dtornabene has quit [Remote host closed the connection]
<jackdaniel>
shka: clisp is and was a compiler for a long time
<jackdaniel>
if not from the beginning. compiling to bytecode is also compilation. what's more, it has JIT to native assembly via library called GNU Lightning
fikka has joined #lisp
Ukari has quit [Remote host closed the connection]
<_death>
ls
<_death>
oops
fikka has quit [Ping timeout: 240 seconds]
<_death>
I've 3 keyboards in front of me atm.. wrong one ;)
<rpg>
dim: I'm just trying to help see if there's really a UIOP bug.
<Xach>
installing ccl is mostly git clone now
<dim>
rpg: brew install clozure-cl
<dim>
thanks for having a look, appreciated
<rpg>
Xach: My problem is that it doesn't have a nice "make install" -- or at least it didn't last time I checked.
<dim>
the build process of CCL is strange and makes it unavailable in debian :/
<akkad>
rpg: 10.1?
<rpg>
akkad: Yes.
<rpg>
I know there are definitely limits to ITERATE's code-walking.
<rpg>
Hm. Looks like maybe I should be on CCL 1.12
<flip214>
but ITERATE is built to be expanded -- tell it to ignore the COMPILER-LET? (and push the fix upstream)?
lumm has joined #lisp
<rpg>
flip214: I don't know if the compiler-let is in the source code, or if it is introduced by Franz's compiler. And, given that I was just trying to check for an unrelated UIOP issue, I'm going to ignore this.
fikka has joined #lisp
megalography has quit [Ping timeout: 260 seconds]
<flip214>
rpg: ask the vendor to push a fix for ITERATE upstream, please - it would make sense and helps everybody.
cpt_nemo has quit [Ping timeout: 240 seconds]
<rpg>
flip214: I don't really want to get into debugging cl-csv, TBH.
fikka has quit [Ping timeout: 256 seconds]
xrash has joined #lisp
grumble has quit [Ping timeout: 600 seconds]
grumble has joined #lisp
jmercouris has joined #lisp
bhyde has joined #lisp
cpt_nemo has joined #lisp
fikka has joined #lisp
<rpg>
So the CCL page has instructions about how to build the lisp kernel, but not how to rebuild the heap image.... Any pointer?
<jmercouris>
rpg: maybe ask on #ccl
<rpg>
My heap image is too new (I was running with the bleeding edge instead of release).
fikka has quit [Ping timeout: 248 seconds]
megalography has joined #lisp
varjag has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
mindCrime has quit [Ping timeout: 265 seconds]
Smokitch has quit []
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
vlatkoB has quit [Remote host closed the connection]
random-nick has quit [Read error: Connection reset by peer]
josemanuel has quit [Quit: leaving]
rippa has quit [Read error: Connection reset by peer]
fikka has joined #lisp
ealfonso has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
shka_ has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
shrdlu68 has quit [Ping timeout: 240 seconds]
mlf|2 has joined #lisp
mflem has quit [Ping timeout: 245 seconds]
Baggers has left #lisp ["rcirc on GNU Emacs 25.2.2"]
shka_ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
thodg has joined #lisp
pseudonymous has quit [Remote host closed the connection]
zachk has joined #lisp
zachk has joined #lisp
zachk has quit [Changing host]
fikka has quit [Ping timeout: 264 seconds]
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
fikka has joined #lisp
lumm has quit [Ping timeout: 276 seconds]
thodg has quit [Ping timeout: 260 seconds]
pierpa has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
Arcaelyx has joined #lisp
mindCrime has joined #lisp
pseudonymous has joined #lisp
fikka has joined #lisp
kuribas has quit [Remote host closed the connection]
wigust- has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
housel has quit [Read error: Connection reset by peer]
pseudonymous has quit [Remote host closed the connection]
housel has joined #lisp
raynold has joined #lisp
graphene has quit [Read error: Connection reset by peer]
<mfiano>
pillton: Hello
bjorkintosh has joined #lisp
<mfiano>
pillton: How can I change a defstore's lambda list without restarting my image?
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
hhdave has joined #lisp
moei has quit [Quit: Leaving...]
nickenchuggets has quit [Read error: Connection reset by peer]
lnostdal has quit [Ping timeout: 264 seconds]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
Naergon has joined #lisp
Bike has quit [Ping timeout: 252 seconds]
random-nick is now known as alpha-nick
graphene has quit [Remote host closed the connection]
edgar-rft has joined #lisp
graphene has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
hhdave has quit [Read error: Connection reset by peer]
alpha-nick is now known as random-nick
jack_rabbit has joined #lisp
hhdave has joined #lisp
milanj has joined #lisp
LiamH has quit [Quit: Leaving.]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
anon___ has quit [Read error: Connection reset by peer]
graphene has quit [Read error: Connection reset by peer]
paule32 has quit [Read error: Connection reset by peer]
graphene has joined #lisp
jmercouris has quit [Remote host closed the connection]
paul0 has joined #lisp
hhdave has quit [Ping timeout: 256 seconds]
pfdietz has quit [Ping timeout: 276 seconds]
hhdave has joined #lisp
sjl has joined #lisp
hhdave has quit [Read error: Connection reset by peer]
loli has joined #lisp
hhdave has joined #lisp
makomo has joined #lisp
FreeBird_ has joined #lisp
paule32 has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
random-nick has quit [Read error: Connection reset by peer]
loginoob has joined #lisp
hhdave has quit [Ping timeout: 260 seconds]
robotoad has quit [Quit: robotoad]
nowhereman_ has quit [Ping timeout: 256 seconds]
moei has joined #lisp
<akkad>
anything special required to get sbcl to honor http_proxy env var?
robotoad has joined #lisp
loginoob has quit [Remote host closed the connection]
<pillton>
mfiano: make-store-unbound
<mfiano>
pillton: thanks. I'm trying to debug something else with specialization-store right now.
<mfiano>
strangely it seems to be treating an ecase as a case with regard to type inference
megalography has quit [Ping timeout: 255 seconds]
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
<pillton>
mfiano: Do you have something I can see?
<mfiano>
With the following code, the CLAMP specialization returns a type uncertainty note under SBCL. I can get rid of it be changing (vec4) to (the vec4 (vec4)). The same code works in a defun with the proper ftype declaration. I'm unsure why it's not inferring the type of the 0 case. https://gist.github.com/mfiano/13c533f190c1a12dfe84da143a960fed
mooshmoosh has quit [Ping timeout: 256 seconds]
<akkad>
music note?
mooshmoosh has joined #lisp
nowhereman_ has joined #lisp
<pillton>
mfiano: Specialization store doesn't integrate with type inference.
Bike has joined #lisp
<pillton>
mfiano: It uses the CLtL2 API to query the environment and is capable of understanding THE forms.
patlv has joined #lisp
<pillton>
mfiano: I can't compile this example to see what is going on.
<mfiano>
Ah I assume it uses introspect-environment for the few impls it supports?
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<mfiano>
I see. (vec4) is just allocating a zero'd vec4, and determines the return type of the clamp! function. So the type uncertainty is because the specialization declares the return type to be vec4, but since clamp! is going through the specialization protocol, it doesn't know the type without using THE
<mfiano>
No problem. I get it now
<mfiano>
Thanks
patlv has quit [Ping timeout: 248 seconds]
megalography has joined #lisp
<pillton>
mfiano: You are welcome.
<mfiano>
pillton: Great job on this library. I tried understanding template-function, but that's too dense for me.
<pillton>
mfiano: Thanks. It took me four years to get it where it is.
edgar-rft has quit [Quit: edgar-rft]
<mfiano>
I'm trying to use it to rewrite a math library of mine that took me 4 years to get it where it is :)
jmarciano has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<pillton>
mfiano: Send me an email about where you get lost in template-function.
<pillton>
mfiano: I'll see if I can update the documentation to help.
<mfiano>
Ok, I'll re-read it in my free time and let you know.
Kundry_Wag has quit [Remote host closed the connection]
<pillton>
I tried to pick a problem where the usual response of "just implement a compiler macro" doesn't scale.
lavaflow has quit [Ping timeout: 240 seconds]
<pillton>
The problem with the problem I picked is that it is only relatable to a small number of people.
EvW1 has joined #lisp
<mfiano>
Yeah. I think part of the problem was I wasn't sure when to use it over specialization-store directly. It's sort of hard to tell from the documentation where one library ends and the other begins
<mfiano>
But I'll re-read it again and come up with some questions for you
fikka has joined #lisp
lavaflow has joined #lisp
<pillton>
Great.
brettgilio has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Naergon has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 255 seconds]
<dim>
oh wow, it seems like the errors in travis (for pgloader) are actual errors/regressions