lucasb has quit [Quit: Connection closed for inactivity]
rumbler31 has joined #lisp
tiwEllien has quit [Ping timeout: 258 seconds]
karlosz has joined #lisp
krisfris1 has joined #lisp
igemnace has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
igemnace has quit [Ping timeout: 258 seconds]
adolby has joined #lisp
<asarch>
If I have: (defparameter *values* '('(lisp rocks) '(clos rocks even better) '(mcclim is also awesome))) and then I do: (loop for lists in *values* do (loop for element in lists do (format t "Parsing element: ~a~%" element))), how could I get each element?
<Bike>
just do that but lose the inner quotes
<Bike>
you don't need them
<asarch>
Thank you!
<aeth>
You can think of ' as like multiplication. 2*(4+3)=2*4+2*3. '((foo) (bar)) = (list '(foo) '(bar))
<aeth>
Not perfectly equivalent, though close enough in most cases
<aeth>
A quoted list is literal so there are edge cases that make it not perfectly equivalent
<White_Flame>
asarch: if you (setf *print-pretty* nil), then you'll see the full lists with QUOTE symbols in them when you show *VALUES* at the repl, and you can see how they're in the way
<pjb>
asarch: think of 'x as (CL:QUOTE x).
<pjb>
'('(lisp rocks)) = '((cl:quote (lisp rocks))) and ask yourself why 1- you put (lisp rocks) in a sublist, 2- you put the symbol CL:QUOTE as first element of that sublist.
<smokeink>
(ql:quickload :com.informatimago) ; System "com.informatimago" not found. Not on quicklisp any more?
<aeth>
To use the distributive property analogy: '('(foo)) is (list ''(foo)) which of course is just (list (quote (quote (list foo))))
<aeth>
If you have to work with quote in quote, be aware of that extra quote, but it's rarely what you want
<Xach>
smokeink: the author posted many vile racist and neo-nazi things on twitter and i do not wish to work with them in quicklisp or anything else.
<pjb>
smokeink: not at all.
<smokeink>
oh
<pjb>
It was Xach's interpretation.
<pjb>
Note how he benefits from free-speech protection by his constitution, but he acts in a completely totalitarian way against others…
<smokeink>
yeah but if it was nazi stuff and he doesn't want to associate in any way, it's his freedom too
<no-defun-allowed>
There is also a...was it draw-cons-tree system on Quicklisp which achieves roughly the same thing.
<no-defun-allowed>
e.g. (draw-cons-tree:draw-tree '(defun f (g) (funcall g 42)))
<smokeink>
pjb: I have neo-nazi friends, I respect their vision , which in part is insightful, but as far as I'm concerned, it's only in part
<Bike>
the author in question is pjb, if that wasn't clear
<asarch>
Thank you guys, thank you very much! :-)
<holycow>
waith, so why is that package banned for ql?
_jrjsmrtn has quit [Ping timeout: 268 seconds]
ebrasca has joined #lisp
<Bike>
i thought xach's explanation was pretty clear, holycow
<holycow>
oh, i missed that, sorry was swapping windows
__jrjsmrtn__ has joined #lisp
<holycow>
yeah that is pure garbage
<holycow>
sorry dude
<holycow>
Xach: if you are monitoring peoples personal postings online you are no longer worty of support
<Xach>
holycow: Ok.
<Bike>
you're walking into this like a year or two late, i think
bilegeek has joined #lisp
<Xach>
holycow: I don't generally seek out things like that, but if I am aware of them and do nothing, I find it intolerable.
<holycow>
well, if we are going to go down that rabbit hole, balkanization it is.
<holycow>
i will make a donation for the work you have done thus far, i find it helpful, but i will no longer be using ql on principle
<holycow>
or any piece of software that you touch
<holycow>
that is a despicable position to take
<holycow>
though i will fully admit the following:
<Xach>
Ok. You don't have to make a donation if you don't feel like it, either.
<holycow>
* i have not donated to you and should out of principle for the work you have done thus far
<no-defun-allowed>
holycow: The paradox of tolerance is an odd one; but not really a topic for #lisp. #lispcafe is usually at its greatest throughput when arguing such philosophical things.
<holycow>
* i admit that my position is hypocritical because my line in the sand is somewhere along the lines of sexual abuse and i would make a similar call then
<Bike>
is this necessary
<no-defun-allowed>
Yeah, I think we should just leave it here.
<holycow>
my apologies, i will drop it.
holycow has left #lisp [#lisp]
<LdBeth>
Does the terminal emulator in CLiki’s suggested projects require to be a VT100 compatible one?
<pjb>
LdBeth: not necessarily.
<karlosz>
i think with suggested projects you should take them in whatever direction you see fit
Kundry_Wag has joined #lisp
<pjb>
LdBeth: you can define your own control codes, but write down a termcap/terminfo entry for your terminal!
<pjb>
You could implement ECMA-048…
<LdBeth>
I mean a 3207 with vector graphic extension ;)
<pjb>
Of course.
jebes has joined #lisp
jebes has quit [Client Quit]
jebes has joined #lisp
jebes has quit [Client Quit]
jebes has joined #lisp
Oladon has joined #lisp
ebrasca has quit [Remote host closed the connection]
akoana has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
notzmv has quit [Remote host closed the connection]
krisfris1 has quit [Ping timeout: 265 seconds]
notzmv has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
dddddd has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 260 seconds]
Lord_of_Life has joined #lisp
Kundry_Wag has quit []
rwcom6 has joined #lisp
rwcom has quit [Ping timeout: 245 seconds]
rwcom6 is now known as rwcom
ahungry has joined #lisp
william1_ has joined #lisp
william1_ has quit [Ping timeout: 268 seconds]
ahungry has quit [Remote host closed the connection]
brettgilio has joined #lisp
dmc00 has joined #lisp
ahungry has joined #lisp
brettgilio has quit [Read error: Connection reset by peer]
brettgilio has joined #lisp
smokeink has quit [Ping timeout: 258 seconds]
<beach>
Good morning everyone!
<LdBeth>
Hello beach
<ahungry>
hi
Bike has quit [Quit: Lost terminal]
gnufr33d0m has joined #lisp
asarch has quit [Quit: Leaving]
adam4567 has joined #lisp
Oladon has quit [Quit: Leaving.]
smokeink has joined #lisp
<HiRE>
man I wish there were more lisp job listings :(
<HiRE>
I'd like to see what big scale lisp looks like in the wild
gnufr33d0m has quit [Quit: gnufr33d0m]
<HiRE>
just got through the macro section of PCL. Macros writing macros...lol
slac-in-the-box has joined #lisp
<beach>
HiRE: If you take a job in the right place, or work for the right customer, your employer or customer might not care whether you use Common Lisp or something else.
<HiRE>
beach: thats true. Similar to the one artcle...cant remember its name where a guy sells common lisp to JPL
<HiRE>
the trick is sales :p
slac-in-the-box has quit [Client Quit]
<beach>
Also, consider getting a job at a place that does NOT use Common Lisp, but that has no good reason not to use it. Then you can show them that you can do better with Common Lisp than with what they are currently using.
<beach>
That's even better than to work for a company that is already convinced about the virtues of Common Lisp.
<HiRE>
thats a good idea
<HiRE>
maybe I could try to find a way to introduce CL at work once im better at it
<beach>
Yes, that's a good idea, but you need to be careful with that.
<beach>
Trying to talk people into it is not going to work (usually).
<copec>
I do systems admin and devops and my job is 100% remote, I've managed to slip in quite a bit of CL scripting
<beach>
The only thing I have found to work is to show that you can create a lot of high-quality stuff in a short period of time.
<beach>
copec: Excellent!
gravicappa has joined #lisp
* no-defun-allowed
would be lucky to find any programming job
<copec>
Have you had one previously no-defun-allowed?
<no-defun-allowed>
Nope.
<copec>
You seem totally qualified for a lot of arbitrary listings I have seen, here in the states
<beach>
copec: I think we should let no-defun-allowed finish university first.
<copec>
Ah, certainly
<beach>
At least that's what I strongly recommend.
<beach>
A degree, while not strictly necessary to get the job done, is a kind of international unemployment insurance.
<no-defun-allowed>
On the contrary, I am trying to find a part-time job so I can pay for university, but I could still wait since it'll just come out of my taxes after university.
<HiRE>
I'm currently in a PhD program. I just couldn't get enough of paying absurd university prices ;D
<HiRE>
its actually not too bad ~$1,100 a class atm
<HiRE>
it'll probably get worse.
<HiRE>
doing it part time and working full time definitely makes it tolerable despite it taking ages to finish
oxum has quit [Remote host closed the connection]
smokeink has quit [Quit: Leaving]
torbo has quit [Remote host closed the connection]
narimiran has joined #lisp
<no-defun-allowed>
Anyways, this is probably the reverse of what is usually asked here, but has anyone attempted to implement something like the JVM in Common Lisp?
milanj has quit [Quit: This computer has gone to sleep]
shka_ has joined #lisp
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
oxum has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
oxum_ has joined #lisp
<beach>
I strongly recommend you move to a country where the university enrollment fees are low.
<Xach>
no-defun-allowed: yes
karlosz has quit [Quit: karlosz]
<Xach>
no-defun-allowed: a JVM was implemented in Common Lisp
karlosz has joined #lisp
<Xach>
no-defun-allowed: not just "something like" but the real thing, able to load and run java code.
gioyik has quit [Quit: WeeChat 2.7]
<no-defun-allowed>
I see.
oxum_ has quit [Remote host closed the connection]
oxum_ has joined #lisp
oxum has quit [Read error: Connection reset by peer]
oxum has joined #lisp
<no-defun-allowed>
Is that available to read anywhere?
<Xach>
it is pretty old now but it is an interesting hack still
<no-defun-allowed>
Cooleo.
<no-defun-allowed>
Thanks.
oxum_ has quit [Ping timeout: 260 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
<no-defun-allowed>
It's bitrotted to the point I can't compile it sadly, but most of the code is there.
shka_ has quit [Ping timeout: 240 seconds]
oni-on-ion has quit [Ping timeout: 268 seconds]
bilegeek has quit [Quit: Leaving]
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
shka_ has joined #lisp
trittweiler has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
vlatkoB has joined #lisp
decent-username has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
grabarz has joined #lisp
jfb4_ has quit [Ping timeout: 265 seconds]
grabarz has quit [Client Quit]
ggole has joined #lisp
akoana has left #lisp ["Leaving"]
jfb4 has joined #lisp
DGASAU has joined #lisp
toorevitimirp has joined #lisp
brown121407 has quit [Ping timeout: 260 seconds]
ahungry has quit [Remote host closed the connection]
jfb4_ has joined #lisp
brown121407 has joined #lisp
jfb4 has quit [Ping timeout: 260 seconds]
oxum_ has joined #lisp
oxum_ has quit [Remote host closed the connection]
oxum has quit [Read error: Connection reset by peer]
oxum_ has joined #lisp
ym has quit [Quit: Leaving]
oxum_ has quit [Ping timeout: 258 seconds]
Qudit314159 has joined #lisp
frgo_ has quit [Remote host closed the connection]
varjag has joined #lisp
jprajzne has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
Qudit314159 has quit [Remote host closed the connection]
flamebeard has joined #lisp
toorevitimirp has quit [Quit: Konversation terminated!]
toorevitimirp has joined #lisp
frgo has joined #lisp
easye`` has quit [Quit: ERC (IRC client for Emacs 26.3)]
frgo_ has joined #lisp
frgo_ has quit [Read error: Connection reset by peer]
frgo has quit [Ping timeout: 268 seconds]
easye has joined #lisp
frgo_ has joined #lisp
hvxgr has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
scymtym has joined #lisp
adam4567 has quit [Remote host closed the connection]
adam4567 has joined #lisp
HiRE has quit [Quit: Later]
HiRE has joined #lisp
frgo_ has quit [Ping timeout: 268 seconds]
hvxgr has joined #lisp
smokeink has joined #lisp
grabarz has joined #lisp
milanj has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
neuro_sys has joined #lisp
neuro_sys is now known as Guest20550
mingus has joined #lisp
heisig has joined #lisp
frgo has joined #lisp
decent-username has left #lisp ["ERC (IRC client for Emacs 26.3)"]
jeosol has quit [Ping timeout: 260 seconds]
loke has quit [Remote host closed the connection]
regi32 has joined #lisp
loke has joined #lisp
<regi32>
Does anybody know the real reason why roswell has been written in C?
<beach>
Come to ELS and ask the author. He is a frequent participant.
<no-defun-allowed>
I think it's supposed to be usable when the user doesn't have a Common Lisp implementation already.
<jackdaniel>
then build ecl from c (if you assume that there is a C compiler ,)
hhdave has joined #lisp
regi32 has quit [Client Quit]
smokeink has quit [Remote host closed the connection]
oxum has joined #lisp
oxum has quit [Remote host closed the connection]
smokeink has joined #lisp
oxum has joined #lisp
* beach
still hasn't understood what problem Roswell solves.
shka_ has joined #lisp
<jackdaniel>
beach: it is a package manager which automates downloading the CL implementation of your choice and apparently to set up quiklisp etc
<jackdaniel>
that said I've found it very impractical to use
william1_ has joined #lisp
<jackdaniel>
i.e I couldn't set up my self-build CL implementation for it, managing "active" implementation was quirky etc
<jackdaniel>
but I've tried it more than a year ago, maybe it got better
hlavaty has joined #lisp
<beach>
I see. Thanks for the explanation.
<pjb>
beach: so instead of having the problem of installing a CL implementation, now the newbies have the problem of installing roswell.
<beach>
Sure. And I would have a problem too, because I don't have a C compiler installed by default.
<pjb>
Exactly.
decent-username has joined #lisp
davepdotorg has joined #lisp
smokeink has quit [Remote host closed the connection]
davepdotorg has quit [Read error: Connection reset by peer]
davepdot_ has joined #lisp
smokeink has joined #lisp
smokeink has quit [Remote host closed the connection]
tiwEllien has joined #lisp
rwcom9 has joined #lisp
rwcom has quit [Ping timeout: 240 seconds]
rwcom9 is now known as rwcom
jfb4_ has quit [Ping timeout: 265 seconds]
jfb4 has joined #lisp
oxum has quit [Remote host closed the connection]
ebzzry has joined #lisp
jfb4_ has joined #lisp
jfb4 has quit [Ping timeout: 265 seconds]
<p_l>
personally, I find it easiest way to get lisp implementations loaded on a mac
adam4567 has left #lisp ["ERC (IRC client for Emacs 26.3)"]
mingus has quit [Remote host closed the connection]
<easye>
roswell ain't too bad from a casual user perspective, but I was not very happy when I needed to modify it to install LispWorks last year for Emotiq.
karlosz has quit [Quit: karlosz]
* beach
uses neither Macs nor C.
Guest20550 has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
<easye>
beach: if you use Linux, yer OS is mostly written in C...
<beach>
I know. I am trying to fix that problem. But it's going to take time.
oxum has joined #lisp
<easye>
Heh. We're rootin' for ya on that one...
jonatack has quit [Ping timeout: 248 seconds]
<beach>
I recently learned that I can't map page 0 because there might be bugs in the OS that dereference NULL and the C compiler does not protect against that by (say) inserting a test.
<beach>
Wonderful technology.
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
<p_l>
beach: ahh, that's configurable
<p_l>
and it's less OS bugs and more tricks with application bugs to get them to jump to known address
<beach>
Yes, so if I distribute SICL, I have to ask every Linux user to reconfigure their systems, thereby making them vulnerable to OS bugs.
neuro_sys has joined #lisp
<beach>
So we keep adding kludges on top of hacks to avoid solving the fundamental problems, thereby making life harder for both developers and users.
neuro_sys is now known as Guest86690
<beach>
Go figure!
<galdor>
why reconfiguring their systems ?
<jackdaniel>
to be able to map page 0 you need to pass a certain kernel flag
<beach>
If I represent NIL as a the machine number 5 and store NIL at address 0, they can't use my system unless they reconfigure.
<galdor>
I'm not sure remapping zero is going to end well on openbsd
<beach>
There you go.
gxt has joined #lisp
<beach>
So now I am in a situation where I must use a 32-bit immediate for NIL, because it can't be stored in the first few pages, and if i want to be able to run the implementation on a system with ASLR, then I also can't have pre-defined data structures in the executable.
<beach>
So I am basically forced to either have the system behave like a C++ application with ctors, or I am forced to do a full GC at the beginning of the execution, or possibly use relative pointers everywhere. Everything has a cost.
<beach>
no-defun-allowed: Exactly.
karlosz has quit [Quit: karlosz]
<beach>
No wonder applications like LibreOffice take forever to start.
<beach>
All this because we refuse to fix the real problem.
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
oxum_ has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
hhdave has quit [Ping timeout: 268 seconds]
hhdave has joined #lisp
wnj has quit [Remote host closed the connection]
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
amerlyq has joined #lisp
<lieven>
but the solutions^Wkludges like prelinking are so amusing
<jackdaniel>
many broken things are amusing and fun to work with ,)
<lieven>
there's KDE with kdeinit
m00natic has joined #lisp
<LdBeth>
beach: have you looked Emacs’ pdumper
<no-defun-allowed>
lieven: 😬
<beach>
LdBeth: I suspect not. I looked at how Emacs dumped memory to an executable a long time ago, but I think they changed it since. Why do you ask?
<no-defun-allowed>
"[kdeinit] executes KDE programs and kdeinit loadable modules (KLMs) starting them more efficiently." That's more terrible than I felt while waiting for at least two minutes for KDE4 to load on my old computer.
oxum_ has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<p_l>
pdumper acts a bit more like typical CL save image
<no-defun-allowed>
Can you dump an image from a cross-compilation where one implementation compiles another using that method?
oxum has joined #lisp
cpape`` has quit [Quit: ERC (IRC client for Emacs 26.1)]
cpape has joined #lisp
<LdBeth>
Emacs now does not directly mapping data into memory, at the cost of a little overhead
frgo has quit [Ping timeout: 265 seconds]
<LdBeth>
it’s very like serialization.
<beach>
Hmm.
<beach>
"a little"?
<jackdaniel>
LdBeth: thank you for the link, quite interesting
<pjb>
Let's note that C NULL pointers don't have to be represented by a #b0 bit pattern. At the level of the C source, casting it into a intptr_t should give you 0, and (void*)0 should give you a NULL pointer, but the binary representation of (void*)0 and (intptr_t)0 can be different.
<no-defun-allowed>
It's certainly useful, but in the "general" case dumping an image doesn't sound easy.
<pjb>
Unfortunately, no known compiler take advantage of that.
<no-defun-allowed>
Hm, I think Zeta C/Symbolics C had an odd representation for NULL (which was NIL?) as pointers were arrays of some kind.
<beach>
LdBeth: Thanks for the information. That is a terrible kludge that should not have been necessary in the first place.
<pjb>
beach: there are other reasons why you might not be able to use page 0 (or others pages with small addresses). Sometimes interruption vectors are stored there. Sometimes these addresses are used for fast addressing so the pages are used as temporary registers. And of course, the kernel can memory map them out of the user process reach anyways.
<beach>
I see.
<p_l>
no-defun-allowed: all "plain" memoy in Symbolics C was a big array that was multiply mapped as different types
<beach>
So I guess if you take ASLR into account, there is no chance that NIL could be a fixed constant, let alone an 8-bit machine value.
hhdave has quit [Ping timeout: 245 seconds]
* beach
thinks to himself... "what a wonderful world".
jonatack has joined #lisp
<p_l>
I like tagging NIL as separate tag
hhdave has joined #lisp
<p_l>
on a "plain" architecture it's not exactly doable to do away with ASLR, IMO
<p_l>
no matter the language
<p_l>
(and even on CADR, some people managed to exploit a memoy access)
<beach>
p_l: Why do you like a separate tag for NIL?
jonatack has quit [Ping timeout: 268 seconds]
<beach>
p_l: The problem is not the architecture. The problem is that we insist on programming as if we have access to the raw computer, just as we did in 60 years ago.
<beach>
s/in//
jonatack has joined #lisp
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo_ has joined #lisp
<LdBeth>
There’re lot of tools I can name written using specifically designed languages so they can translated to different architecture and assembled with macro
<LdBeth>
assemblers
<LdBeth>
And they write documents about internals
<LdBeth>
so other people can port the software to archs that the author had never heard
swills has quit [Ping timeout: 268 seconds]
frgo has quit [Ping timeout: 240 seconds]
Nilby has joined #lisp
<p_l>
beach: making it explicit that you don't have access to raw machine requires either a special machine, or disregard for security. And we no longer can do the latter, niot really
trittweiler has quit [Ping timeout: 240 seconds]
<p_l>
even AS/400, despite using "special intermediary language" route, implements portion of the necessary stuff in actual physical machine
trittweiler has joined #lisp
<White_Flame>
p_l: there's a difference between application code and system code
<White_Flame>
one of the big historical mistakes of computing was using C as an application langauge
<p_l>
White_Flame: for Lisp-style OS we might want to have less difference between the two
<p_l>
and C is very much application language, you can't write an OS in it without compiler extensions
<White_Flame>
you can't write an OS without assembly language full stop
<White_Flame>
at some point, the interface to the actual CPU and hardware must exist
<White_Flame>
but that should be contained in the systems dev stuff, not exposed to the application dev
<White_Flame>
and of course, considering a lisp os, things are different
<p_l>
White_Flame: `int *ptr = 0x12345; *ptr=10;` <--- what's the result in C of that?
<jackdaniel>
of course it is 42.
<p_l>
and I'm of the argument that "constraining" application development is bad
<p_l>
jackdaniel: I like the option of "programmer strangled by compiler"
<jackdaniel>
I'm sure many people could raise a concern, that while C is indeed part of the topic, it lacks the L suffix :-)
<p_l>
I didn't know lisp implementation talk was outside the topic
<jackdaniel>
I don't share a view that banter about C is discussing "lisp implementation"
dddddd has joined #lisp
<no-defun-allowed>
p_l: Clearly you don't use my compiler, where undefined behaviour causes unicorns to shoot out of the screen.
<LdBeth>
Missile launched
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
<beach>
p_l: I don't see how a special architecture is needed. Can you elaborate?
<beach>
p_l: And you didn't answer my question as to why you prefer a special tag for NIL.
<p_l>
beach: AS/400 solved security issues involved in having single address space by making a much fine grained control (on hw level) on access to memory locations, with more flexibility than simplistic supervisor/usermode
<p_l>
as for specific symbol for NIL, it means that a check for NIL doesn't have to dereference memory, nor do you need any special memory location, which is problematic with ASLR and others
<beach>
p_l: That would be the same problem for any symbol then; not just NIL.
<p_l>
beach: by providing more advanced security measures in hw, the intermediate level "bytecode" could exploit such features for efficient *and* secure implementation
<p_l>
as for symbols - I honestly believe we have way more cases of NIL-checking than any other, and EQ can just compare the address usually
<beach>
p_l: I am suggesting making direct access to memory locations impossible. I don't see how that requires special hardware, and I don't see how it would be a security risk.
papachan has joined #lisp
<beach>
p_l: Yes, ASLR is a problem for comparing to a constant. So, if ASLR was your argument, I agree.
<beach>
p_l: But the disadvantages of a separate tag would result in a maintenance nightmare, and also you would need two tests for each iteration in a loop over a list.
<beach>
p_l: Whereas, even with ASLR, you just have to implement EQ by comparing two lexical locations.
<p_l>
also, I kinda don't trust "direct access to memory locations is impossible", given several times people escaped from exactly that kind of sandboxing - maybe you'll find a better method to implement it though (I hope)
<beach>
p_l: We'll find out.
<beach>
Also, I would give some more thought to my idea if you could provide some more substance as to what technique would be used to access memory if no operation is provided to do so. More than your distrust, I mean.
<beach>
I guess the two tests in the loop could be avoided if you don't do it the way SBCL does.
<beach>
Anyway, time for a break.
<p_l>
beach: I'll dig out some details later, but generally there's been a plenty done in JS space - you might be able to avoid them by using a better language for implementation though, so I'm eagerly awaiting more on SICL :)
<Shinmera>
People have managed to program and launch entirely new games just by pressing the right inputs in Super Mario World
<Shinmera>
Which to me just shows that implementing anything to be secure is very hard.
<jackdaniel>
security concerns take away a lot of fun from playing with computers
<pjb>
White_Flame: note that using C for applications is not really the fault of the creators of unix: they provided a fortran compiler!!!
<pjb>
:-)
grewal has quit [Quit: leaving]
<pjb>
p_l: you've got an implicit conversion from into to int*; you get a message from the compiler (and if you insist, a segfault when running it).
<pjb>
(undefined behavior).
rnmhdn has joined #lisp
<pjb>
As for NIL, I don't think there would be any win today to handle it any differently than any other CL symbol.
<pfdietz63>
Archaic unix ran in a very constrained environment. It's amazing it (or its C compiler) worked at all in a 16 bit address space.
<pjb>
Shinmera: security is when you can implement a new game in Super Mario World without crashing or destroying Super Mario World. No security is when pressing buttons let you break Super Mario World, and worse, when it let you program the host computer to a different program.
Guest86690 has quit [Ping timeout: 258 seconds]
rnmhdn has quit [Client Quit]
nirved has quit [Ping timeout: 252 seconds]
nirved has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
oxum has quit [Remote host closed the connection]
rnmhdn has joined #lisp
samlamamma has joined #lisp
ebrasca has joined #lisp
<samlamamma>
There used to be a video on YouTube where some LispM guys (Symbolics?) present an emacsen C++ IDE. Any idea what that video is called?
EvW has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
krisfris1 has joined #lisp
gravicappa has joined #lisp
oxum has joined #lisp
pfdietz63 has quit [Remote host closed the connection]
<decent-username>
"the most inefficient way of creating strings"
<shangul>
:)
<Shinmera>
list* is also very good for prepending things in general!
<beach>
(list* "a" "b" "c" "d")
<boeg>
ah that works, I had been trying with normal "list" but it just wanted the "cons list" and i'm not sure I understand why, but "list*" works
<boeg>
thanks all
<beach>
boeg: It is called a "dotted list".
<boeg>
ah yes, sorry
<beach>
As opposed to a "proper list".
bitmapper has joined #lisp
<boeg>
yes, dotted list, ill remember
<beach>
boeg: You will understand why when you read the Common Lisp HyperSpec page for LIST*.
<boeg>
ill go do that now
<decent-username>
The list section from the book "ANSI Common Lisp" by Paul Graham helped me a lot.
<decent-username>
In understand all that dotted list stuff.
<boeg>
yeah, I think I know the difference - the dotted list it just "the items" where as a proper list is composed of a dotted list with an element and a pointer to another dotted list, and so on, and the last dotted list will have a nil as its last element? And in this case, the function i'm calling wants a dotted list with elements all the way through, and not a nil at the end
madmonkey has joined #lisp
<boeg>
anyways, i'll get to reading the documentation for list* now and see if i am right
asdf_asdf_asdf has joined #lisp
<_death>
the glossary has definitions for dotted list, proper list, etc.
<phoe>
boeg: (... . nil) equals (...)
EvW1 has joined #lisp
<boeg>
right - but am I wrong or? a List say (list 1 2 3) is actually (cons 1 (cons 2 (cons 3 nil))) right whereas (list* 1 2 3) is (1 . 2 . 3) or?
<phoe>
it's (1 2 . 3)
<boeg>
ah
<phoe>
(1 . 2 . 3) is invalid notation
<_death>
boeg: (1 . (2 . 3))
<boeg>
ah of course
<phoe>
only one dot is allowed in a list, and only one element is allowed after the dot
<boeg>
thanks
<dlowe>
boeg: are you familiar with linked lists?
<phoe>
LIST* is equivalent to LIST except for the last argument passed to it
<boeg>
dlowe: yes
<boeg>
phoe: yes I see that now
<phoe>
(list* 1 2 3 4 5 ...) == (list 1 2 3 4 5 ...) as long as you only care about the first five elements
oxum_ has joined #lisp
EvW has quit [Ping timeout: 248 seconds]
EvW1 is now known as EvW
<phoe>
it's the ... up there where things get different
<dlowe>
boeg: lists in CL are standard singly linked lists of two-field structures called conses. all this other stuff is notation
<boeg>
dlowe: yes, I had just gotten confused - i knew lists were linked lists, but I thought for some reasons conses wasn't
<boeg>
but of course they are
<boeg>
but lists are made of conses, so they have to be
<boeg>
I am trying to up my common lisp game, but now that i am trying out (next browser) I guess i'll get a lot more practical experience with common lisp since it's configured in common lisp
<dlowe>
I mean, a linked list is an arrangement - conses are just a convenient standard to build lists out of
<dlowe>
you could also do (defstruct my-cons data next) and build it up from scratch
gnufr33d0m has joined #lisp
oxum has quit [Ping timeout: 268 seconds]
<boeg>
right
<dlowe>
boeg: going through the Practical Common Lisp book?
jmercouris has joined #lisp
<boeg>
boeg: no done with that for a first pass, right now I'm reading that paradigms of artificial intelligence programming
<jmercouris>
how can I inspect an object in Slime without right clicking "Inspect"?
<jmercouris>
(inspect x) doesn't do the same thing, it doesn't open the *slime-inspector*
Lord_of_Life_ has joined #lisp
<dlowe>
boeg: that's a very fun one
<dlowe>
jmercouris: M-x slime-inspect
<boeg>
dlowe: its very interesting yes
<jdz>
jmercouris: C-c C-v i
william11 has joined #lisp
<jmercouris>
dlowe: how can I refer to previously evaluated things from the slime repl?
<jdz>
jmercouris: press RET
<jmercouris>
jdz: perfect! thank ou
oxum_ has quit [Remote host closed the connection]
<jmercouris>
for future readers: C-c C-v i also works when the cursor is over the object
<jdz>
jmercouris: there are quite a few more keybindings with C-c C-v prefix, Press C-c C-v ?.
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
DGASAU has quit [Read error: Connection reset by peer]
<jmercouris>
Ah, OK! thanks
<dlowe>
the maximum number of sequential keybindings I can remember is 2 :p
<decent-username>
How would you merge multiple large lists into a single even bigger list?
Necktwi has quit [Read error: Connection reset by peer]
<decent-username>
but appends needs to traverse the list right?
asdf_asdf_asdf has quit [Remote host closed the connection]
<jdz>
Right.
<decent-username>
isn't there a faster way?
<jdz>
No.
<decent-username>
makes sense. LOL
<jdz>
Unless you make your own datastructure that keeps track of list tails.
<decent-username>
nah, I'm to lazy for that. I'll use append.
<decent-username>
thanks for the answer
jfb4_ has quit [Ping timeout: 240 seconds]
kajo has quit [Ping timeout: 252 seconds]
<pjb>
boeg: note the names: proper-list, dotted-list, circular-list. proper-list implies that the other types of lists are IMproper. This is quite negative. Why would you want to create and use IMproper lists? This will lead to all sorts of difficulties, given that most CL functions are not prepared to deal properly with IMproper lists. They will in general fail on dotted-list, and enter infinite loops on circular-lists.
<pjb>
boeg: so you have to have a strong justification to use improper lists such as dotted-lists…
jfb4 has joined #lisp
Necktwi has joined #lisp
oxum has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
shangul has quit [Remote host closed the connection]
<luis>
I think I'm holding ironclad wrong. https://pastebin.com/nXu6ch1e Can anyone tell me what I'm doing wrong? The encrypted message is unchanged. %-)
brown121408 has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
jprajzne has quit [Quit: Leaving.]
oxum has quit [Ping timeout: 265 seconds]
<gabc>
luis: does #'ironclad:encrypt returns a value or change it in place?
<gabc>
If it returns a value you're throwing it out and not saving it, which would explain what you're describing
<luis>
gabc: it's returning (values 0 0)
<dlowe>
hm. what do those 0s mean
<_death>
since you're using ECB mode you need to pass in blocks..
<dlowe>
yeah, are those padded to the correct length?
DGASAU has joined #lisp
dyelar has joined #lisp
<_death>
(ironclad:block-length :blowfish) => 8
<jmercouris>
if they aren't you can always npm install leftpad++
<luis>
Ah, I need to pad the message!
pfdietz has quit [Remote host closed the connection]
<luis>
(And probably the key too.)
<luis>
Though "password" matches the block size.
<_death>
luis: you can use ironclad:key-lengths to see which key lengths the cipher supports
<_death>
for padding, you can use ironclad::add-padding-bytes (for some reason it's not exported?)
<luis>
_death: seems like I can pass :padding :pkcs7 (or whatever) to the cipher and :handle-final-block t to encrypt.
<_death>
and for key, you will likely want to use key derivation.. and if you're actually plan on using it rather than learning, you shouldn't use blowfish, and shouldn't use ECB :)
scymtym_ has joined #lisp
<luis>
_death: I'm just porting some code, so I think I have to stick to blowfish and ECB since I have encrypted messages floating around that way
<_death>
ouch.. visions of penguins
<luis>
_death: but the wikipedia article about ECB illustrates why ECB is a bad idea very eloquently :)
<luis>
with a penguin, exactly
scymtym has quit [Ping timeout: 245 seconds]
scymtym_ has quit [Ping timeout: 245 seconds]
<luis>
dlowe: how do you usually pad the message?
<_death>
pkcs7 is the usual way
<luis>
Right. But with ironclad::add-padding-bytes?
william11 has quit [Ping timeout: 268 seconds]
<_death>
I guess.. personally I like CTR mode (+ authentication) so I don't need to pad or steal from ciphertext :)
froggey has quit [Ping timeout: 268 seconds]
<_death>
there are other useful ironclad operators whose symbols should be exported.. e.g., ironclad::modular-inverse
Nilby has quit [Ping timeout: 265 seconds]
froggey has joined #lisp
smazga has joined #lisp
ebzzry has joined #lisp
<_death>
luis: but you're right, there's the :padding argument and :handle-final-block
<_death>
you just need to make sure the output buffer size is a multiple of block size
<luis>
Right. OK. Many thanks. You've been most helpful!
<_death>
(+ 1, if the message is zero bytes..)
heisig has quit [Quit: Leaving]
<_death>
*er, if the message is an exact multiple
gxt has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
<_death>
pkcs7 padding will always add at least one byte.. if the message size is an exact multiple of block size, it will add another block
jonatack has quit [Ping timeout: 240 seconds]
zmv has joined #lisp
oxum has joined #lisp
pfdietz has joined #lisp
rnmhdn has quit [Ping timeout: 265 seconds]
jayspeer has joined #lisp
jfb4_ has joined #lisp
jfb4 has quit [Ping timeout: 268 seconds]
jfb4 has joined #lisp
jfb4_ has quit [Ping timeout: 260 seconds]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
ebzzry has quit [Ping timeout: 268 seconds]
dale_ has joined #lisp
dale_ is now known as dale
jfb4_ has joined #lisp
oxum has quit [Remote host closed the connection]
jfb4 has quit [Ping timeout: 268 seconds]
jebes has joined #lisp
oxum has joined #lisp
william11 has joined #lisp
ebzzry has joined #lisp
grabarz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jfb4 has joined #lisp
sjl has joined #lisp
Odin- has joined #lisp
oni-on-ion has joined #lisp
jfb4_ has quit [Ping timeout: 258 seconds]
william11 has quit [Ping timeout: 265 seconds]
<_death>
boeg: huh, we were talking about lists and cons cells, and Joe Marshall just put out a post about it (check planet lisp)
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
jfb4 has quit [Ping timeout: 268 seconds]
ebrasca has quit [Remote host closed the connection]
jfb4 has joined #lisp
jayspeer has quit [Quit: going home, see you around]
nullniverse has joined #lisp
nullniverse has quit [Max SendQ exceeded]
nullniverse has joined #lisp
nullniverse has quit [Max SendQ exceeded]
nullniverse has joined #lisp
jmercouris has quit [Ping timeout: 268 seconds]
ebrasca has joined #lisp
jfb4_ has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
jfb4 has quit [Ping timeout: 268 seconds]
DGASAU has quit [Read error: Connection reset by peer]
reg32 has joined #lisp
terpri_ has quit [Remote host closed the connection]
DGASAU has joined #lisp
terpri has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 268 seconds]
shangul has joined #lisp
quazimodo has joined #lisp
slyrus__ has joined #lisp
vivit has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
<vivit>
Is it possible to define a single method specializer across, for example, all types (SIMPLE-VECTOR N) where N is a positive integer?
<Shinmera>
you can't specialise on types at all
<vivit>
What are you doing when you (defmethod f ((foo integer) (bar integer)) (...)) then?
<mfiano>
All classes have an associated type, but the inverse is not true.
davepdot_ has quit [Ping timeout: 268 seconds]
<Bike>
i'm not sure what you're going for with the original question. the union of all (simple-vector n) types is just simple-vector. or do you want to use N in the body?
<mfiano>
There are libraries to emulate what you want, however. specialization-store comes to mind.
rumbler3_ has joined #lisp
<mfiano>
Or if you want to use actual generic functions, flitered-functions is pretty nice.
hhdave has quit [Quit: hhdave]
rumbler31 has quit [Ping timeout: 240 seconds]
g0d_shatter has joined #lisp
<vivit>
Bike: I was confusing classes and types; I thought that methods were specialized on types and since (simple-vector 1) is a different type from (simple-vector 2) there would be some special syntax for writing a definition across all simple-vector types. I blame Haskell.
<vivit>
What about specializing methods with &rest arguments?
<mfiano>
Can't specialize on &key &optional or &rest without specialization-store
<Bike>
rest arguments are always nil or cons, anyway.
<_death>
usually functions have a single "target audience", the callers.. with generic functions, there are now two distinct possible audiences, callers and extenders.. if you feel the need to specialize on &rest or &key, that means it may be beneficial not to conflate the two audiences, by defining a separate function for each
DGASAU has quit [Read error: Connection reset by peer]
<Bike>
indeed
DGASAU has joined #lisp
<_death>
(of course you still call the "extenders" function, but you can think of these particular callers as yet another audience)
varjag has joined #lisp
rnmhdn has joined #lisp
jonatack has joined #lisp
m00natic has quit [Remote host closed the connection]
<vivit>
trying to define a package-local function called +, but I'm getting the error "The variable + is unbound" when I try to compile the defun. What's up with that?
jfb4 has joined #lisp
<Bike>
What does your defpackage look like? Maybe it doesn't :use :CL, so the compiler is reading your-package::defun and treating it as a function name.
mathrick has joined #lisp
jfb4_ has quit [Ping timeout: 268 seconds]
amerlyq has quit [Quit: amerlyq]
terpri has quit [Remote host closed the connection]
terpri_ has joined #lisp
vivit has quit [Quit: WeeChat 1.9.1]
vivit has joined #lisp
brown121408 has quit [Ping timeout: 240 seconds]
fookara has quit [Remote host closed the connection]
grabarz has joined #lisp
terpri_ has quit [Excess Flood]
brown121407 has joined #lisp
grabarz has quit [Client Quit]
brown121407 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
gareppa has joined #lisp
<vivit>
Now I'm getting "Lock on package COMMON-LISP violated when defining + as a function while in package LRL". How do I indicate that I want to define LRL::+, not cl:+?
jfb4_ has joined #lisp
<vivit>
I get the same error if I try to (defun lrl::+ ...)
<Bike>
so to be clear, you did your defpackage lrl, and then (in-package #:lrl) or such, and so it's reading things in the LRL package?
<Bike>
probably you want to shadow + (and whatever other symbols) in defpackage.
jfb4 has quit [Ping timeout: 265 seconds]
<Bike>
otherwise lrl::+ will be the same as cl::+.
<_death>
you should also know that cl:+ has more roles than a function name, which your:+ may not be able to fulfil
<_death>
this matters especially with regards to cl:*
nullniverse has quit [Quit: Leaving]
decent-u` has joined #lisp
decent-username has quit [Ping timeout: 246 seconds]
slyrus_ has joined #lisp
jmercouris has joined #lisp
gareppa has quit [Quit: Leaving]
decent-u` has quit [Quit: ERC (IRC client for Emacs 26.3)]
decent-username has joined #lisp
slyrus__ has quit [Ping timeout: 258 seconds]
<earl-ducaine>
phoe: I haven't contacted the Hemlock developers re: the :qt dependancy. But as far as I can tell there's been no active development for over a decade, so I wouldn't expect anyone to take action on it.
jmercouris has quit [Remote host closed the connection]
zmv has quit [Remote host closed the connection]
karlosz has joined #lisp
swflint has quit [Ping timeout: 258 seconds]
shangul has quit [Ping timeout: 268 seconds]
davisr has quit [Quit: Leaving]
madmonkey has quit [Remote host closed the connection]
rnmhdn has quit [Ping timeout: 240 seconds]
rnmhdn has joined #lisp
william1_ has joined #lisp
tiwEllien has quit [Quit: WeeChat 2.7]
cosimone has quit [Quit: Quit.]
grabarz has joined #lisp
william1_ has quit [Ping timeout: 268 seconds]
EvW has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
<pjb>
vivit: don't worry, you can always type: (vector integer cl:*).
swflint has joined #lisp
terpri_ has joined #lisp
scymtym has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
<jasom>
I'm writing some software for an rpi; any tips or gotchas for using lisp to develop for it? Will swank and tramp-mode just work similar to how I would do between two x86oids?
scymtym has quit [Read error: Connection reset by peer]
DGASAU has quit [Read error: Connection reset by peer]
<Xach>
I would like to do some lisp stuff to display on my tv with my raspberry pi
X-Scale` has joined #lisp
<luis>
_death: ironclad:encrypt-message takes care of padding!
milanj has quit [Quit: This computer has gone to sleep]
X-Scale has quit [Ping timeout: 265 seconds]
X-Scale` is now known as X-Scale
<_death>
luis: ah, good to know
<_death>
would be nice if ironclad:encrypt docstring had a See Also note
DGASAU has joined #lisp
<boeg>
Is it possible to have an optional argument (with or without default value) as *not* the last parameter. So say a function takes argument (a b &optional (c "") d), and the function can then be called with 3 argument (where c will get default value) or 4 arguments?
eddof13 has joined #lisp
<Xach>
boeg: no
<boeg>
alright
<_death>
you could implement your own arglist parsing, though that's a good sign you should rethink the interface
<boeg>
yeah
<pjb>
boeg: you can either 1- use &key arguments they are optional! or 2- use &rest and parse the list of arguments yourself!
<boeg>
pjb: good suggestions, thanks
<pjb>
(defun foo (a b &rest args) (let (c d cp dp) (ecase (length args) ((0)) ((1) (setf d (car args) dp t)) ((2) (setf c (car args) cp t d (cadr args) dp t))) (list a b cp c dp d))) (foo 1 2 3) #| --> (1 2 nil nil t 3) |# (foo 1 2 0 3) #| --> (1 2 t 0 t 3) |#
<boeg>
thanks
g0d_shatter has quit [Quit: Leaving]
eddof13 has quit [Quit: eddof13]
vivit has quit [Ping timeout: 240 seconds]
phlim has quit [Quit: WeeChat 2.4]
grabarz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rnmhdn has left #lisp ["WeeChat 2.5"]
grabarz has joined #lisp
eddof13 has joined #lisp
scymtym has joined #lisp
ebrasca has quit [Remote host closed the connection]
milanj has joined #lisp
atgreen has joined #lisp
ebrasca has joined #lisp
bitmapper has quit []
asdf_asdf_asdf has joined #lisp
X-Scale has quit [Ping timeout: 260 seconds]
efm has quit [Ping timeout: 240 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
gareppa has joined #lisp
gxt has joined #lisp
<eeeeeta>
jasom: you'd want to use CCL on a pi if you want threading; I was able to get swank working that way
vivit has joined #lisp
efm has joined #lisp
ebrasca has quit [Remote host closed the connection]