yaji has quit [Read error: Connection reset by peer]
yaji has joined #lisp
yaji has quit [Remote host closed the connection]
yaji has joined #lisp
yaji has quit [Read error: Connection reset by peer]
yaji has joined #lisp
yaji has quit []
EvW1 has quit [Ping timeout: 244 seconds]
heisig has quit [Ping timeout: 240 seconds]
mankaev_ has joined #lisp
mankaev has quit [Read error: Connection reset by peer]
Lycurgus has joined #lisp
asdf_asdf_asdf has quit [Quit: Connection closed]
asdf_asdf_asdf has joined #lisp
gko_ has quit [Ping timeout: 240 seconds]
kaftejiman_ has joined #lisp
kaftejiman has quit [Read error: Connection reset by peer]
igemnace has quit [Remote host closed the connection]
asarch has joined #lisp
<asarch>
I have 1, 3, 5, 6, 9 in the first vector and 3, 9 in the second. Is there an easy way to get 1, 5, 6 (those elements available only in the first vector but not in the second one)?
<Demosthenex>
so, my fav password manager is a console utility in C++. i'm considering reimplementing in in CL (ECL for tiny binary). one of the interesting things it does is uses "secured" memory allocation while it is working. i think it may just pin it's memory so it can't be swapped to disk unencrypted. is there a way to pin memory in CL? if you were going to load sensitive data, any recommendations on how to
<Demosthenex>
secure it briefly in ram and clear it correctly on exit?
<phoe>
what does it mean by "secured" memory allocation
<phoe>
likely this boils down to issuing some syscalls on some memory region
asdf_asdf_asdf has quit [Ping timeout: 264 seconds]
asdf_asdf_asdf has joined #lisp
<asdf_asdf_asdf>
(let ((a (list 1 2 3 4))
<asdf_asdf_asdf>
(b (list 1 2)))
<asdf_asdf_asdf>
(loop for i in a
<asdf_asdf_asdf>
for j in b
<asdf_asdf_asdf>
collect i))
<phoe>
asdf_asdf_asdf: please use a paste service for anything longer than a line or two
remexre has joined #lisp
<asdf_asdf_asdf>
phoe, OK; Why You banned me on #lisp-pl?
<asdf_asdf_asdf>
#lisp-pl *
<asdf_asdf_asdf>
I am the best passioner on Lisp lang.
<remexre>
it's definitely well-defined to sort a vector for the side effects, right? CCL's giving me a warning about it, but sbcl's fine, and the code seems to work...
<beach>
asdf_asdf_asdf: No doubt because you completely refuse to comply with channel rules.
Lord_of_Life_ has joined #lisp
<remexre>
(work on sbcl, that is; having unrelated issues with my tests and ccl)
<remexre>
yeah, it says destructively, but ccl still warns
<asdf_asdf_asdf>
beach, him banned me on #lisp-pl, not on #lisp-en !
<asdf_asdf_asdf>
phoe, unban me, now. Thank.
<phoe>
remexre: the notes say, " If sequence is a vector, the result might or might not be simple, and might or might not be identical to sequence. "
<beach>
remexre: Destructive means that there *might* be mutations.
<phoe>
in general this means that the proper means of using SORT is to utilize its return value
<remexre>
beach: oh, I misunderstood that :|
<remexre>
phoe: oh, hm, ok
<asdf_asdf_asdf>
Channel #lisp-pl is madness for every human exist creature.
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<phoe>
can't unban you there, I don't even have operator rights on #lisp-pl
<beach>
asdf_asdf_asdf: If you continue like this, you will likely be banned here as well.
<asdf_asdf_asdf>
beach, so what I can put here on this chat?
<asdf_asdf_asdf>
beach, remember every time; I never give up! Never!!!
<beach>
You have been told several times what you are not supposed to do. Check the logs.
<asdf_asdf_asdf>
beach, You check, because I play on chess and I don't know, whether You too.
<asdf_asdf_asdf>
Also.
<phoe>
sorry about that
asdf_asdf_asdf was banned on #lisp by phoe [*!*2e4c5f73@*.com/ip.46.76.95.115]
asdf_asdf_asdf was kicked from #lisp by phoe [(trivial-garbage:gc :full t)]
<phoe>
remexre: there's several destructive functions like that whose results must not be discarded, *even* if are passed vectors and not lists
<phoe>
SORT, DELETE and its variants, I guess there were a few more
<phoe>
but basically - it's a Lisp idiom to always keep the return value of these functions
<remexre>
okay
<remexre>
I suppose that makes sense, wrt implementor freedom
<phoe>
in particular - even though no one really does that - DELETE is allowed to just call REMOVE
rilez has quit [Ping timeout: 245 seconds]
caltelt has joined #lisp
Lycurgus has quit [Remote host closed the connection]
bitmapper has joined #lisp
kaftejiman_ has quit [Remote host closed the connection]
zaquest has quit [Ping timeout: 240 seconds]
<Demosthenex>
phoe: well, i'm rusty on C, and dont know c level memory security, that's also why i linked the code. i think it was just memory pinning to prevent it being written out to swap.
<phoe>
C has no concept of memory security itself, that's why I suspect it's basically just invoking some OS-level functionality via syscalls
<phoe>
and if that is the case, then Lisp can do it, too.
zaquest has joined #lisp
<asarch>
Thank you beach! Thank you very much! :-)
mindCrime has joined #lisp
<Demosthenex>
phoe: yep. interesting
orivej has joined #lisp
gravicappa has joined #lisp
Lycurgus has joined #lisp
Lycurgus has quit [Remote host closed the connection]
Jeanne-Kamikaze has joined #lisp
cosimone has joined #lisp
stepnem has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
Grauwolf has joined #lisp
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
Josh_2 has joined #lisp
<Josh_2>
Evening
stoneglass has quit [Quit: stoneglass]
yitzi has quit [Quit: yitzi]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
EvW has joined #lisp
ayuce has quit [Remote host closed the connection]
gaqwas has quit [Remote host closed the connection]
dmr0x80 has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
dominic34 has joined #lisp
dominic34 has quit [Excess Flood]
dominic34 has joined #lisp
dmr0x80 has quit [Ping timeout: 246 seconds]
dddddd has quit [Ping timeout: 240 seconds]
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
CrazyEddy has joined #lisp
yitzi has joined #lisp
<sveit>
is there a reason SBCL does not elide constructors? I mean that one might hope that (defun f (x) (car (cons x 3))) avoids allocating the cons.
dominic34 has quit [Ping timeout: 264 seconds]
dddddd has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
kaftejiman has joined #lisp
<White_Flame>
SBCL doesn't have a lot of specifically applicable optimizations. But it does focus on the biggies
<White_Flame>
it doesn't have a peephole optimizer either, which really bugs me when reading disassemblies
<sveit>
what do you mean by "specifically applicable"? i guess this would be a general thing. maybe you mean it could have been implemented by compiler macros?
<sveit>
but i think eliding constructors (say for structs) is a generally useful optimization, not just for built-in datatypes
<aeth>
White_Flame: #3 "algebraic laws" is a lot less useful than you think
<aeth>
e.g. Floating point doesn't follow this.
<aeth>
sveit: I'm more surprised it can't handle the equivalent (defun f (x) (car `(,x . 3))) since I know SBCL does optimize e.g. (defun f () (car '(42 . 3)))
alandipert has quit [Ping timeout: 260 seconds]
alandipert has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
Oberon has joined #lisp
yitzi has quit [Read error: Connection reset by peer]
shifty has joined #lisp
CrazyEddy has joined #lisp
gaqwas has quit [Remote host closed the connection]
drot has quit [Read error: Connection reset by peer]
shinohai has quit [Read error: Connection reset by peer]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
orivej has quit [Ping timeout: 256 seconds]
yitzi has joined #lisp
<phoe>
aeth: that's because '(42 . 3) is a literal
<phoe>
(cons 42 3) allocates a new cons each time
EvW1 has joined #lisp
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
<Oberon>
Are there any cloud-type platforms for Lisp? It occurs to me that the language may be uniquely suited to the model.
<Oberon>
It also occurs to me that I could google "lisp cloud" and get my answer there. Excuse me while I clean this egg off of my face.
EvW1 has quit [Ping timeout: 244 seconds]
<phoe>
Oberon: what exactly do you mean by cloud-type platform?
orivej has quit [Ping timeout: 264 seconds]
gaqwas has quit [Remote host closed the connection]
<phoe>
also, what do you mean by being uniquely suited
shinohai has joined #lisp
<phoe>
if you mean something like AWS Lambda, then I guess the runtime advantages provided by Lisp's image-based programming are mostly lost, since you cannot easily debug or inspect recompile your code anymore because it runs Somewhere™ and usually bills you per hour
<phoe>
also each request might happen to execute in a different Lisp image, which also means that you don't have the program state in a single place
shinohai has quit [Remote host closed the connection]
shinohai has joined #lisp
orivej has joined #lisp
asarch has quit [Ping timeout: 272 seconds]
cosimone has joined #lisp
<Oberon>
The program state would be a problem, but the model where you have bits of code that you can run on demand, and that can scale up quickly without provisioning a new machine
<phoe>
sure, you can do that same way you can run all other languages
orivej has quit [Ping timeout: 265 seconds]
<bitmapper>
aws lambda but they actually run lambdas
bitmapper has quit [Remote host closed the connection]
bitmapper has joined #lisp
<White_Flame>
well, one of the advantages that amazon benefits from with lambda is that they keep your python/node/whatever instance running between executions, if you use them frequently, to save on startup times
<White_Flame>
but again, none of that really is language specific
<White_Flame>
just magic routing to reuse the same instance if one's still open
mrcom has quit [Read error: Connection reset by peer]
gaqwas has joined #lisp
mangoicedtea has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
gaqwas has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
Josh_2` has joined #lisp
Josh_2 has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
Josh_2` has quit [Remote host closed the connection]
v3ga has quit [Ping timeout: 244 seconds]
vutral has joined #lisp
Oberon has quit [Ping timeout: 240 seconds]
Christ0pher has joined #lisp
Oberon has joined #lisp
Oberon has quit [Ping timeout: 265 seconds]
Oberon has joined #lisp
DGASAU` has joined #lisp
Oladon has quit [Quit: Leaving.]
madage has quit [Quit: leaving]
Oberon has quit [Ping timeout: 256 seconds]
DGASAU has quit [Ping timeout: 256 seconds]
Oberon has joined #lisp
stepnem has quit [Ping timeout: 256 seconds]
hendursa1 has joined #lisp
stepnem has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
Oberon has quit [Ping timeout: 240 seconds]
madage has joined #lisp
Oberon has joined #lisp
v3ga has joined #lisp
Oberon has quit [Ping timeout: 256 seconds]
cosimone has quit [Ping timeout: 244 seconds]
Oberon has joined #lisp
<ralt>
A lisp cloud might be related to CRIU and never dying processes...
<ralt>
I've never tried CRIU on an sbcl process, speaking lf
<ralt>
of*
<ralt>
I wonder if that works well
<ralt>
if at all
Oberon has quit [Ping timeout: 264 seconds]
<ralt>
I don't think it's doing anything special that wouldn't make it work
<aeth>
I wonder if you can get a Lisp image running 'in the cloud' in the sense that it runs on mulitple machines simultaneously, sharing the heap. I mean, probably yes, but it's probably also way too hard over just running a dozen Lisp images simultaneously.