zwr has quit [Read error: Connection reset by peer]
contrapunctus has quit [Ping timeout: 276 seconds]
zwr has joined #commonlisp
contrapunctus has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
bike has joined #commonlisp
bike has quit [Remote host closed the connection]
bike has joined #commonlisp
char has quit [Ping timeout: 260 seconds]
Akbar-Birbal has joined #commonlisp
kevingal has quit [Ping timeout: 265 seconds]
<paulapatience>
aeth: uiop:define-package fixed the package redefinition issues
<paulapatience>
s/fixed/fixes/
amb007 has joined #commonlisp
random-nick has quit [Quit: quit]
amb007 has quit [Ping timeout: 265 seconds]
shawnw has quit [Ping timeout: 248 seconds]
edgar-rft_ has joined #commonlisp
edgar-rft` has quit [Ping timeout: 245 seconds]
dinomug has quit [Remote host closed the connection]
char has joined #commonlisp
spdegabrielle has quit [Quit: Connection closed for inactivity]
brokkoli_origin has quit [Ping timeout: 252 seconds]
brokkoli_origin has joined #commonlisp
alcor` has joined #commonlisp
alcor has quit [Ping timeout: 248 seconds]
JuanDaugherty has joined #commonlisp
char has quit [Ping timeout: 248 seconds]
Josh_2 has quit [Quit: Gotta go fast!]
LispTyro has joined #commonlisp
decweb has quit [Ping timeout: 245 seconds]
LispTyro has quit [Quit: leaving]
JuanDaugherty has quit [Quit: JuanDaugherty]
PennyBlake has joined #commonlisp
shawnw has joined #commonlisp
Akbar-Birbal has left #commonlisp [#commonlisp]
Akbar-Birbal has joined #commonlisp
<mountainman1312>
I've never made a GUI before, always a text-only kind of guy. I'm about to be making a program for my employer (manufacturing, not software company) and it has to be GUI. It also has to work on both Windows and FreeBSD. I'm wondering what's the current recommended Qt bindings for Common Lisp?
<beach>
mountainman1312: If you have never made a GUI before, how come you decided on Qt?
PennyBlake has quit [Remote host closed the connection]
<mountainman1312>
It's the one that is both cross-platform and I've heard of it before. No real technical reasons as I realize I have no idea what I'm doing in terms of GUI yet :)
<beach>
I see.
gooba has joined #commonlisp
<Bubblegumdrop>
I don't know if anyone is maintaining a Qt backend right now, I think there's some work on Qt6?
<Bubblegumdrop>
It has to work on both Windows and FreeBSD? That sounds like a good choice for a web app if you ask me.
<Bubblegumdrop>
Server backend with REST API and your clients can run on the web
char has joined #commonlisp
mishoo has joined #commonlisp
gooba has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2.50)]
amb007 has joined #commonlisp
Guest890 has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 260 seconds]
char has quit [Remote host closed the connection]
amb007 has joined #commonlisp
Pixel_Outlaw has quit [Quit: Leaving]
copec has quit [Ping timeout: 244 seconds]
amb007 has quit [Ping timeout: 260 seconds]
synchrom1 has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
copec has joined #commonlisp
grawlinson has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
dinomug has joined #commonlisp
amb007 has joined #commonlisp
LispTyro has joined #commonlisp
meaty has quit [Ping timeout: 244 seconds]
srji has joined #commonlisp
<srji>
\o/
rtypo has quit [Ping timeout: 265 seconds]
srji has quit [Quit: leaving]
copec has quit [Ping timeout: 265 seconds]
cryptk has quit [Read error: Connection reset by peer]
cryptk has joined #commonlisp
copec has joined #commonlisp
cmack` has joined #commonlisp
cmack has quit [Ping timeout: 265 seconds]
copec has quit [Ping timeout: 245 seconds]
copec has joined #commonlisp
synchromesh has quit [Quit: WeeChat 4.0.5]
Lord_of_Life has quit [Ping timeout: 248 seconds]
Lord_of_Life has joined #commonlisp
alcor` is now known as alcor
alcor has quit [Changing host]
alcor has joined #commonlisp
wacki has joined #commonlisp
cage has joined #commonlisp
cage has quit [Excess Flood]
cage has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
shka has joined #commonlisp
spdegabrielle has joined #commonlisp
gooba has joined #commonlisp
cosimone has joined #commonlisp
synchromesh has joined #commonlisp
<cosimone>
hello, i found something weird the other day, i'm on sbcl 2.2.9. apparently, when using defclass, i can use the :initargS slot option (notice the trailing s), which compiles fine, altohugh i don't se it in the available options in the hyperspec (i only see :initarg)
<cosimone>
here is an example: define this class (defclass point () ((x :initargs :x) (y :initarg :y))) then make an instance: (make-instance 'point :x 0 :y 0), i get the following error: "Invalid initialization argument: :x"
<cosimone>
my question is, is this some kind of sbcl extension i wasn't aware of? is there some part of the spec that i missed? or, worst case scenario, could this be an implementation bug?
gooba has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2.50)]
<cosimone>
i'll try later on the very latest sbcl version to see if the phenomenon persists
heisig has joined #commonlisp
donleo has joined #commonlisp
gooba has joined #commonlisp
gooba has quit [Remote host closed the connection]
gooba has joined #commonlisp
<beach>
Sounds like a bug to me.
gooba has quit [Client Quit]
gooba has joined #commonlisp
gooba has left #commonlisp [#commonlisp]
kevingal has joined #commonlisp
gooba has joined #commonlisp
gooba has quit [Client Quit]
chiselfuse has quit [Remote host closed the connection]
chiselfuse has joined #commonlisp
<dino_tutter>
i just spent 5+ hours debugging a macro that was using `macrolet` and giving me weird compiler errors when what i wanted was `symbol-macrolet`, oops
<beach>
Heh!
pve has joined #commonlisp
paddymahoney has quit [Ping timeout: 260 seconds]
<dino_tutter>
maybe LLMs have a future in "this obscure SBCL error" -> "you are using function X when you want function Y" ?
mwnaylor has quit [Ping timeout: 276 seconds]
ingeniot has joined #commonlisp
pranav has joined #commonlisp
pranav has quit [Read error: Connection reset by peer]
ingeniot has quit [Quit: Client closed]
<cosimone>
beach: i see, i tried looking up the macroexpansion, but i couldn't understand exactly what was going on
<beach>
cosimone: You might try to read the relevant section of the AMOP to see what i supposed to happen.
<cosimone>
i don't see anything mentioning :initargs as a valid slot option
<cosimone>
the class-wide :default-initargs option is another thing entirely
pranav has joined #commonlisp
Shinmera has quit [Quit: WeeChat 3.8]
Shinmera has joined #commonlisp
McParen has joined #commonlisp
random-nick has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
spdegabrielle has quit [Quit: Connection closed for inactivity]
Colleen has quit [Quit: Colleen]
Colleen has joined #commonlisp
dinomug has quit [Remote host closed the connection]
sailorCa- has quit [Remote host closed the connection]
X-Scale has joined #commonlisp
sailorCa- has joined #commonlisp
q3cpma has joined #commonlisp
<q3cpma>
Hello, I have the ambition of locally "fixing" cl:search to provide :key1 and :key2 instead of (or in addition to) the standard :key that applies to both sequences, but while keeping speed. How would you do such a thing? At first, I tried forking some of SBCL's code, but it's basically impossible to get the banana without the gorilla and jungle here...
decweb has joined #commonlisp
<nil>
It seems in Lisps with CLOS derived from PCL, like sbcl and ccl, since slots have a "initargs" slot, you can conveniently set it from defclass.
X-Scale has quit [Ping timeout: 256 seconds]
skeemer has joined #commonlisp
<nil>
q3cpma: I'd say just make a search wrapper that wraps the test function. Compilers may do a lot of tricks to make ‘search’ faster. I guess you could write one from scratch or out of other sequence functions and compare performance.
<q3cpma>
nil: huh, good idea. Actually pretty ashamed I didn't think of it!
<q3cpma>
Thanks!
<q3cpma>
(am I the only one that was annoyed to find that search can't easily act as a generalization of find with a sequence needle?)
<jackdaniel>
is CCL's clos derived from PCL?
kevingal has quit [Ping timeout: 248 seconds]
runxiyu has quit [Quit: ZNC 1.8.2+deb3.1+deb12u1 - https://znc.in]
runxiyu has joined #commonlisp
zwr has quit [Read error: Connection reset by peer]
zwr has joined #commonlisp
cryptk has quit [Ping timeout: 245 seconds]
cryptk has joined #commonlisp
cryptk has quit [Read error: Connection reset by peer]
cryptk has joined #commonlisp
cryptk has quit [Remote host closed the connection]
cryptk has joined #commonlisp
<cosimone>
nil: i wasn't aware of that, interesting
<cosimone>
still, :initargs doesn't seem to be allowed as an individual slot option in standard CL if i'm not mistaken
cryptk has quit [Remote host closed the connection]
shawnw has quit [Ping timeout: 248 seconds]
cosimone has quit [Remote host closed the connection]
yitzi has joined #commonlisp
spdegabrielle has joined #commonlisp
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
synchrom1 has joined #commonlisp
synchrom2 has joined #commonlisp
ftzm has quit [Ping timeout: 245 seconds]
synchromesh has quit [Ping timeout: 260 seconds]
synchromesh has joined #commonlisp
benjaminl has quit [Ping timeout: 248 seconds]
benjaminl has joined #commonlisp
synchrom1 has quit [Ping timeout: 260 seconds]
synchrom2 has quit [Ping timeout: 252 seconds]
zxcvz has joined #commonlisp
JuanDaugherty has joined #commonlisp
supercode has joined #commonlisp
fermat has joined #commonlisp
susam has joined #commonlisp
McParen has left #commonlisp [#commonlisp]
JuanDaugherty has quit [Quit: JuanDaugherty]
amb007 has quit [Ping timeout: 244 seconds]
amb007 has joined #commonlisp
shawnw has joined #commonlisp
Akbar-Birbal has left #commonlisp [#commonlisp]
cosimone has joined #commonlisp
shawnw has quit [Remote host closed the connection]
shawnw has joined #commonlisp
Akbar-Birbal has joined #commonlisp
q3cpma has quit [Quit: nyaa~]
shawnw has quit [Ping timeout: 248 seconds]
kevingal has joined #commonlisp
emaczen has joined #commonlisp
<emaczen>
is there a recommended way of updating SBCL?
cosimone has quit [Remote host closed the connection]
emaczen` has joined #commonlisp
emaczen has quit [Read error: Connection reset by peer]
scymtym has quit [Remote host closed the connection]
scymtym has joined #commonlisp
attila_lendvai_ has joined #commonlisp
emaczen` has quit [Remote host closed the connection]
simendsjo has joined #commonlisp
rtypo has joined #commonlisp
skeemer has quit [Ping timeout: 252 seconds]
Akbar-Birbal has left #commonlisp [#commonlisp]
theruran has joined #commonlisp
heisig has quit [Quit: Leaving]
char has joined #commonlisp
<Bubblegumdrop>
I just build the debian package from source with apt-get source
<Bubblegumdrop>
I think you just install it again and it should work fine
<reb>
emaczen: I check out the HEAD of the Git repository and compile SBCL from source.
<Bubblegumdrop>
looks like they left...
<reb>
Sometimes people check back for answers.
char has quit [Remote host closed the connection]
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
emaczen has joined #commonlisp
<emaczen>
Wow, that was somewhat crazy -- I was having problems with sb-ext:save-lisp-and-die, but cross-compiling the latest version of SBCL with CCL seemed to do the trick
skeemer has joined #commonlisp
<Bubblegumdrop>
I didn't even know you could do that
<emaczen>
The install manual from the source gives an example of cross compiling
<emaczen>
It was something like sh make.sh -xc-host='path-to-ccl'
<emaczen>
Something was either wrong with the version of SBCL or the debian package of
<emaczen>
sbcl 2.1.11 because I couldn't save-lisp-and-die without being dropped into ldb
<Bubblegumdrop>
I was having that issue on ARM recently
<Bubblegumdrop>
what arch?
<emaczen>
linux-x86-64
<emaczen>
How does SBCL perform on ARM? Are you working on a Raspberry pi?
<Bubblegumdrop>
The compile step is painfully slow for some things (ironclad). Some programs that use ffi/groveller are slow to shell out too. Once you get the project built and loaded into an instance of the interpreter it's quite smooth.
<Shinmera>
it's plenty fast on a fast ARM chip
<Shinmera>
(like your phone, probably)
<Bubblegumdrop>
I haven't tried it on my phone
<Bubblegumdrop>
It's pretty noticable on an rpi though
<Shinmera>
Compiling anything on an rpi is noticeably slow
<Bubblegumdrop>
yes
<emaczen>
I don't remember too many details but I ended up choosing CCL for my Rpis like 7 years ago
<Bubblegumdrop>
I ought to give other impls a shot
<emaczen>
But I really enjoy how fast vanilla SBCL is
<emaczen>
Bubblegumdrop: ABCL is pretty cool, it can be slow in some areas though.
X-Scale has joined #commonlisp
scymtym has quit [Read error: Connection reset by peer]
mgl has joined #commonlisp
scymtym has joined #commonlisp
<bigbookofbug>
hi all, i'm undertaking the task of rebuilding cl-wayland currently under a new and updated package, and had a quick question since im not too experienced in CLOS or CFFI. i have a "wl-list" class around the "wl_list" struct which contains two pointers. my class slots reference these using cffi:foreing-pointer, and during initialization have to foreign-alloc memory to hold the struct
zxcvz has quit [Quit: zxcvz]
<bigbookofbug>
my question is: is there a method i can target to de-allocate the memory when an instance of the class goes out of scope, or would this just be a method i'd need to define a generic for and impliment myself
<bigbookofbug>
i learned about trivial-garbage, so currently what i have is that added into the "initialize-instance" method for the class to free the memory on gargbage collection, but am unsure if this is the best way of handling foreign memory. i was also considering a `use-wl-list` macro to wrap usage into an unwind-protect but that seems like it could get too verbose too fast
supercode has quit [Quit: Client closed]
treflip has joined #commonlisp
treflip has quit [Quit: Quit]
<cow_2001>
what's a synchronized-hash-table? duckduckgo and google won't answer
<cow_2001>
oh woops it's a local function
<cow_2001>
oh, it's a key to make-hash-table
<Bubblegumdrop>
bigbookofbug foreign pointers on startup/shutdown are annoying. as far as I know there is not standard "Destructor" type method for CLOS objects, "they never go out of scope"
<Bubblegumdrop>
bigbookofbug This is the process I usually follow, I think with your save-lisp-and-die you can specify a "startup" function and a "shutdown" function. that's where you'll allocate your foreign pointers https://recursive.games/posts/Beware-foreign-memory-in-lisp-images.html
<ixelp>
Recursive Gaming
<Bubblegumdrop>
I don't know of any reference counting libraries or any better way to do this
cage has quit [Quit: rcirc on GNU Emacs 29.4]
<Bubblegumdrop>
perhaps you can abuse reinitialize-instance ?
<bigbookofbug>
Bubblegumdrop: this is a good resource, ty ! i didn't know that instances never go out of scope, so i'll need to keep that in mind as i go forward
<bigbookofbug>
is that the case for (let ((my-instance (make-instance ...))) ...) formulations as well?
<aeth>
I always put manually managed stuff inside of an unwind-protect, usually inside of a with-foo macro defined for that unwind-protect, and often with a CLEANUP generic function if CLOS is used.
<aeth>
Libraries that try to be too clever (e.g. cl-sdl2) will undermine this to some extent. In which case, the solution is to (eventually) replace such libraries.
<bigbookofbug>
i intend to ship this as a library rather than an image so i'll keep those differences in mind as well re the recursive gaming article. the only binary should be the scanner, which won't call cffi at all thankfully
<aeth>
The way you deallocate when it goes out of scope is to, inside of the unwind-protect, call the cleanup method.
<aeth>
This means anything that can hold a foreign pointer can actually hold NIL as well, since you want to set it to NIL after you clean it up, so you can avoid double freeing
mishoo has quit [Ping timeout: 252 seconds]
<bigbookofbug>
aeth: i might need to do that ultimately if clos instances indeed don't leave scope. right now im still porting a lot of the defcfuns since wayland itself is pretty big, and making sure unit tests succeed as i go along the process
<bigbookofbug>
are there any good libraries that use this method that i could use for reference in the meantime ?
<aeth>
To be clear... The user should (almost) never call make-instance or make-foo directly (unless they want to manually manage it themselves). The user should call a with-foo (see e.g. static-vectors:with-static-vector) which binds the object to a LET around an UNWIND-PROTECT. The first part of the UNWIND-PROTECT is the body (in a PROGN) and the second part cleans up the class (for instance, a generic
<aeth>
CLEANUP function that works on all such classes)
<ixelp>
static-vectors/src/impl-sbcl.lisp at 3d9d89b4950b72e0e5bdacfcdfd366bde72386d2 · sionescu/static-vectors · GitHub
<bigbookofbug>
thanks! initial plans were to call make-foo directly, so i can modify that accordingly
<aeth>
This sort of thing applies to all "resources" (e.g. with-open-file... SBCL does seem to use a fancier version of this LET then UNWIND-PROTECT pattern to implement it when I M-. to source... just to CLOSE, not to free), not just FFI-adjacent things.
<aeth>
bigbookofbug: You do want to still expose make-foo in addition to with-foo, you just want to strongly discourage its use. The user uses make-foo instead of with-foo when the user is putting FOO inside of a class that itself is put inside of its own unwind-protect.
<aeth>
This is why I personally define a cleanup method for such things. Now the unwind-protect is trivial and the cleanup method is trivial as well, since it will just recurse on everything that has its own cleanup. Is using a method slow? Probably, but this isn't a hot-loop kind of thing, it's a do-after-ending-the-program kind of thing.
X-Scale has quit [Ping timeout: 256 seconds]
mwnaylor has joined #commonlisp
neuroevolutus has joined #commonlisp
<aeth>
I _almost_ want to turn this into its own library. Literally just (defgeneric cleanup (object)) but the real utility is that the unwind-protect can then just call CLEANUP or CLEANUPs
<bigbookofbug>
yeah, there's a lot of subclassing with the wayland primitive types especially, so i'll expose both. thank you! CLOS has been one of the murkier parts of cl for me because i don't have much experience in OOP conceptually
<bigbookofbug>
i know C like the back of my hand but oop is sort of novel to my -- cl is actually my first encounter with it
<aeth>
CLOS is, to me, one of the most overkill, overengineered OOP systems, at least with the metaobject protocol extension that's technically nonstandard.
<aeth>
But it fits in CL because CL is not a language to tell you that you can't do something.
neuroevolutus has quit [Quit: Client closed]
<aeth>
I think only Perl is comparable here?
<aeth>
So it's not very typical for OOP if there are only a few programming language (of many!) that might possibly have something similar.
<Bubblegumdrop>
I was also going to suggest something similar to (defgeneric cleanup (object)). aeth you absolutely should publish this code.
<aeth>
Bubblegumdrop: I do use it, in my game engine's util library, which is distinct from my game engine so I can pull it in all of my projects without pulling in a gigantic, incomplete game engine.
<aeth>
Bubblegumdrop: However, the point of (defgeneric cleanup (object)) would be to :use it so there's only ever one canonical CLEANUP when used recursively, so it would have to be in its own library.
<aeth>
The only other generic function with similar utility would probably be NAME
neuroevolutus has joined #commonlisp
<Bubblegumdrop>
aeth mito uses :metaclass to do some weird stuff with database access objects (DAOs). I wonder if you could do something similar? I don't understand enough about MOP yet
k_hachig_ has joined #commonlisp
k_hachig_ is now known as k_hachig
<Bubblegumdrop>
I wrapped this functionality with a registered-table-class that abuses class allocation on a slot to keep a map of every object in every package that uses (:metaclass registered-object)
<ixelp>
2023-12-17: REGISTERED-TABLE-CLASS for MITO
amb007 has quit [Ping timeout: 246 seconds]
<aeth>
Bubblegumdrop: Fancy is where bugs live and bugs in CFFI-related things tend to crash the entire Lisp process because that's what C or C++ would do in that situation.
<Bubblegumdrop>
yes
<aeth>
Calling cleanup on an unwind-protect exit is, more or less, what a well-behaved C++ program would expect, and so it shouldn't be too incompatible with CFFI usage.
<aeth>
If you want flexibility, don't interface with C things, which ultimately means use Mezzano. :-p
<paulapatience>
Bubblegumdrop: aeth: or (defgeneric cleanup (client object)), if you want to be able to share the same class between different backends that clean up differently.
mgl has quit [Ping timeout: 255 seconds]
<aeth>
paulapatience: sounds like it should have a different name?
<aeth>
cleanup should be dead-simple because if it's not, you're probably introducing bugs
<aeth>
paulapatience: the extremely simple way to do it would be to use subclassing in your use case... the parent class is free to be used by either, but the child class controls how it is cleaned up. You do not want to give the responsibility to cleaning up resources to two things simultaneously, and you want it known in advance.
attila_lendvai_ has quit [Ping timeout: 252 seconds]
<paulapatience>
aeth: Sure
<paulapatience>
It should be simple
<paulapatience>
But the most general protocol for something like that would be with a client parameter
<paulapatience>
If there are not many classes, you can get by with subclassing, but there might be situations with many many
<paulapatience>
Then who knows, the library might want to specialize cleanup on a hash table
amb007 has joined #commonlisp
<aeth>
You don't want the most general protocol. You want the hardest protocol to mess up. This, as described, already leaves plenty of room for error because it's up to the user to set the slots to NIL when cleaned up and even then, the values of those slots could still exist as references elsewhere if the use was undisciplined.
<aeth>
Now make it more general and it becomes even easier to mess up.
<aeth>
If you want to do something fancy with foreign memory, then copy it into CL memory first. And if you can't do that because it's large, then your problem space is just inherently difficult.
<paulapatience>
I'm not suggesting that users should specialize :around and other method variants. Just to allow not having to subclass everything and to make it possible to specialize to standard CL classes.
<aeth>
This cleanup method more naturally operates with composition. That is, put everything with a cleanup method in a class (as slots). Then write a cleanup method that calls cleanups on all slots that need to be cleaned up. So subclassing is not the only way.
varjag has joined #commonlisp
<paulapatience>
Also, cleanup is not specific to foreign memory; it's anything to do with resources, as I think you mentioned above.
<aeth>
Yes, I am aware. However, most such resources are still FFI if the OSes are C, except those exposed by the implementation (I think portably, that's just open files?) or those you can implement entirely in Lisp.
<aeth>
Perfect generality is thus opposed to the main use case, which requires care to not break the safety that CL normally gives you.
jonatack has joined #commonlisp
jdz has quit [Quit: I'm done]
jdz has joined #commonlisp
jon_atack has quit [Ping timeout: 244 seconds]
wacki has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
neuroevolutus has quit [Ping timeout: 256 seconds]
szkl has quit [Quit: Connection closed for inactivity]
amb007 has quit [Ping timeout: 244 seconds]
mwnaylor has quit [Ping timeout: 276 seconds]
jonatack has quit [Ping timeout: 255 seconds]
<Bubblegumdrop>
(with-safe-code ...)
pve has quit [Quit: leaving]
skeemer has quit [Ping timeout: 245 seconds]
mwnaylor has joined #commonlisp
amb007 has joined #commonlisp
<emaczen>
So, I just did the whole nginx proxy_pass to hunchentoot deal, and it is really slow at loading images -- Is this likely because of proxying or is it because of hunchentoot?
<emaczen>
It reminds me of earlier days of the internet... lol
jonatack has joined #commonlisp
amb007 has quit [Ping timeout: 265 seconds]
<Bubblegumdrop>
not sure
<Bubblegumdrop>
are you able to host some static images and see how those are?
meaty has joined #commonlisp
alcor has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 255 seconds]
<emaczen>
Bubblegumdrop: I'm thinking at the moment that the images need resized/compressed. I'm used to just developing locally, so I don't know what to expect or what is normal
<Bubblegumdrop>
if you're local loading images should be pretty fast
<Bubblegumdrop>
are you resizing images or compressing them somehow?
<emaczen>
Yeah, I never noticed it when I was developing locally. Now, I have it on an nginx server proxy passing to hunchentoot and it is like a throwback to 2004!
<emaczen>
I'm probably going to have to, but I'm going to sum up the total image size and see if I can find out "what is normal" in terms of page load sizes etc.
<emaczen>
I was curious though, if there are any hunchentoot deficiencies or not.
<Bubblegumdrop>
loading images locally should be fast
<emaczen>
It is fast locally. Loading them from the server is 2004 slow
<Bubblegumdrop>
your server?
<Bubblegumdrop>
I'm a bit confused what your setup is like. You have a lisp app running on localhost, then a remote server somewhere in the cloud running nginx?
<emaczen>
the lisp app on localhost is just for experimenting/developing. Then I sb-ext:save-lisp-and-die my program and scp it to a server that has SBCL and nginx installed
<emaczen>
The nginx is configured for proxy passing to hunchentoot
<emaczen>
Make sense?
<Bubblegumdrop>
yes that's a bit more clear
<Bubblegumdrop>
is the server the nginx is on normally fast to serve static images? are you able to test that/
markasoftware has joined #commonlisp
markasoftware_ has quit [Ping timeout: 276 seconds]
kevingal has quit [Ping timeout: 265 seconds]
pillton has joined #commonlisp
shawnw has joined #commonlisp
donleo has quit [Ping timeout: 255 seconds]
<emaczen>
Bubblegumdrop: I'm working on it :)
rtypo has quit [Quit: WeeChat 4.4.2]
supercode has joined #commonlisp
kpg has joined #commonlisp
shka has quit [Quit: Konversation terminated!]
<fe[nl]ix>
aeth: SBCL has some issues with interrupt safety so with-static-vector needs to be the way it is