contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
semz has quit [Ping timeout: 250 seconds]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
amk has joined #lisp
Josh_2 has joined #lisp
<Josh_2>
How can I connect to a lisp image that is already running in sly?
<Josh_2>
My emacs has frozen and I need to connect to the image it had running
<Josh_2>
I don't know if the underlying lisp image has frozen
<tetrahedron>
Josh_2: SLY or SLIME?
<Josh_2>
Sly
<pjb>
Josh_2: well, I don't know about sly, but if a swank server is running, you connect to it with M-x slime-connect RET
<Josh_2>
just got a connection refused
<Josh_2>
:(
johnjay has quit [Ping timeout: 260 seconds]
<pjb>
Of course, if there's no swank server listening, the only solution would be to do a gdb attach to the frozen emacs process, and to try to locate and use the socket connected to the image.
<pjb>
Perhaps closing it would be enough, if the swank server loops on listening.
<tetrahedron>
i think this config var is what you need to fix to choose a lisp server
<pjb>
Josh_2: if this problem occurs often, you could prepare by running multiple swank servers in the lisp image, or some other listening server.
johnjay has joined #lisp
<Bike>
this looks like slime's communication style, which isn't quite the same
<Bike>
seems there's an M-x sly-connect to use
<Josh_2>
I tried that
<Bike>
though you'll have to figure out what port the lisp is listening on if any
<Josh_2>
It must have frozen
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
<pjb>
sudo netstat -tpnl |grep $your_lisp
<Josh_2>
nothing :(
logand` has joined #lisp
hiroaki has quit [Ping timeout: 246 seconds]
yonkunas has quit [Quit: Connection closed for inactivity]
<Josh_2>
ah well
<pjb>
Without the -l you can see the open connections: sudo netstat -tpn |grep $your_lisp
logand has quit [Ping timeout: 240 seconds]
<pjb>
If it's still connected to emacs, as I said above, you can use gdb to attach to the frozen emacs, try to locate the socket and close it.
<pjb>
Or just kill the frozen emacs.
<Josh_2>
If I kill the frozen emacs that will shut the lisp image
<pjb>
So you mean that the lisp image was launched by emacs.
<Josh_2>
Yep
<pjb>
You're doomed.
<Josh_2>
Yeh xD
<pjb>
Instead, launch your lisp images separately, run a swank server in it, and use slime-connect instead of slime.
<tetrahedron>
how bad would that be Josh_2 :/
<Josh_2>
Not that bad tetrahedron
<Josh_2>
I will be able to fix it
<Josh_2>
pjb: I will do that, I have been meaning to create a deploy system for this. Lesson learned
vv8 has quit [Ping timeout: 265 seconds]
gigamonkey has quit [Remote host closed the connection]
gigamonkey has joined #lisp
gigamonkey has quit [Ping timeout: 260 seconds]
hoz has left #lisp ["ERC (IRC client for Emacs 26.1)"]
frost-lab has joined #lisp
ikrabbe|2 has joined #lisp
ikrabbe has quit [Ping timeout: 265 seconds]
akoana has left #lisp ["Leaving"]
mindCrime_ has quit [Ping timeout: 240 seconds]
<Josh_2>
I export a macro called 'pkv' from my main package and in a sub package, I use this macro extensively, this package has (use <main package>) in its defpackage, why am I getting an error telling me that pkv isn't defined?
<no-defun-allowed>
Stupid question, use or :use?
<Josh_2>
:use
<no-defun-allowed>
I'm out of ideas then.
<Bike>
well, from that description it should work, so clearly there's some devil in the details
<Bike>
what particular error do you get? udnefined function?
<Josh_2>
yes
<Bike>
you might have to share source then
ramHero has quit [Ping timeout: 260 seconds]
mindCrime_ has joined #lisp
mindCrime_ has quit [Ping timeout: 240 seconds]
<Josh_2>
Well
<Josh_2>
what part?
<White_Flame>
are you (in-package ..) correctly?
<Bike>
the package definitions, i guess
<White_Flame>
(as a 2nd stupid question)
<Josh_2>
White_Flame: yes I have (defpackage .. ) then (in-package ..) after
<Josh_2>
And then describing it while in that package it returns what I'd expect
<Josh_2>
'pkv names a macro ... '
<White_Flame>
single-colon, and it says it's exported?
<Bike>
and it actually exists? (macro-function 'pkv) in mm-module.jitsi returns something?
<White_Flame>
if you just C-c C-c an expression, instead of C-c C-k'ing the entire file, it might not have actually run the in-package. I've hit that on simple files
rumbler31 has joined #lisp
hineios6 has joined #lisp
hineios has quit [Ping timeout: 265 seconds]
hineios6 is now known as hineios
jeosol has quit [Quit: Connection closed]
<Josh_2>
Okay I fixed
<Josh_2>
Turns out it was absolutely nothing to do with that package...
<White_Flame>
let me guess, pvk vs pkv?
<Josh_2>
nope, I was using pkv before it was defined in a class definition file
<White_Flame>
that'll do it
<White_Flame>
it's weird not to load the full contents of a package before loading another one, though
<Josh_2>
Now I have another odd issue
<beach>
Good morning everyone!
<White_Flame>
re beach
Alfr is now known as Guest98335
Guest98335 has quit [Killed (cherryh.freenode.net (Nickname regained by services))]
Alfr has joined #lisp
<Josh_2>
Okay
<White_Flame>
okey dokey
<White_Flame>
here we gokey
<Josh_2>
Fixed it
<Josh_2>
Man I got you all excited, sorry xD
thmprover has quit [Quit: Goodnight, ladies, good night, sweet ladies, good night, good night]
<White_Flame>
don't get me wrong, I'm happier to debug my own code than someone else's ;)
<Josh_2>
Well I guess having to restart was a blessing in disguise
<White_Flame>
restarting fixes a lot, but doesn't always tell you where the problem is, especially if it's dynamically munged
<White_Flame>
in the latter, you want to poke in the currently messed up state
marusich has quit [Ping timeout: 246 seconds]
skapate has joined #lisp
<Josh_2>
In this case restarting brought up a few problems
<Josh_2>
I hadn't stopped the image for about a week
<huonib>
does anyone know of a compiled, dynamic language that doesn't use a garbage collector? I think an academic one might exist, but I am not sure
<huonib>
I am unsure if being dynamic requires a garbage collector... and I cannot find anything making that claim online
<Krystof>
I would not say that being dynamic requires a garbage collector
<Krystof>
As a concrete example, I would expect many Forths not to have a garbage collector
<Bike>
"dynamic" is a really vague term.
<jackdaniel>
put in your init (ext::disable-gc) and there you go, common lisp doesn't use the garbage collector ;-)
<jackdaniel>
don't expect it to work for long though
<Krystof>
I seem to recall stories about Lisp Machines needing to be power-cycled because they really really believed in tenure
<Xach>
I recently learned that Allegro has an operation "panify" to ensure that certain objects never grow old
<Bike>
heh.
<Xach>
(as in peter pan-ify)
paulj` has joined #lisp
phantomics has joined #lisp
paulj` has quit [Remote host closed the connection]
paulj` has joined #lisp
<jcowan>
huonib: GC is what you do to the heap, and Forth has no heap, only two stacks. (Which at that is better than Fortran II, which has neither heap nor stack.)
<jcowan>
s/II/II or 66
paulj` has quit [Client Quit]
paulj has joined #lisp
<phantomics>
Here's a question, not sure if this is completely off the wall ridiculous or not: how practical would it be to create a dialect or DSL within CL that runs code without GC? Meaning inside the code written in this DSL, you would have to manually manage memory and there would be functions for that
<phantomics>
Seems like something that could aid in doing realtime apps in CL
<Bike>
it would be difficult for objects in a managed space to refer to objects in an unmanaged space and vice versa. though it's possible. i mean, most implementations can handle foreign pointers.
tetrahedron has quit [Ping timeout: 240 seconds]
<Bike>
but if an object in unmanaged space has a pointer to an object in managed space, and the collector tries to move things, problems will happen
<phantomics>
Yeah, if CFFI is possible I'd think something like this should be, I don't know if CLs have any functions that let you turn off GC for objects created within a particular block of code
gigamonkey has joined #lisp
<Nilby>
phantomics: When heavily using a C FFI objects you have to somewhat restrict yourself to such a dialect. Thank goodness for with- macros. There are also some foreign calls which necessitate turning off GC in some implementations.
Feldman has joined #lisp
<Shinmera>
The easiest way to prevent GC is to just not allocate.
gigamonkey has quit [Ping timeout: 265 seconds]
<Shinmera>
And that's not even a joke. Allocate things once in a block, then manually recycle the objects. Presto, no GC.
villanella has joined #lisp
<Shinmera>
You don't need a DSL or whatever for that, just a lot of restraint and a lot of annoying manual recycling, just when you manually malloc/free.
<Shinmera>
*just like
<Bike>
it might be nice if the compiler could help by flagging function calls that allocate, though.
<Shinmera>
For sure. Being able to see which functions are pure would be nice.
<Shinmera>
But not even a DSL can help with that (you can't know what's going to allocate without help from the compiler)
<Bike>
yeah.
<Nilby>
I seem to remember there was a CL that compiled to non-GC'd C code.
ukari has quit [Ping timeout: 265 seconds]
<Nilby>
and they reccommended just such restraint
<Shinmera>
One trick I've been making use of in Kandria recently is, since I know some things are going to run single-threaded, but I cannot stack-allocate certain complex objects, I can instead use load-time-value to create a local instance that'll be re-used. Certainly less handy and more dangerous than stack allocation, but it does the trick.
heisig has joined #lisp
<Bike>
there have been a couple times when i've been like "i know, i'll do the l-t-v trick" and then remembered other threads exist. very sad
<Shinmera>
Yep :(
<Bike>
takes me back to learning C and failing to understand static
<Shinmera>
Heh
<mfiano>
Shinmera: Interesting. Can you link to one part of your code that does that? I'd like to see it in context.
<phoe>
what is the issue with l-t-v in a multithreaded context? race conditions, or also something else?
<Bike>
well we're talking specifically about using a load-time-value object
<Shinmera>
if two threads access the same function at the same time they'll use the same instance and thrash it
<Bike>
there's only one, so if multiple threads try to use it at the same time, problems
<semz>
Nilby, I recall something like that as well, but iirc it had a supremely ungoogleable name like CL- or something...
<Bike>
same reason you can't use static in reentrant C functions
<mfiano>
AH I have recently start stack-allocating some vectors in my collision detection codes, and some lexical variables cannot be stack allocated because they call c2mop:s-i-a or something. Was trying to figure out what I could do about it
heisig has quit [Ping timeout: 240 seconds]
<mfiano>
But I did make it more manageable. I had a OBB struct with like 20 slots, mostly all for mutating temp variables. It was a mess lol. Now there's only 5, with 2 of them being an unfortunate temp variable
mister_m has quit [Ping timeout: 260 seconds]
<semz>
Turns out I was thinking of CL_1 as defined by CLICC, but that does seem to have a GC, so probably a different project.
ech has quit [Ping timeout: 240 seconds]
bgardner has quit [Quit: Konversation terminated!]
tetrahedron has joined #lisp
<beach>
I define "dynamic language" as one with semantics defined by a suite of interactions.
<beach>
I use "interactive language" as a synonym.
epony has quit [Remote host closed the connection]
<Josh_2>
Whats the sbcl function to drop into the top level repl?
epony has joined #lisp
notzmv has joined #lisp
ljavorsk has quit [Ping timeout: 252 seconds]
<Xach>
Josh_2: toplevel-init (not an external symbol)
tetrahedron has quit [Quit: WeeChat 3.1]
<Josh_2>
Thanks
maxwilliamson has quit [Remote host closed the connection]
<jmercouris>
anyone can think of a way of writing a function "string" -> unique number?
maxwilliamson has joined #lisp
<mfiano>
hash it
<Josh_2>
^
<jmercouris>
hashes have collisions
<phoe>
so you want bignums
<jmercouris>
phoe: ?
<phoe>
you need bignums to encode arbitrary strings without collisions
<jmercouris>
I guess so
<jmercouris>
I would be considering each letter a number in base 26
<jmercouris>
in that kind of a straightforwards case
<phoe>
convert your string into a byte array, append the string's length to it, convert the result into an integer
<jmercouris>
hm, or that, that is much simpler
<mfiano>
(sxhash "foo") would probably be acceptable and not collide with 61 bits on SBCL
<mfiano>
62*
<jmercouris>
let me start with the base problem actually
<phoe>
yes please
<jmercouris>
I want to make a mode, and represent it with a unique glyph in nyxt
<jmercouris>
I want to be able to do this automatically
<phoe>
mode, as in?
<jmercouris>
the modes the user has active
<phoe>
are we talking emacs-like modes?
<phoe>
major, minor modes, et cetera?
<jmercouris>
yes, like that
mister_m has joined #lisp
<phoe>
my UX instincts are telling me that modes should provide some sort of taskbar-like icon that can then be displayed, but that's orthogonal to your issue
<jmercouris>
you are correct
<jmercouris>
there is a glyph slot that the user can set
<jmercouris>
however, when it is NOT set, what to show?
<phoe>
that's not really a #lisp question I think :D you can try to use the first letter of the mode, or something
<jmercouris>
well it is a #lisp question in the sense that I want to go from string -> unique glyph
<phoe>
and provide more information when the user mouseovers above it
<jmercouris>
glyph can be a unicode value
<phoe>
sxhash is likely going to be good enough for your use case then
<jmercouris>
OK, thanks
<phoe>
I don't think you're going to have modes at a scale where collisions become likely
<phoe>
(mostly because you won't have enough screen to fit all those mode glyphs at once)
<jmercouris>
probably not, just my pedantic CS self thinking about it 11
<Nilby>
Websites, e.g. github, google docs, do this with random semi-unique user icons.
<phoe>
and, honestly, I think that providing icons and falling back to first letters of each mode name is going to be much better than generating tiny semirandom icons that users will need to memorize anyway before being able to use them well enough
<phoe>
but that's already UX zone
<jmercouris>
I think you're right phoe
<jmercouris>
I will do that
mister_m has quit [Ping timeout: 260 seconds]
<phoe>
in the worst case the mode line will look like
<phoe>
"MmW🖊️" or something
<jmercouris>
lol, that would be something
<phoe>
and all I'm using there is three ASCII letters and one cursed unicode symbol
<jackdaniel>
what you see there is a normal clim application run in the browser (the hunchentoot acceptor is also a frame manager)
ech has joined #lisp
<alanz>
jackdaniel, nice. Is there example code we can look at somewhere?
<Josh_2>
Well thats really cool jackdaniel
<jackdaniel>
not yet, but it is part of the manual for writing backends I'm working on
<jackdaniel>
so it will be public eventually
<jackdaniel>
(mind that no js is involved so far)
<Josh_2>
The less the better imo
<Josh_2>
I have dumped my lisp image and I'm now connecting to it using sly-connect. How do I get all the output to go through my connected repl instead of into the terminal that I started the image in?
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
bitmapper has joined #lisp
<jmercouris>
Josh_2: i don’t believe you can, when you start sly the *inferior lisp* buffer is always pushing some messages
<jmercouris>
I think the problem is in the case of CFFI that is writing to stdout for example
<jmercouris>
Though I’m not entirely sure of the conditions
<jmercouris>
I don’t know if that will capture all messages
<jmercouris>
I’ve had C code evade that I believe
<jackdaniel>
I thought that we talk about common lisp
<Josh_2>
How do I find my sly stream?
<jackdaniel>
even when you start your lisp from emacs other processes that write to stdout will still write to stdout
<jackdaniel>
Josh_2: type (defparameter cl-user::*my-stream* *standard-output*) in sly repl
<Josh_2>
well
<Josh_2>
maybe I should just deal with the output being in my terminal
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
mister_m has joined #lisp
silasfox has quit [Ping timeout: 265 seconds]
<phoe>
Bike: regarding the l-t-v trick, l-t-v CLHS page states that the object is treated as a literal; doesn't mutating it invoke UB then?
charles` has quit [Ping timeout: 276 seconds]
<mfiano>
I asked Shinmera the same thing
<Shinmera>
It sure does, but there's no incentive for it to not just work the way you expect it to.
<mfiano>
I think we all know we can't assume programmers to make sound decisions all the time. I can't guarantee an implementation won't be doing something funky, or my current implementation some time in the future.
<jackdaniel>
(pushnew :lean-and-mean *features*)
<phoe>
I guess an implementation could go ahead and define that behavior as possible and useful, then
<Shinmera>
sure.
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Nilby>
But there's an incentive as an implementation developer to have popular software run on your implementation.
<mfiano>
Might want to wrap that pattern up in a macro just to have a search point and a single place for a big comment.
<_death>
if I understand it correctly, the compiler treats it as a literal object, but it's still modifiable by the user, as long as read-only is nil, as the preceding paragraph says
<phoe>
yes, I can see that it is being confusing; generally, "modifiable data" and "literal object" should be disjoint sets
zulu-inuoe has joined #lisp
Feldman has joined #lisp
Oladon has quit [Quit: Leaving.]
<phoe>
and the specification is not very clear here
<_death>
literal here means it's "referenced directly in a program rather than being computed by the program".. I think it means the form is only evaluated once
<Nilby>
I think the Lisp aesthetic is to no have unmodifiable that exists.
<Nilby>
unmodifiable data that is
<Shinmera>
My favourite lisp aesthetic is being fast in the face of adversity. This includes having unmodifiable things at times.
ukari has joined #lisp
hypercube has joined #lisp
<pjb>
Shinmera: in general, compiled code is immutable.
<Nilby>
If it doesn't exist because it's optimized away, or it's existence is temporary, sure, but if you break in the debugger at the just right place, it's modifiable. I can accept things intentionally protected by memory barriers and such. It's also happens to be the aesthetic of assembly code.
<pjb>
:-)
rumbler31 has quit [Ping timeout: 265 seconds]
<pjb>
Nilby: code is data ;-)
orivej has joined #lisp
<Nilby>
I agree and I think compiled code should be modifiable.
contrapunctus has left #lisp ["Disconnected: closed"]
<pjb>
Nilby: it is not necessary. Non-controlled systems want to put the code in read-only memory to avoid exploits. Controlled systems want to prevent write access (and sometimes even read-access) to the code to ensure control and security. And in lisp we can always modify the source sexp and recompile.
<phoe>
jmercouris: what packages are those slot names from
<Nilby>
pjb: Yes, I agree it's not necessary, but still useful. I think it's basically game over for security if something can control Lisp code, but in some way beach's idea of top level first class environments is like having virtual lisp machines. I would like to think it could include hardware level protection, so that memory address and compiled code could still be safely modifiable.
notzmv has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 265 seconds]
<_death>
Nilby: you can do it today with implementation and platform specific means
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pjb>
Nilby: it is a choice: either you allow modifiable code, and then you need a system like unix with separate addressing spaces and crashes, or you prevent modifiable code, and even you prevent generating code vectors by random code, only compilers authorized by the system are allowed to produce code that is guaranteed not to crash, and then you can avoid the separate addressing space and use capabilities, environments and have bet
<pjb>
security.
<Nilby>
I guess I'm imagining I could have both, without crashing an O/S layer.
<Nilby>
I guess I'll have to wait for a portable with-lisp-vm that doesn't do something horrible like linux containers.
<_death>
namespaces/cgroups are kinda simple though.. just need a lisp library to wrap'em
davisr__ has joined #lisp
davisr_ has quit [Ping timeout: 268 seconds]
<Nilby>
_death: I don't feel like cgroups are simple: ls -R /sys/fs/cgroup/ | wc -l => over 6000!
<Nilby>
er, actually over 14k!
<Nilby>
Please forgive me for typing unix code in #lisp :(
Feldman has joined #lisp
norsxa has joined #lisp
norsxa has quit [Client Quit]
raeda has quit [Quit: Leaving]
zaquest has quit [Read error: Connection reset by peer]
zaquest has joined #lisp
norsxa has joined #lisp
silasfox has joined #lisp
<Bike>
phoe: if read-only-p is false, modifying load-time-value objects is fine
aartaka_d has quit [Read error: Connection reset by peer]
<Bike>
"it must be considered to be potentially modifiable data"
aartaka has joined #lisp
<Bike>
it's not ub
<_death>
Nilby: do they all have ad-hoc semantics?
gigamonkey has joined #lisp
mindCrime_ has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
silasfox` has joined #lisp
Feldman has joined #lisp
elflng has quit [Ping timeout: 240 seconds]
silasfox` has left #lisp [#lisp]
<_death>
Nilby: I guess a good reason to stay away from it is the constant churning though
silasfox` has joined #lisp
<Nilby>
_death: I don't know, but looking linux/Documentation/cgroup*/*.txt I got disgusted by the complexity and stupidity of the formatted file based API
silasfox` has quit [Client Quit]
notzmv has joined #lisp
varjag has joined #lisp
<Nilby>
I was actually considering how to wrap such a thing in Lisp without using foreign code above the kernel.
<_death>
I think at one point I looked at launching a qemu instance and communicating with it using zeromq
<Nilby>
That's much more sensible, but I have some dumb obsession with idea that I want 100% lisp code above the kernel.
sauvin has quit [Remote host closed the connection]
<semz>
there are dumber obsessions
ljavorsk has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
rogersm has quit [Quit: Leaving...]
notzmv has quit [Read error: Connection reset by peer]
mindCrime_ has quit [Ping timeout: 260 seconds]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
ikrabbe has quit [Ping timeout: 240 seconds]
<phoe>
Bike: yes, I assume that this passage takes precedence over clhs 3.7.1
<Bike>
ah, i suppose. "treated like a literal object at runtime" is a bit vague. i think it's mainly just emphasizing that the form is only evaluated once.
<phoe>
yes
<phoe>
that's the part that confused me
<Bike>
ltv is one of those things that didn't really make any sense to me until i implemented it
<Bike>
and even now it can confuse me at times
<phoe>
l-t-v is a thing that didn't make sense to me until I actually needed to use it
<Bike>
the really involved part is all the cycle detection and ordering of load time evaluations
<Bike>
it's kind of a lot of work for the compiler writer but programmers don't usually think about it
rumbler31 has joined #lisp
<pjb>
There's still ordering freedom left to the compiler. the order of the l-t-v forms is not specified IIRC.
zaquest has quit [Ping timeout: 240 seconds]
slyrus has joined #lisp
slyrus has quit [Ping timeout: 260 seconds]
<_death>
Bike: after thinking about it more, it's not just that it's evaluated once, but also that the object is returned as-is, not, say, copied (according to some definition of copied)
<Bike>
in some way making it non-eq? i suppose so
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
Inline has joined #lisp
notzmv has joined #lisp
VincentVega has quit [Quit: Connection closed]
dinnu93 has quit [Remote host closed the connection]
Nilby has quit [Ping timeout: 250 seconds]
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Feldman has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
semz has quit [Read error: Connection reset by peer]
davisr_ has joined #lisp
davisr_ is now known as davisr
curtosis[away] has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
skapata has joined #lisp
davisr__ has quit [Ping timeout: 260 seconds]
Codaraxis has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ljavorsk has joined #lisp
amb007 has joined #lisp
klltkr has joined #lisp
galex-713 has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has joined #lisp
notzmv has quit [Ping timeout: 252 seconds]
thinkpad has quit [Ping timeout: 260 seconds]
thinkpad has joined #lisp
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
aeth has quit [Ping timeout: 265 seconds]
ukari has quit [Remote host closed the connection]
aeth has joined #lisp
ukari has joined #lisp
hiroaki has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
Feldman has joined #lisp
cosimone has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
davisr has quit [Ping timeout: 268 seconds]
davisr_ has joined #lisp
karlosz has joined #lisp
cage_ has quit [Quit: Leaving]
notzmv has joined #lisp
narimiran has quit [Ping timeout: 265 seconds]
notzmv has quit [Ping timeout: 246 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
hypercube has quit [Ping timeout: 265 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cosimone has joined #lisp
thinkpad has quit [Ping timeout: 265 seconds]
thinkpad has joined #lisp
ikrabbe has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
amb007 has quit [Read error: Connection reset by peer]
jeosol has joined #lisp
silasfox has quit [Ping timeout: 260 seconds]
amb007 has joined #lisp
VincentVega has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
hypercube has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
amb007 has joined #lisp
notzmv has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
sm2n_ has joined #lisp
sm2n_ is now known as sm2n
amb007 has joined #lisp
__jrjsmrtn__ has quit [Quit: Bye !]
eddof13 has joined #lisp
galex-713 has joined #lisp
slyrus has joined #lisp
__jrjsmrtn__ has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
slyrus has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
gigamonkey has quit []
DGASAU has quit [Read error: Connection reset by peer]
<mfiano>
Those #'map's are there because min1/max1 will be inputs to the function later on, and are required to be (simple-array single-float (3))
<mfiano>
This test code should be printing lists of fixnums, not floats
vv8 has quit [Ping timeout: 265 seconds]
cosimone has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
ech has quit [Ping timeout: 240 seconds]
<mfiano>
Also what did you mean by "not sure"?
<_death>
in your first gist, you have assert -1.0 < x < 1.0 so result will always be -1 or 0
<mfiano>
Yes, the actual domain doesn't matter...just has to be small enough for the result to be fixnumable
<mfiano>
So is it the case that the 2-arity floor is just missing a transform, or is there a better reason it didn't work?
<mfiano>
It seems if I assert with (assert (< #.(float (expt -10f0 9) 1f0) x #.(float (expt 10f0 18) 1f0))) your version works. Curious why such the unsymmetrical domain
<mfiano>
increasing lower or upper more fails
<_death>
well, (truly-the (unsigned-byte 32) (floor (the (single-float 0.0 65535.0) x) cell-size)) in the second gist (after fixing malformed syntax) seems to give no note
<_death>
(and it should actually be 65536.0)
<mfiano>
or in base 2, exponents 19 and 61 respectively
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
<jmercouris>
scymtym: what can we do with this?
<jmercouris>
performance optimization?
<jmercouris>
SBCL development?
<scymtym>
jmercouris: both. you can type in a lambda expression and investigate how SBCL processes it under different optimization policies
<jmercouris>
It is a cool project, don't get me wrong, just wondering what intent you had when developing it
<jmercouris>
I see
<phoe>
I'd place $5 that the intent was introspection into the SBCL compilation and IR generation process
<phoe>
better to work with things when they're laid out spatially
<jmercouris>
phoe: that was the outcome, was that the intent?
<phoe>
s/place/bet/
<phoe>
let's see if I lose my five bucks
zigpaw107613 has quit [Quit: Ping timeout (120 seconds)]
zigpaw107613 has joined #lisp
<Krystof>
mfiano: I don't understand what you mean by unbalanced domain. Example?
<mfiano>
Krystof: One moment
<scymtym>
phoe is right since he described what the program does and i made it do that intentionally. but i'm not sure where this discussion is supposed to go
<mfiano>
Krystof: Shall we take this to #sbcl?
<Krystof>
maybe to a mailing list; I'm about to go to bed
<Krystof>
or you can (trace :encapsulate nil sb-c::floor-derive-type-optimizer sb-c::floor-quotient-bound) to find what's not giving you the right answer
<Krystof>
SBCL is a bit conservative about its lower bound to floor in the presence of floating point arithmetic
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
notzmv has joined #lisp
rgherdt has quit [Ping timeout: 260 seconds]
surabax has quit [Quit: Leaving]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
villanella has quit [Ping timeout: 252 seconds]
random-nick has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
Feldman has joined #lisp
Feldman has quit [Client Quit]
karlosz has joined #lisp
Feldman has joined #lisp
sveit has joined #lisp
simplegauss has joined #lisp
mindCrime_ has quit [Ping timeout: 260 seconds]
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Feldman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
akoana has joined #lisp
sxmx has quit [Quit: WeeChat 3.1]
sxmx has joined #lisp
scm has quit [Quit: Leaving]
hiroaki has quit [Ping timeout: 260 seconds]
vv8 has joined #lisp
shka_ has quit [Ping timeout: 240 seconds]
curtosis[away] has joined #lisp
notzmv has quit [Ping timeout: 265 seconds]
charles` has joined #lisp
kevingal_ has quit [Ping timeout: 246 seconds]
kevingal has joined #lisp
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]