Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.2)]
sjl has quit [Ping timeout: 276 seconds]
Kaisyu7 has joined #lisp
Achylles has quit [Remote host closed the connection]
charh has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
Merdam has joined #lisp
Merdam has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 276 seconds]
<White_Flame>
In LOOP, I want a value calculated every iteration, via something like FOR or WITH, so that UNTIL can see it. What's the appropriate keyword to use there?
<White_Flame>
"for q = (calc ...) then (calc ...)" is what I currently have, which is lame
<White_Flame>
I use the calculated value in both UNTIL and COLLECT
<no-defun-allowed>
doesn't `for q = foo` already reevaluate foo for each iteration?
<White_Flame>
hrm, I thought the spec said it only evaluated it once
<no-defun-allowed>
i think that's `with`
<White_Flame>
but yeah, seems that this is the case
<White_Flame>
ah, for-as-arithmetic only evaluates each form once
galdor has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
<loke>
White_Flame: (loop for x = (calulcate) ...) is the right way
<White_Flame>
yeah, I re-tested and it does work
<White_Flame>
got it crossed with how (loop for x from ...) works
Merdam has joined #lisp
Merdam has quit [K-Lined]
cyberoctopi has quit [Ping timeout: 258 seconds]
sjl has joined #lisp
rumbler31 has quit [Remote host closed the connection]
* ebrasca
think "Next" webbrowser is cool!
rumbler31 has joined #lisp
oni-on-ion has joined #lisp
abhixec has quit [Remote host closed the connection]
cyberoctopi has joined #lisp
saravia has joined #lisp
charh has joined #lisp
kajo has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
madmuppet006 has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
madmuppet006 has joined #lisp
Kundry_Wag has joined #lisp
<madmuppet006>
I am trying to write a mandelbrot set program .. I can create an image but the image is incorrect .. I have tried reversing list of numbers but still get the same image .. can anyone have a quick look? thanks https://pastebin.com/r0mEgvVq
Kundry_Wag has quit [Ping timeout: 258 seconds]
kajo has quit [Ping timeout: 264 seconds]
kajo has joined #lisp
dddddd has quit [Remote host closed the connection]
cdegroot has joined #lisp
TikityTik has joined #lisp
cyraxjoe has joined #lisp
ludston has joined #lisp
Kundry_Wag has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
Oladon has joined #lisp
<no-defun-allowed>
You might want to consider using LOOP and formatting your code better.
defunkydrummer has joined #lisp
<Bike>
complex-number-iteration looks wrong to me. where's the constant?
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
nicball has joined #lisp
nicball has quit [Client Quit]
nicball has joined #lisp
groovy2shoes has joined #lisp
<beach>
Good morning everyone!
<defunkydrummer>
good morning Beach
khisanth_ has quit [Ping timeout: 276 seconds]
gruntmaster6000 has joined #lisp
eschatologist has quit [Remote host closed the connection]
lucasb has quit [Quit: Connection closed for inactivity]
defunkydrummer has quit [Remote host closed the connection]
gruntmaster6000 has quit [Remote host closed the connection]
gruntmaster6000 has joined #lisp
ring has joined #lisp
khisanth_ has joined #lisp
nicball has quit [Disconnected by services]
ring is now known as nicball
gruntmaster6000 has quit [Remote host closed the connection]
gruntmaster6000 has quit [Remote host closed the connection]
gruntmaster6000 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
gruntmaster6000 has quit [Remote host closed the connection]
gruntmaster6000 has joined #lisp
Kundry_Wag has joined #lisp
gruntmaster6000 has quit [Max SendQ exceeded]
gruntmaster6000 has joined #lisp
groovy2shoes has quit [Excess Flood]
groovy2shoes has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
gruntmaster6000 has quit [K-Lined]
igemnace has joined #lisp
linack has joined #lisp
sjl has quit [Ping timeout: 245 seconds]
MFGA has joined #lisp
MFGA has quit [Remote host closed the connection]
MFGA has joined #lisp
MFGA has quit [K-Lined]
notzmv has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
cyberoctopi has quit [Ping timeout: 255 seconds]
sauvin has joined #lisp
Lycurgus has joined #lisp
aindilis has joined #lisp
Oladon has quit [Quit: Leaving.]
linack has quit [Quit: linack]
Kundry_Wag has joined #lisp
nicball has quit [Remote host closed the connection]
nicball has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
nicball has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
deng_cn has quit [Quit: deng_cn]
deng_cn has joined #lisp
Inline has quit [Quit: Leaving]
stacksmith has quit [Ping timeout: 276 seconds]
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
cyberoctopi has joined #lisp
vlatkoB has joined #lisp
cyberoctopi has quit [Ping timeout: 255 seconds]
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
nicball has joined #lisp
MarkShuttleworth has joined #lisp
MarkShuttleworth has quit [Remote host closed the connection]
JohnMS_WORK has joined #lisp
dale has quit [Quit: dale]
TikityTik has quit [Quit: WeeChat 2.4]
Arcaelyx has quit [Ping timeout: 258 seconds]
nicball has quit [Remote host closed the connection]
Folkol has joined #lisp
nicball has joined #lisp
nicball has quit [Ping timeout: 245 seconds]
miatomi has quit [Ping timeout: 276 seconds]
gigetoo has quit [Ping timeout: 276 seconds]
v88m has quit [Quit: Quit]
v88m has joined #lisp
miatomi has joined #lisp
gigetoo has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nicball has joined #lisp
<splittist>
morning #lisp
<beach>
Hello splittist.
nicball has quit [Ping timeout: 250 seconds]
nowhere_man has quit [Ping timeout: 276 seconds]
varjag has joined #lisp
miatomi has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
miatomi has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
Folkol has joined #lisp
libertyprime has joined #lisp
cyberoctopi has joined #lisp
cyberoctopi has quit [Ping timeout: 258 seconds]
Lord_of_Life has quit [Ping timeout: 276 seconds]
Lord_of_Life has joined #lisp
defaultxr has quit [Ping timeout: 258 seconds]
nicball has joined #lisp
longshi has joined #lisp
defaultxr has joined #lisp
schweers has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nicball has quit [Remote host closed the connection]
<schweers>
I have a very simple class, of which many instances are created. Can using a struct instead significantly reduce the memory footprint of these instances? How can I find out the difference (apart from creating loads of instances and comparing how much memory usage the OS sees, that is)?
nicball has joined #lisp
miatomi has quit [Ping timeout: 258 seconds]
<beach>
schweers: If the class is small, then I think the overhead could be non-negligible.
<beach>
schweers: A class instance needs an indirection that a struct instance may not have.
<phoe>
schweers: measure, measure, measure
<beach>
schweers: Plus, a class instance probably needs some indication of the state the class was in when the instance was created, so that instances can be updated when the class changes.
<phoe>
make a Lisp image with 10e6 class instances, measure the OS memory footprint; do the same with 10e6 structs, and then with 10e6 structs allocated as vectors
varjag has quit [Remote host closed the connection]
<schweers>
k, I’ll try that.
<schweers>
beach: in case you meant my small that the class has few slots, then yes, that is the case.
angavrilov has joined #lisp
<beach>
That's what I meant, yes.
nicball has quit [Ping timeout: 246 seconds]
angavrilov has quit [Read error: Connection reset by peer]
miatomi has joined #lisp
hhdave_ has joined #lisp
keep_learning has joined #lisp
<schweers>
I have another question: has anyone used lparallel? I don’t yet have hard evidence on this, but it seems to me, that a huge amount of memory is not freed, despite calling END-KERNEL.
<loke>
schweers: How do you determine that it's not freed?
<no-defun-allowed>
Maybe having multiple threads creates garbage faster. Also, it may be that checking htop or your favourite process lister might be confusing because your implementation might not free the memory in order to allocate it faster later.
<White_Flame>
you can manually run a GC (eg (sb-ext:gc :full t)), but also watch out that repl variables like *, **, *** aren't keeping large things alive
<schweers>
After end-kernel is called, the process quickly ended up in the debugger (a completely unrelated part of the program, which does not use lparallel). Meaning, the lisp process was still running, but not allocating any significant amount of memory. I have a memory consumption graph which shows that memry went up a lot at the time the lparallel using part of the program started, which did not go down afterwards.
angavrilov has joined #lisp
<White_Flame>
a GC cycle would have to run to decrease memory usage
<schweers>
Oh yes, I do call (sb-ext:gc :full t) after using lparallel.
<schweers>
So this is all not hard evidence, it’s just a hunch. I was asking as it was possible that someone else had a similar issue.
<no-defun-allowed>
Are you using Lisp functions like ROOM to determine memory usage, or external tools like htop or gnome-system-monitor?
cyberoctopi has joined #lisp
<no-defun-allowed>
It is fairly commonplace for runtimes to only release memory quite a while after the program is finished with it.
<schweers>
no-defun-allowed: I’m using external tools for this.
<loke>
schweers: That's probably the reason
<schweers>
This caused OOM later on for another task which uses lots of memory.
<loke>
Use the Lisp tools to get correct numbers.
<no-defun-allowed>
I would recommend you check again using (room) -- oh, weird.
<loke>
schweers: OOM is easily fixed by making sure you have enough Swap
<schweers>
otherwise I wouldn’t have cared
<loke>
I've seen a worrying trend where people don't understand how memory managemnt works and end up with installing Linux without sdwap
<schweers>
loke: I’d rather fix the root cause of the problem. I could also start up new processes each time.
<loke>
schweers: The root caus _is_ that you don't have Swap
<schweers>
The machine doesn’t have lots of swap, but I didn’t commit that particular crime ;)
<no-defun-allowed>
You should also avoid setting your implementation's heap size larger than the amount of memory you can afford.
<loke>
Just add some more (easily done using a swapfile)
cyberoctopi has quit [Ping timeout: 258 seconds]
Folkol has joined #lisp
kushal has quit [Remote host closed the connection]
<no-defun-allowed>
Also, zram and ksm may be useful.
<dim>
turn off overcommit in the kernel? that's a tunable...
<no-defun-allowed>
Or, maybe ksm is called something else.
keep_learning_M has quit [Quit: This computer has gone to sleep]
<no-defun-allowed>
dim: I was thinking of how some runtimes refuse to release pages it allocated before, so it doesn't have to acquire new pages when more memory is required.
<dim>
overcommit is useful when applications don't know how to handle malloc() returning NULL (out of memory conditions), which used to be mainly the JVM back in the days
<loke>
dim: Nothing wrong with doing that, but if you do you need even more swap
<dim>
I don't know how SBCL/CCL/ECL/... are dealing with out of memory conditions from the kernel, I would suppose they handle that in a good enough way that you can run them in production with vm.overcommit_memory set to 2
<loke>
In production you _really_ don't want the oom to kick in, and 2 is the correct number (with plenty of swap)
_jrjsmrtn has joined #lisp
<loke>
(note that the swap will mostly not actually be _used_. It just needs to be there to be able to guanratee that even if every singl eprocess touched every single page of memory, there is still going to be neough virtual memory)
<schweers>
Now that I have a test run complete, I can see that the usage went from 1185M after loading the code, but before running, to 2326M after running and a full gc. ROOM on the other hand reports merely 200M for dynamic space. This looks to me that the lisp process simply has not returned this memory back to the OS, but will use it in future allocations.
Kundry_Wag has joined #lisp
<no-defun-allowed>
Exactly.
<p_l>
dim: JVM knew quite well how to handle malloc() returning NULL because the system it was written for didn't do overcommit
<p_l>
Linux is the outlier with overcommit, and most stupid C code that fails without overcommit is due to that
<p_l>
also, Linux docs are outright lying in terms of how to handle "allocate just virtual space" so I believe some lisp implementations get it slightly wrong
<loke>
p_l: especially since Java was first written for SOlaris which has sane memory management.
<p_l>
loke: that's the system it was written for in my sentence ;)
<schweers>
will malloc ever return NULL on linux?
<p_l>
schweers: not with glibc
<loke>
schweers: Yes.
<p_l>
loke: did you manage to get it?
<schweers>
how does this depend on which libc one uses?
<loke>
Or rather, it can, but usually won't.
<loke>
schweers: Yes.
<p_l>
schweers: malloc() is a libc function, not OS interface
<p_l>
to make things worse, glibc malloc will actually use sbrk() for small allocations
<schweers>
I know that, I’m just wondering what the libc can do to influence whether or not overcommiting is performed.
Kundry_Wag has quit [Ping timeout: 246 seconds]
<loke>
If I remember correctly, glibc calls mmap on /dev/zero when it needs more memory pages. Since Linux happily overcommits, you'll always get more pages. glibc malloc will only return null for malloc() if the underlying mmap() call returns NULL
<p_l>
schweers: it can handle OOM condition or not handle
<loke>
(or rather, returns error)
<p_l>
schweers: and with overcommit, both sbrk() and mmap() will return true always
<loke>
yes, indeed
<schweers>
What else could a libc do to get more memory which can fail even when overcommit is turned on?
varjag has joined #lisp
<White_Flame>
allocate more than the allowed memory space for a process
<schweers>
that won’t invoke OOM?
<schweers>
I mean the OOM-Killer
<White_Flame>
I mean that's a situation that could immediately fail even with overcommit, if that's what you're asking
<p_l>
schweers: malloc() doesn't mean a call to mmap() or sbrk() *has* to happen
keep_learning_M has joined #lisp
<p_l>
malloc() tries to find a space in already allocated memory
<schweers>
but then it won’t return NULL
<p_l>
yes
<p_l>
allocators should use mmap() to manipulate memory pages directly
<p_l>
there are ways to allocate *address space* without comitting memory
<schweers>
For instance by mapping actual files read only or shared.
<p_l>
then you get SIGSEGV (or equivalent) when your code attempts to use memory that can't be delivered
<schweers>
but I guess that’s not your point
<p_l>
having control over address space rather than get buffers from malloc() means you get to do nice things like custom layout for memory
<p_l>
which then makes it easy to use, for example, a simple bump allocator for nursery generation
Kundry_Wag has joined #lisp
nicball has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
longshi has quit [Ping timeout: 258 seconds]
jmercouris has joined #lisp
dddddd has joined #lisp
snits has quit [Ping timeout: 258 seconds]
_jrjsmrtn has quit [Ping timeout: 258 seconds]
pankajgodbole has joined #lisp
* varjag
removes fax number from email signature
m00natic has joined #lisp
schjetne has quit [Remote host closed the connection]
svillemot has quit [Remote host closed the connection]
rumbler31 has quit [Read error: Connection reset by peer]
cyberoctopi has joined #lisp
rumbler31 has joined #lisp
svillemot has joined #lisp
scymtym has joined #lisp
ring has joined #lisp
ring has quit [Client Quit]
nicball has joined #lisp
jmercouris has quit [Remote host closed the connection]
snits has joined #lisp
pierpal has joined #lisp
JohnMS has joined #lisp
JohnMS_WORK has quit [Ping timeout: 250 seconds]
libertyprime has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
heisig has joined #lisp
nicball has quit [Ping timeout: 256 seconds]
pierpal has quit [Ping timeout: 244 seconds]
igemnace has quit [Ping timeout: 250 seconds]
fivo has joined #lisp
igemnace has joined #lisp
<hjudt>
does anyone know of a library that can parse the "cookie:" header line and return a cookie like hunchentoot?
cyberoctopi has quit [Ping timeout: 245 seconds]
<hjudt>
i mean something that parses the Cookie: header when i sent it to the server with e.g. wget or curl...
libertyprime has joined #lisp
<flip214>
hjudt: DRAKMA should have such code
cyberoctopi has joined #lisp
vxe has joined #lisp
<hjudt>
hunchentoot also does simply string-split key=value
<hjudt>
flip214: thanks, i'll look at it
zigpaw has quit [Remote host closed the connection]
<phoe>
hjudt: from the client or the server side?
<phoe>
drakma has an implementation of cookie jars
<phoe>
if you want to do it on the client side
cosimone has joined #lisp
pierpal has joined #lisp
defaultxr has quit [Ping timeout: 258 seconds]
saravia has quit [Remote host closed the connection]
brundleticks has quit [Remote host closed the connection]
schjetne has joined #lisp
brundleticks has joined #lisp
rumbler31 has quit [Remote host closed the connection]
milanj has joined #lisp
galdor has joined #lisp
mathrick has quit [Ping timeout: 250 seconds]
selwyn has joined #lisp
mathrick has joined #lisp
pjb has quit [Read error: Connection reset by peer]
longshi has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
pjb has joined #lisp
<hjudt>
actually i am working on the radiance i-woo interface, and woo doesn't provide any cookies. for now, i've implemented it similar to how hunchentoot does (only treating key=value;... in the appropriate header as sent by wget or curl, but without any attributes). i guess it will be fine for now.
<hjudt>
if i use curl or wget, the appropriate http header is "Cookie:". Not "Set-Cookie". Don't know the difference, but the latter is set by the server iirc.
sz0 has joined #lisp
<no-defun-allowed>
yeah, Cookie is c->s, Set-Cookie is s->c
lavaflow has quit [Read error: Connection reset by peer]
lavaflow has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
<selwyn>
schweers: i have used lparallel a lot over the last year on HPC. i can't remember encountering memory issues
amerlyq has joined #lisp
<schweers>
selwyn: it seems to not be an lparallel issue, but more of general sbcl behaviour. I’m still not entirely sure what to make of it.
<selwyn>
i know little about memory management, but it is apparently rare to return memory to the OS, as claimed by the authors of a GC that does: https://www.ravenbrook.com/project/mps/
<White_Flame>
p_l: and of interest to me and maybe you, my first execution of Ivory instructions, dynamically recompiled to CL: https://pastebin.com/sjAVepSP
<Josh_2>
What are Ivory instructions White_Flame ?
<White_Flame>
Josh_2: It's the CPU from the later revisions of the Symbolics lisp machines
<p_l>
Josh_2: Ivory is the cpu of late models of Symbolics Lisp Machines
<Josh_2>
O right
<p_l>
White_Flame has a project that had went the furthest regarding reimplementing some of that :)
<White_Flame>
well, VLM has gone the furthest. It just takes too much wharrgarbl to run it
makomo has joined #lisp
<p_l>
VLM is technically official Ivory implementation, just like recent ClearPath mainframes
<p_l>
are implementations of Burroughs Large System that happens to use Xeon as bit slice
scymtym has quit [Ping timeout: 252 seconds]
<White_Flame>
as in bit-slice style ALUs?
snits has quit [Ping timeout: 244 seconds]
<p_l>
White_Flame: well, more like VLM ;)
<p_l>
except complete
<White_Flame>
heh
<p_l>
but yeah, x86-64 program doing the work of microcode
snits has joined #lisp
flazh has quit [Ping timeout: 246 seconds]
selwyn has quit [Read error: Connection reset by peer]
<moldybits>
is there some way of treating a vector of vectors so that i can do something to this effect: (aref #(#(a b c)) 0 0) => A
<phoe>
moldybits: nope
<moldybits>
dang :(
flazh has joined #lisp
<moldybits>
i'll just write my vref and (setf vref) tehn
<Bike>
if it can't have variable bindings then it's in cltl2... though support for it is unsurprisingly kind of spotty across implementations
<pfdietz>
The response was in the context of discussing how to do it and include variable bindings/
<pfdietz>
(and flet/labels bindings of function names)
<Bike>
"defsubst defines a function just like defun but also defines a compiler-macro that captures any surrounding non-null lexical environment and inlines the function body in its original lexical environment." wow, what
<Bike>
based on its use in ensure-compiled-body, i think this must work with whole lexical environments. how about that.
<Bike>
ensuring-compiled-body*
piotrbrzezinski has joined #lisp
jmercouris has quit [Ping timeout: 245 seconds]
heisig has quit [Quit: Leaving]
v88m has quit [Quit: Quit]
v88m has joined #lisp
<pfdietz>
Er, I meant I think the latter.
<pfdietz>
(runtime lexenv)
<Bike>
i said "compiler or runtime? like, [runtime] or [compiler]" so confusion is natural
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Inline has joined #lisp
notzmv has quit [Remote host closed the connection]
<Bike>
i've found the idea of a system where you could do (enclose [some function] closure-values...) interesting, and i guess you could use that to implement this, provided you were allowed to deal with the kind of uncompleted function
<phoe>
Bike: you'd need to have three kinds of functions then: functions that aren't closures at all, as in, they don't depend on their lexenv; "open closures" that require an environment but don't have it yet, and "closed closures" that have been supplied a lexical environment
<phoe>
the first and third can be funcalled, the second can't
z3t0 has joined #lisp
<Bike>
Right.
<Bike>
of course for just this compiler thing, the second kind only exists within the system, so it's no big deal
<Bike>
the second kind is kind of implicit in the idea of closures anyway
<Bike>
at least if you take them seriously as objects
<phoe>
yep - just, if you want to make them first-class objects, you'll want to elevate them into actual user-interactable objects
<phoe>
just like lexenvs kind-of-already-are in CL
<phoe>
(even standard CL)
<Bike>
runtime lexenvs aren't
<jackdaniel>
lexenvs are not first class objects and dealing with them is a pita
Arcaelyx has joined #lisp
Arcaelyx has quit [Client Quit]
<beach>
jackdaniel: In what way are they not first class?
Arcaelyx has joined #lisp
<phoe>
jackdaniel: Bike: that's why I said kind-of-already-are
<jackdaniel>
beach: in a sense that I can't take the function lexenv at runtime and inquiry "what is X"
longshi has quit [Ping timeout: 245 seconds]
mindCrime has joined #lisp
<Bike>
compile time lexenvs are first class, depending on what you mean by "first class", i guess
<phoe>
they usually only exist at macroexpansion- and compile-time, they are of dynamic extent, and pretty damn hard to reach and interact with
<jackdaniel>
right, you may pass them around in a semi-opaque manner
dale_ has joined #lisp
<phoe>
but they fulfill the notion of first-classness because they can be returned as values, taken as arguments, and operated upon via cltl2 functionality
dale_ is now known as dale
<Bike>
letting code deal with runtime lexenvs arbitrarily puts you in perl world and makes compilation impossible, so i'm okay with that not happening
<phoe>
so they are first-class, they're just elusive as hell
<jackdaniel>
cltl2 is not ansi common lisp
<phoe>
jackdaniel: that's another reason why I said kind-of-already-are; cltl2 isn't ansi cl, but implementations provide that functionality anyway, so we may as well live with it
<Bike>
sort of provide
<phoe>
(and with the introspect-environment system)
<jackdaniel>
sure, I'm not saying it is not rational, just suggesting that when you need to interact with them at runtime it is problematic
<phoe>
jackdaniel: yes, it *is* problematic - these object aren't meant to be interacted with at runtime, unless you enjoy poking your fingers into compiler stack frames
<jackdaniel>
phoe: many kind of here, you may rethink that phrasing
<pjb>
pfdietz: CL:COMPILE must use the NIL environment; does allegro provide an extension?
fanta1 has joined #lisp
<phoe>
jackdaniel: sure - it's possible that I'm just ignorant about the topic, my phrasing is based on what I've seen so far
<Bike>
allegro has an extension but it doesn't look like it's external
<jackdaniel>
phoe: I think that only cmu, sbcl and ccl (from free implementations) have cltl2 interface implemented
jmercouris has joined #lisp
<jackdaniel>
(and last time I've tested it they had some problems with declarations, I have it noted somewhere to report when I'm done with cltl2 interface implementation for ecl - postponed for after 16.2.0)
<jackdaniel>
querying declarations*
cosimone has joined #lisp
cosimone has quit [Client Quit]
<pjb>
Bike: Thanks.
cosimone has joined #lisp
<pfdietz>
I don't see how runtime lexenvs rule out compilation.
<Bike>
i mean, if you can access them arbitrarily
<Bike>
being able to build them or get them in the interpreter is fine
<jackdaniel>
it is also a question of expectations. i.e you may optimize out some variables and have a very suprised programmer that lexenv doesn't have x
<pfdietz>
It just means keeping track of how you stored lexical variables (and their names), so you can hook new code into that. There's not even a performance penalty if the runtime lexenv is never manifested in the code.
<easye>
Anybody hook drakma/dexador as the basis for a HTTPS proxy yet?
<pfdietz>
If I am understanding it properly, the CLtL2 lexenv interface does miss one thing I'd want: getting a list of all the lexical variables visible in the lexenv (and lexical functions).
<jackdaniel>
I've got interrupted at some point with it, but it revealed some issues in cltl2
<jackdaniel>
s/cltl2/sb-cltl2/
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
makomo has quit [Quit: WeeChat 2.2]
cosimone has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
nanoz has joined #lisp
v88m has quit [Quit: Quit]
v88m has joined #lisp
rippa has joined #lisp
MShuttleworth has joined #lisp
jmercouris has quit [Ping timeout: 246 seconds]
<selwyn>
moldybits: the library array-operations at https://github.com/bendudson/array-operations has some nice methods to combine and split arrays of arrays which may give the behaviour you would like
<selwyn>
(aref (aops:combine #(#(a b c))) 0 0) => A
PretendMatter has joined #lisp
MShuttleworth has quit [Max SendQ exceeded]
<cosimone>
join #xmonad
MShuttleworth has joined #lisp
<cosimone>
whoops sorry
varjag has joined #lisp
cross has quit [Remote host closed the connection]
gbiesiad has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jmercouris has joined #lisp
MShuttleworth has quit [Killed (Fuchs (<No reason given>))]
Josh_2 has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
jmercouris has quit [Ping timeout: 245 seconds]
ricekrispie2 has joined #lisp
piotrbrzezinski has quit [Remote host closed the connection]
<pjb>
all in closer-mop and pcostanza-closer-mop (so, duplicated).
<pjb>
And also, in implementation specific files.
<pjb>
drmeister: so I would say, not often. It's used with call-next-method in the closure in compute-discriminating-function.
sauvin has quit [Ping timeout: 276 seconds]
<pjb>
and in reinitialize-instance of standard-generic-function.
<pjb>
so quite rare…
izh_ has joined #lisp
aindilis has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<drmeister>
Ok - thank you very much.
jmercouris has quit [Ping timeout: 276 seconds]
jmercouris has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
Snardbafulater2 has joined #lisp
Snardbafulater2 is now known as Snardbafulater
Zaab1t has quit [Remote host closed the connection]
Snardbafulater has quit [K-Lined]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
gbiesiad has joined #lisp
sjl has quit [Ping timeout: 245 seconds]
whartung has quit [Read error: Connection reset by peer]
whartung has joined #lisp
v88m has quit [Ping timeout: 246 seconds]
gbiesiad has quit [Quit: gbiesiad]
<moldybits>
jdz: i'm representing a 2d dungeon. i want to be able to pick out rows, as well as rectangle slices easily. it's probably just as easy with arrays, but i lack experience with them
<moldybits>
i've had a miserable time getting started, but this is good practice. next jam i'll be more prepared :)
<oni-on-ion>
mfiano, thats pretty
milanj has quit [Quit: This computer has gone to sleep]
<mfiano>
That's the idea, and why it's encouraged to submit something even if you don't finish. It sets the bar for next year, and allows others to use it as a base to build upon
<mfiano>
dark gray = solid, light gray = corridors, blue = rooms, pink = doorways, and you can just ignore the orange circles
<mfiano>
and you can tweak it pretty well, such as controlling how windy the corridors between rooms are, and the number of cycles added to the MST
<oni-on-ion>
orange dots = 'between' two areas ?
<oni-on-ion>
well between light blue and gray or blue and blue
<mfiano>
The orange dots don't mean much after the dungeon is built. They define the graph for when the MST is computed. Basically, an orange dot represents where a doorway could have been.
<moldybits>
is there an obvious way to simulate an infinitely sized array (for the purpose of not having to worry about bounds-checking, and defaulting to some value)
<mfiano>
There are some constraints, such as a connector (orange dot) can't be next to a door (pink), and they must be orthogonally and never diagonally adjacent to grey or blue
decent-username has joined #lisp
<decent-username>
O . o' wow, this room is packed.
sz0 has quit [Quit: Connection closed for inactivity]
<fe[nl]ix>
decent-username: loosely speaking...
vlatkoB has quit [Remote host closed the connection]
<mfiano>
moldybits: either use a vector with vector-push-extend, or if you require a multiple dimension array, you'll have to do the work with adjust-array manually
vlatkoB has joined #lisp
<moldybits>
hm. okay, i'll look into that if there's time. for now i'll just make the dungeon extra large :)
<aeth>
Depends on what you mean by infinte. You have to be fancier if you're infinite in *both* directions. Probably by having two actual adjustable arrays, one starting at 0 and the other starting at -1 and then convert the minusp indices to (abs (1+ i)) on the second array
rumbler31 has joined #lisp
<aeth>
For people who use both structs and standard objects (some people never touch structs), holding thinly wrapped array data structures is a good use for structs imo.
<sjl>
may-or-may-not-be-serious answer: use a hash table
<aeth>
hash table is if it's sparse
<aeth>
like 1 385978 3284798235798 and 1357498317498374189 as the indices
SenasOzys has quit [Remote host closed the connection]
sakpaone has joined #lisp
SenasOzys has joined #lisp
sakpaone has quit [Max SendQ exceeded]
sakpaone has joined #lisp
<aeth>
sjl: An "array" with complex integer indices? I wonder if there's a use.
travv0 has joined #lisp
<sjl>
... a map. A 2d map. Like for a roguelike.
<aeth>
oh "map" as in cartography not as in "hash map"
<sjl>
Yeah.
vlatkoB has quit [Remote host closed the connection]
<Bike>
i guess if you use a map as a hash map it's geocaching
sakpaone has quit [K-Lined]
lumm has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
<sjl>
I've used complexes instead of 2-element vectors for representing 2d coords in games/art/etc before. You get arithmetic functions, eql-ity, reader syntax, etc all for free.
milanj has joined #lisp
ebrasca has quit [Remote host closed the connection]
Lord_of_Life_ has joined #lisp
igemnace has joined #lisp
karlosz has quit [Quit: karlosz]
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life_ is now known as Lord_of_Life
lumm has quit [Quit: lumm]
lumm_ has joined #lisp
lumm has joined #lisp
lumm has quit [Ping timeout: 258 seconds]
lumm_ is now known as lumm
nanoz has quit [Ping timeout: 246 seconds]
gxt has joined #lisp
<jasom>
fun fact, 2 64 bit integers are sufficient to represent any position on the surface of the earth to a precision of 1pm
lavaflow has quit [Ping timeout: 258 seconds]
gbiesiad has joined #lisp
<jasom>
well if you model the earth as an oblate spheroid anyways
SenasOzys has quit [Remote host closed the connection]
kajo has joined #lisp
<Xach>
which two??
SenasOzys has joined #lisp
<Xach>
sorry.
miatomi has quit [Ping timeout: 244 seconds]
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
lumm has quit [Client Quit]
lumm has joined #lisp
pfdietz has quit [Ping timeout: 256 seconds]
wigust- has joined #lisp
refpga has quit [Remote host closed the connection]
lumm_ has joined #lisp
miatomi has joined #lisp
wigust has quit [Ping timeout: 245 seconds]
karlosz has joined #lisp
cross has joined #lisp
lumm has quit [Ping timeout: 246 seconds]
lumm_ is now known as lumm
karlosz has quit [Quit: karlosz]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
karlosz has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
longshi has quit [Ping timeout: 258 seconds]
miatomi has quit [Ping timeout: 246 seconds]
<aeth>
There are all sorts of fun things you can do with location, like combining a (signed-byte 32) with a single-float
<aeth>
That's an alternative to double-float for space-scaled things
<phoe>
aeth: you're describing a floating point format with a really damn long mantissa
<Bike>
and a redundant sign, yeah?
karlosz has quit [Quit: karlosz]
<White_Flame>
define a spiral that slowly wraps around the earth, and have a 1d location it
fiveop has quit []
defaultxr has joined #lisp
<phoe>
Bike: I can't wait to combine -1000000 with +1e6
miatomi has joined #lisp
pankajgodbole has quit [Ping timeout: 258 seconds]
longshi has joined #lisp
longshi has quit [Client Quit]
scymtym has joined #lisp
selwyn has joined #lisp
<p_l>
White_Flame: space-filling curves are often used
libertyprime has joined #lisp
SenasOzys has quit [Ping timeout: 246 seconds]
john2x has joined #lisp
mindCrime has quit [Ping timeout: 246 seconds]
fivo has quit [Quit: WeeChat 1.9.1]
Bike has quit []
lavaflow has joined #lisp
mindCrime has joined #lisp
Aruseus has joined #lisp
mindCrime has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
PretendMatter has quit [Remote host closed the connection]
gbiesiad has quit [Quit: gbiesiad]
cosimone has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
john2x has quit [Ping timeout: 276 seconds]
ltriant has joined #lisp
gbiesiad has joined #lisp
<katco>
has anyone worked with github.com/bendudson/py4cl much?
<no-defun-allowed>
is it backwards cl4py?
<katco>
i haven't used cl4py, but i think so, yes.
<no-defun-allowed>
right
<no-defun-allowed>
i used burgled-batteries once
<katco>
it claims to convert CL types to python types, but this works: `(py4cl:python-eval "foo")` and this doesn't `(let ((s "foo")) (py4cl:python-eval s))`
john2x has joined #lisp
<grewal>
Why do you want python's type system?
<Josh_2>
Some people are masochists
<katco>
i don't, i want to call py things from CL
<katco>
well that's a rather dismissive statement
<Josh_2>
xD
<Josh_2>
It was a joke
<grewal>
Josh_2: One nice feature of python's type system is that there isn't a character type. They just have strings of length 1. It frequently simplifies things
<Josh_2>
absolute savage
<grewal>
But I rarely worry about types, so don't go by me
[rg] has joined #lisp
<[rg]>
howdy, any books that give a cursory overview? the little schemer is cute but I could go faster without the repetition
<Josh_2>
Lil schemer is a book for Scheme
<Josh_2>
this is the Common Lisp IRC channel :P
<Josh_2>
good book tho
<decent-username>
[rg]: SICP
<[rg]>
oh, is there a general lisp channel?
<[rg]>
[rg], too long?
<[rg]>
like does lisp have anything like a tour of c++?
<Josh_2>
Lisp is a family of languages
<Josh_2>
an umbrella term that covers many different languages
<grewal>
[rg]: ##lisp. But if you're just interested in scheme, try #scheme
<Josh_2>
U should be interested in CL tho, It's better :P
<[rg]>
im interested in #picolisp but they dont have a book or anything
<Josh_2>
I used picolisp for a college project once, was fun
<no-defun-allowed>
minion: tell [rg] about Practical Common Lisp
<minion>
[rg]: direct your attention towards Practical Common Lisp: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<Josh_2>
if SICL is too long that'll be too long
<no-defun-allowed>
yeah well you won't learn anything from studying SICL Josh_2
<Josh_2>
Yes I won't
<Josh_2>
can barely count to 7 like
<no-defun-allowed>
but it gets into full applications quicker than SICP which is useful for beginners to keep attention
<[rg]>
not interested in full applications right now
random-nick has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
and the curve of the book is not as steep, SICP brings you up to creating a compiler for a register machine, PCL does not
<Pixel_Outlaw>
grewal: I just wanted to make sure that some form of scoping was provided. Some of the languages of the era just used a big bunch of global variables.
<Pixel_Outlaw>
grewel: I may or may not be in a small debate with a COBOLista on scoping and history.
<moldybits>
[rg]: note that arc has some idiosyncracies. but i guess they all do
<grewal>
I remember reading that all variables were dynamic. Lexical variables came with scheme.
<no-defun-allowed>
what the hell, arc uses = for setf
<_death>
grewal: lexical scoping _by default_ came with scheme..
svillemot has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
decent-username has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]