iamFIREcracker has quit [Ping timeout: 246 seconds]
<Bike>
i guess there's a sort of issue in that if you have, like, (aref x (incf y)) as a place, the incf will only be executed once probably, even if you repeatedly use the setter function
<stylewarning>
phoe: yes
wsinatra has joined #lisp
iamFIREcracker has joined #lisp
beach` has joined #lisp
iamFIREcracker has quit [Ping timeout: 265 seconds]
edgar-rft has quit [Quit: Leaving]
beach has quit [Ping timeout: 272 seconds]
theBlackDragon has quit [Ping timeout: 256 seconds]
theBlackDragon has joined #lisp
mangoicedtea has quit [Quit: Leaving]
<White_Flame>
Bike: and then what would (incf <locative for (aref x (incf y))>) be most sensible to do?
quazimodo has quit [Ping timeout: 256 seconds]
yitzi has quit [Quit: yitzi]
justache has quit [Ping timeout: 240 seconds]
Volt_ has joined #lisp
justache has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
ldb has joined #lisp
<ldb>
good morning
<Josh_2>
Hi
<ldb>
White_Flame: > and then what would (incf <locative for (aref x (incf y))>) ... in principle, that should be undefined behavior
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
bilegeek has quit [Quit: Leaving]
bilegeek has joined #lisp
IPmonger has quit [Client Quit]
IPmonger has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
IPmonger has quit [Read error: Connection reset by peer]
IPmonger has joined #lisp
Bike has quit [Quit: leaving]
Kaisyu has joined #lisp
Gerula has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
Oladon has quit [Quit: Leaving.]
iAmDecim has joined #lisp
aartaka has joined #lisp
ebrasca has quit [Remote host closed the connection]
iAmDecim has quit [Ping timeout: 265 seconds]
iAmDecim has joined #lisp
IPmonger has quit [Ping timeout: 244 seconds]
IPmonger has joined #lisp
borei has joined #lisp
<borei>
good morning/afternoon everybody !
iAmDecim has quit [Ping timeout: 258 seconds]
Oladon has joined #lisp
dominic34 has quit [Ping timeout: 258 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<ldb>
HELLO borei
IPmonger has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
<borei>
don't know if my question very basic, but i can't find answer for it. In C i can treat array as chunk of memory, using (char *) i can use it as a sequence of bytes, i can dump that chunk of binary data to the file, but i can't find how does lisp approach to this problem
IPmonger_ has joined #lisp
<borei>
more explicit problem is i have array of floats, i need to work with it like with array of bytes.
IPmonger has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
Not easily; I don't think Common Lisp specifies a float representation, but there are libraries that you can use to convert floats to bytes and back which could help.
<borei>
well not necessary float it can array of the items of any type, i just need to treat it as block of data, not looking at the type of the items. type can be specified later.
IPmonger has joined #lisp
<no-defun-allowed>
That is not going to happen.
<borei>
ic
<no-defun-allowed>
In C, the representation of all the data you would write is probably undefined, and in CL only more so, as you can't portably make an array of a different type with the memory of another.
srhm has joined #lisp
aartaka has joined #lisp
Lycurgus has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
dominic34 has joined #lisp
zaquest has quit [Quit: Leaving]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
beach` is now known as beach
IPmonger has joined #lisp
<beach>
Good morning everyone!
mindCrime_ has quit [Ping timeout: 244 seconds]
Inline has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
Oladon has quit [Quit: Leaving.]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ldb has quit [Quit: Connection closed]
space_otter has joined #lisp
Lycurgus has quit [Quit: Exeunt]
johnjay has quit [Ping timeout: 258 seconds]
johnjay has joined #lisp
Volt_ has quit [Quit: ]
ldb has joined #lisp
<ldb>
borei: I think you are looking for serialization
<ldb>
there're vast implementations of this feature, and to different extents, but most of them works at least on builtin data types
<ldb>
but this is not meant to dump out an array of characters and read in as if it is something else like array of floats
zaquest has joined #lisp
|3b| has quit [Ping timeout: 246 seconds]
trn has quit [Ping timeout: 265 seconds]
gravicappa has joined #lisp
trn has joined #lisp
notzmv has quit [Remote host closed the connection]
<borei>
looks like i can deal with the problem using cffi foreign memory, in any cases i need to pass that data further to cffi foreign functions. i just measured if there is any overhead loading data into native lisp array and into foreign pointer - not too much. for 10M double float native array - ~0.08 sec, foreign - ~0.10.
<borei>
side notice - im still surprised how fast lisp is (sbcl) - using native C implementation im getting the same numbers.
<no-defun-allowed>
From memory, referencing a foreign array is basically just one load instruction.
<no-defun-allowed>
With sufficient declarations, (cffi:mem-aref <a cffi:foreign-pointer> :char <a fixnum>) is MOVSX RDX, BYTE PTR [RAX+RDI] on SBCL on x86_64.
<borei>
declaration in your example in <> brackets - is it real form ? don't recall such.
<no-defun-allowed>
It's a suggestion that you should put something of that type in the <...>.
<borei>
:ldb thanks for pointing me to serialization libraries
<White_Flame>
man, low-bit tags were such a performance enhancing idea for fixnums
<White_Flame>
(presuming the "SX" is sign extension)
<no-defun-allowed>
Yes.
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
aartaka has joined #lisp
borei has quit [Ping timeout: 264 seconds]
aartaka has quit [Read error: Connection reset by peer]
narimiran has joined #lisp
torbo has quit [Remote host closed the connection]
Codaraxis__ has quit [Read error: Connection reset by peer]
Codaraxis__ has joined #lisp
_whitelogger has joined #lisp
<beach>
I am completely changing my opinions about Robert C Martin, also known as "Uncle Bob". In the past, I thought he was an ignorant, fad-pushing buffoon. After listening to his lectures entitled "Clean Code", I now think he is neither ignorant, nor fad-pushing.
<beach>
In fact, I think it's the exact opposite. He is still a bit of a buffoon, but that's just his style. I don't like it much, but it seems to work for him.
<beach>
And the reason I am mentioning it here, is that in the Q&A session at the end of lesson 4, he says that he wants Lisp to be one of the languages used in the future, because it combines "structured programming", "functional programming", and "object-oriented programming". If he were just an ignorant, fad-pushing buffoon, he would not even know about Lisp.
msk has joined #lisp
msk has quit [Max SendQ exceeded]
msk has joined #lisp
<beach>
So all you #lisp participants who work in industry where projects are managed by people who know nothing about software design, but who believe in "software gurus", you can now tell them that one of the most famous gurus wants you to use Lisp.
dominic34 has quit [Ping timeout: 258 seconds]
bsd4me has quit [Quit: Leaving]
treflip has joined #lisp
Necktwi has quit [Ping timeout: 256 seconds]
<ldb>
never heard that person, although I heard "Clean Code”
<ldb>
I think I still would focus on one-man-week size projects for a long time
ggole has joined #lisp
dmiles has quit [Read error: No route to host]
dmiles has joined #lisp
iamFIREcracker has joined #lisp
skapata has joined #lisp
<jackdaniel>
afair in one of his lectures he declared clojire the ultimate lisp to use ;)
<aeth>
to be fair, if you were pushing software fads for decades, you probably would've pushed Lisp 3-4 separate times...
<flip214>
Is there a way to kill a process started with UIOP/LAUNCH-PROGRAM
skapata has left #lisp [#lisp]
<jackdaniel>
use terminate-process
<jackdaniel>
on the program reference
ljavorsk has joined #lisp
<ldb>
see UIOP/LAUNCH-PROGRAM section of the UIOP manual for usage reference
<flip214>
ah, terminate. I looked for kill, stop, and similar stuff. Thanks!
iAmDecim has joined #lisp
jprajzne has joined #lisp
scymtym has quit [Remote host closed the connection]
<flip214>
If I've got a stream with multiple XML blobs, can I use CXML in a loop to parse "incrementally"? CXML croaks "trash at end of input" (the next xml blob)
aartaka has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
aartaka has quit [Read error: Connection reset by peer]
<jackdaniel>
crash at end of input is a possibility :)
aeth has joined #lisp
aartaka has joined #lisp
treflip has quit [Ping timeout: 260 seconds]
aartaka has quit [Read error: Connection reset by peer]
treflip has joined #lisp
<flip214>
jackdaniel: well, if I could get an item back, I'd be willing to put an IGNORE-ERRORS around...
<flip214>
guess I'll have to do manual buffering to separate the blobs
treflip has quit [Quit: WeeChat 2.6]
jason_m has quit [Ping timeout: 256 seconds]
schweers has joined #lisp
<flip214>
I now used a CONCATENATED-STREAM to add start/end tags... I hope that'll work for my inputs and not get OOM some time in the future
<wwolf[m]>
flip214: I think Klacks parser may help:
<ebrasca>
It is GPLv2 , I only need to keep it GPLv2 I think.
<phoe>
yes, just remember not to bundle it into the mezzano codebase.
<ebrasca>
Do you think someone outside mezzano is going to be interested in cl-smta ?
<phoe>
I can't answer that question since I don't know, I'm just pointing out possible licensing issues
shka_ has joined #lisp
<phoe>
Mezzano is MIT and you don't want to pollute it with GPL code if it is supposed to stay MIT
<ebrasca>
I think pollute is bad word, why not mix?
<ebrasca>
phoe: Thanks!
<phoe>
"pollute" implies that turning the whole project GPL is unwanted
<phoe>
and I usually assume that if some code is MIT-licensed then it is MIT-licensed purposefully, and therefore relicensing it GPL is unwanted
<ebrasca>
Why adding some GPL make it GPL?
<phoe>
because that is what the GPL says.
bilegeek has quit [Quit: Leaving]
hendursa1 has joined #lisp
<phoe>
all code that is a derivative work of GPL code must be licensed under GPL, and bundling GPL code within some other application and then having other code depend on that GPL code is the best way to create such a derivative work.
hendursaga has quit [Ping timeout: 240 seconds]
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
<jackdaniel>
so having gcc on osx makes whole operating system gpl?
<jackdaniel>
or using cl-smtp with sbcl renders the latter gpl?
<jackdaniel>
also "mere aggregation is not a derivative work"
<ldb>
well, gcc doesn't link with OS X's system components
<jackdaniel>
it is not linking model what defines a derivative work, however literal wording in the license mentions vague terms like linking or objects
<aeth>
Separation in a CL image is a lot less clear. At the very least, you shouldn't bundle GPL software with a non-GPL Lisp OS imo.
<aeth>
If someone else loads in GPL software, it's on them.
<jackdaniel>
it was clarified in many places, also by fsf
<jackdaniel>
and lispworks lawyers n.b, talking about lisp
<jdz>
If any code in Mezzano depends on GPL code to function then it will be considered a derivative work.
<jackdaniel>
so spreading misinformation is either ignorant or malicious towards gpl ;)
<jackdaniel>
yes, what jdz says is true
<moon-child>
I agree with aeth. The presence of the symbols in the image alongside system components seems like it make a derivative work. Certainly, it's difficult to ensure there are no other components that accidentally call into the smtp lib
<jackdaniel>
^ fud
* jackdaniel
goes afk
<aeth>
The issue is distinguishing between applications, which isn't necessarily as clear in an exotic Lisp OS as it is in something closer to a Unix-like or Windows one.
<aeth>
I don't know enough details to know if it's safe, but I wouldn't assume out of the box that it's safe, especially since the FSF's clarifications for the GPL and Lisp are almost certainly going to be in the context of Unix-like OSes.
Necktwi has joined #lisp
<phoe>
...with a license that was clearly only created to be used with Unix-like or Windows systems and C-like programming languages, given the "linking" terms used there
<phoe>
but that's already been clarified multiple times anyway
<aeth>
As long as the base license is GPL-compatible, there's no issue for users, of course.
jonatack has quit [Ping timeout: 240 seconds]
<aeth>
phoe: LGPL is the really problematic license to apply because linking really matters there, but this channel has had that conversation before here and I'd still trust the LGPL over the custom-license LLGPL. (never use a non-OSI/non-FSF license for FOSS code! NEVER!) But my interpretation of the LGPL as applied to CL would still be pretty awkward in practice, since you'd have to have it reloadable/replacable as a separate FASL rather than bu
<aeth>
rather than bundled as a monolithic application.
<phoe>
only in case of lgpl3 which has the anti-tivoization clause
<aeth>
ah, good point
<phoe>
lgpl2 does not have it.
<aeth>
and the GPLv3 has similar clauses, so it might be similarly problematic, then. From a distribution standpoint I mean... since CL applications (rather than QLed libraries) want to be monoliths.
msk has quit [Quit: Leaving]
<ebrasca>
What about GPLv3 working on ROM?
<aeth>
(By "monolith", I mean, creating an executable save-lisp-and-die or whatever the equivalent is, rather than starting the Lisp image bare like running "sbcl --script" and loading the FASLs from ~/.cache/common-lisp/ or wherever.)
<aeth>
ebrasca: sounds like it would be "tivoized"
<jackdaniel>
as I've said, business with linking and lisp images has been clarified by both lawyers and fsf, so it is still fud
<jackdaniel>
(either ignorance or malice - driven)
<aeth>
At the very least, strict adherance to the spirit of anti-tivoization might require something like uiop:with-upgradability...
<jackdaniel>
you also need an available (to the end user) interface to load either a fasl or some other form of the *gpl3 library
<aeth>
Yes, you might be able to argue that just giving REPL access is good enough, although inlining (part of what with-upgradability solves) and macros could still be problematic. And possibly packages/structs, too, depending on the Lisp.
<aeth>
But I think in theory, you can do the correct surgery required just with REPL/swank access even in something that doesn't like certain redefinitions like SBCL. Worst case just unintern the symbol and very quickly provide the new definition while recompiling all users, I guess.
<jackdaniel>
repl is not always part of the final application, also end user may have no access to the cli etc (i.e app on the camera device). sure, things should not be inlined in that case
<aeth>
Without REPL access, I think you'd probably need to keep everything as separate FASLs (or at least provide a mechanism so they're overridable as separate FASLs) with no macros and with uiop:with-upgradability.
<aeth>
(I mean no exported macros in the GPLed interfaces)
<aeth>
Perhaps you could just track the users of macros and recompile them, though.
<jackdaniel>
macros are part of the compiler, they are not part of runtime, hence there is no need to recompile macro users --given that it will work correctly without recompilation)
<jackdaniel>
that was sloppily worded
wxie has joined #lisp
<jackdaniel>
they are in the runtime of course
<aeth>
if you replace a(n L)GPLed library for an application without recompiling the application, macros might break because the macroexpanded code might now be nonsense to the new API of the library.
wxie has quit [Remote host closed the connection]
<jackdaniel>
but the result of prior compilation is not obligued to be recompiled
wxie has joined #lisp
<jackdaniel>
yes, that's why I noted "given that it will work correctly"
<aeth>
if what you're saying is true, I think you could intentionally circumvent the license using
<jackdaniel>
a good practice to achieve that is to have macros always expand to a separate finction
<aeth>
macros
Inline has quit [Ping timeout: 272 seconds]
<jackdaniel>
i.e invoke-with-foo
<jackdaniel>
you may always be the bad guy, sure ;)
<phoe>
I mean, that's the case with C style macros, too, isn't it? if some code uses C style macros and the newly loaded shared object doesn't have the proper C symbols or the API has changed of the functions that are called as a result of macroexpansion, then stuff will break
<jackdaniel>
yes
<phoe>
it's not really specific to Lisp, even though Lisp has macros that are more advanced than just C preprocessor text operations
<phoe>
it doesn't matter in the end though, breakage can happen
<aeth>
jackdaniel: Your invoke-with-foo style probably would work for "anti-tivoization" libraries.
<aeth>
phoe: I thought, at the very least, that the intent of the LLGPL is that the user can replace the old version of $library_foo with a new version of $library_foo without recompiling the applications that use $library_foo.
<aeth>
Of course, at this point, it's best to talk about the intent, rather than license specifics (it would be amusing if this conversation eventually sparks the necessity for a GPLv4, though!)
<aeth>
s/the necessity/the need/
ldb has quit [Quit: Connection closed]
<aeth>
In a sense, CL makes it more possible to do this (upgrade a library without recompiling the user) than most languages.
<phoe>
aeth: reading this literally means that you can't really use macros or other compile-time features across module boundaries
<aeth>
phoe: right.
<phoe>
especially if they are useful in any way
<phoe>
...or that you need to bundle a compiler in your application that will solve this issue for you :D
<aeth>
Clearly, a good CL would track the users of macros and inline functions and recompile the user when the source is recompiled so nothing is stale.
<aeth>
Not quite in the spirit of "without recompiling", but, hey, CL is weird like that. The main thing is that the application itself doesn't need to know about it.
wxie has quit [Ping timeout: 244 seconds]
scymtym has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
edgar-rft has joined #lisp
iAmDecim has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
ayuce has joined #lisp
iAmDecim has quit [Ping timeout: 265 seconds]
jmarciano has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
jesse1010 has joined #lisp
<jdz>
aeth: Have you read the email thread about clisp's "adoption" of GPL?
jonatack has joined #lisp
<phoe>
the "CLISP being a derivative of GNU readline" one?
<phoe>
"If you do succeed in circumventing the GPL for readline, you would be blazing a path for every commercial company that wants to do it. Would you really like that result?
<phoe>
"
iAmDecim has joined #lisp
<xantoz>
isn't there non-GPL alternatives to readline these days, though?
<phoe>
companies did that anyway though
<phoe>
and the latter "can interfaces be copyrighted?" question turned into the famous Oracle vs. Google lawsuit
dddddd_ is now known as dddddd
Bourne has joined #lisp
rgherdt has joined #lisp
cosimone has joined #lisp
schweers` has joined #lisp
schweers has quit [*.net *.split]
cairn has quit [*.net *.split]
selwyn has quit [*.net *.split]
rme has quit [*.net *.split]
stylewarning has quit [*.net *.split]
jsatk has quit [*.net *.split]
heredoc has quit [*.net *.split]
winny has quit [*.net *.split]
gaze__ has quit [*.net *.split]
p_l has quit [*.net *.split]
travv0 has quit [*.net *.split]
funnel has quit [*.net *.split]
nopf has quit [*.net *.split]
heredoc has joined #lisp
rme has joined #lisp
selwyn has joined #lisp
jsatk has joined #lisp
stylewarning has joined #lisp
Krystof has quit [Ping timeout: 246 seconds]
cosimone_ has joined #lisp
cosimone has quit [Ping timeout: 244 seconds]
cairn has joined #lisp
p_l has joined #lisp
winny has joined #lisp
gaze__ has joined #lisp
travv0 has joined #lisp
funnel has joined #lisp
nopf has joined #lisp
p_l has joined #lisp
p_l has quit [Changing host]
travv0 has quit [Changing host]
travv0 has joined #lisp
winny has quit [Max SendQ exceeded]
winny has joined #lisp
scymtym_ has quit [Remote host closed the connection]
scymtym has joined #lisp
<ebrasca>
phoe: How much code can I use without having to use GPLv2?
jmarciano has quit [Read error: Connection reset by peer]
jmarciano has joined #lisp
luckless_ has joined #lisp
kaftejiman has joined #lisp
ebrasca has quit [Remote host closed the connection]
iAmDecim has quit [Ping timeout: 256 seconds]
luckless has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #lisp
igemnace has joined #lisp
treflip has joined #lisp
treflip has quit [Client Quit]
kaftejiman has quit [Remote host closed the connection]
jmarcian` has joined #lisp
jmarciano has quit [Ping timeout: 256 seconds]
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 264 seconds]
space_otter has quit [Remote host closed the connection]
ljavorsk_ has quit [Ping timeout: 246 seconds]
jonatack has quit [Ping timeout: 240 seconds]
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
gko_ has joined #lisp
wsinatra has joined #lisp
wsinatra has quit [Client Quit]
ebrasca has joined #lisp
cosimone has joined #lisp
wsinatra has joined #lisp
cosimone_ has quit [Ping timeout: 260 seconds]
jonatack has joined #lisp
wxie has joined #lisp
jmarcian` has quit [Read error: Connection reset by peer]
wxie has quit [Ping timeout: 265 seconds]
wxie has joined #lisp
<shka_>
hello
jmarcian` has joined #lisp
<shka_>
i want to use cl-store for serialization of class objects
<shka_>
so (cl-store:store (find-class ... kind of stuff
<shka_>
question: is this portable?
<Josh_2>
Afternoon all
bitmapper has quit [Ping timeout: 246 seconds]
michael` has joined #lisp
<michael`>
Does anyone know what's going on with the SBCL website?
<Alfr_>
shka_, portable for an implementation by itself, probably as cl-store claims to support it. The output being successfully read back in any other implementation than you created it with, most likely no. Btw. what do you expect to happen when you restore it?
Lycurgus has joined #lisp
<shka_>
i expect that i can (setf (find-class 'foo) ...
<shka_>
with that object
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
Bike has joined #lisp
iAmDecim has joined #lisp
<contrapunctus>
o/
<contrapunctus>
The cl-advice library seems to have vanished 😶
secretmyth has quit [Remote host closed the connection]
secretmyth has joined #lisp
dominic34 has joined #lisp
<beach>
Plazma: Why are you posting this link? I never click on a link until the person posting it gives a plausible summary of what I can expect if I click on it.
<beach>
Plazma: Furthermore, you seem to be new here. That's another reason for me to ask for an explanation. New people who start by posting links make me think of troll behavior.
dominic34 has quit [Remote host closed the connection]
dominic34 has joined #lisp
<beach>
Plazma: And if the phrase given in the link is accurate, then the entire thing is off topic, unless of course you wanted us to see anything particularly related to Common Lisp.
wxie has joined #lisp
secretmyth has quit [Remote host closed the connection]
secretmyth has joined #lisp
<Josh_2>
cringe, doesn't include lisp at 1958
<clothespin>
but it's totally accurate
<phoe>
Plazma: this is quality #lispcafe material
<phoe>
not #lisp material though
<Plazma>
Oh ok beach didn't have to be so rude though thank you for being nice phoe
<phoe>
Plazma: it's not really about rudeness
<phoe>
there's two reasons for this sort of reaction
<Gnuxie[m]>
This is such a garbage quality article too
<phoe>
one - #lisp is strictly on topic about CL whereas #lispcafe is not
<Plazma>
A little effort would show in anything but a troll
leo_song has quit [Ping timeout: 256 seconds]
<phoe>
two - there's people who somewhat frequently come and troll this channel
<Plazma>
I was just hang out because I wanted to learn more lisp for my quantum computing stufd
<beach>
Plazma: I wasn't trying to be rude. Just stating the rules.
<phoe>
Plazma: no problem with that
<Plazma>
Still kinda rude in how you railroaded me beach but phoe was very pleasant
<phoe>
no, I honestly think that posting a somewhat famous memepost about a history of programming languages as a greeting on #lisp is a very weird way of introducing yourself
<beach>
Plazma: Fine. I'll be quiet.
<Josh_2>
could be worse
<phoe>
especially since that post doesn't even mention lisp
<Plazma>
It was actually meant for another channel ..to be honestly
<clothespin>
i think that is the point plazma was trying to make
<phoe>
IMO a quick "woops, sorry, wrong channel" would do best, then
<phoe>
but anyway, I think the situation's clear now
leo_song has joined #lisp
<Plazma>
I didn't have time because beach kinda jumped on me..I mean I'm former freenide staff so it's unlikely I'd troll
iAmDecim has joined #lisp
<Plazma>
I spent far too much time dealing with them
<jackdaniel>
being pragmatically honest with explaining misbehavior is an act of kind guidance often mistaken for rudeness
<Plazma>
Also traveling a bit so on the phone I don't see the things and bits
<jackdaniel>
that's very ungrateful type of being kind
<Plazma>
I dunno phoe did it well that I understood and didn't make assumptions :)
<Plazma>
So thank you phoe
<Plazma>
You are a good person
<Josh_2>
Buttering you up good phoe
<Plazma>
Hah
<jackdaniel>
if irc were full of phoe"s the noise ratio would be higher due to roundabout ways of explaining mistakes and then praise etc
<Josh_2>
oof
wxie has quit [Ping timeout: 240 seconds]
<jackdaniel>
that's not a nitpick, rather an observation
<phoe>
Plazma: OK, thanks, let's keep #lisp on topic though
iAmDecim has quit [Ping timeout: 240 seconds]
<phoe>
jackdaniel is right that this has in total generated two or more screens' worth of talk that isn't really about Lisp and is just somewhat about #lisp
<Plazma>
Ok friends
schweers` has quit [Ping timeout: 244 seconds]
rpg has joined #lisp
|3b| has joined #lisp
<Plazma>
so do the lots of youmostly do lisp in emacs or use other tools/editors ?
skapata has joined #lisp
rgherdt has quit [Remote host closed the connection]
<phoe>
I use emacs and slime
skapata has quit [Remote host closed the connection]
<phoe>
slime is an emacs toolkit that provides connection to the running Lisp image, allowing for live code evaluation, function definition/redefinition, autocompletion, debugger, and such
<Plazma>
i remember slime from a long time ago
<Plazma>
it was abit much though for me at first
<ck_>
you should spend some time and read through the manual. It has excellent features, for example, take a look at its trace dialog
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
<shka_>
slime make lisp programming a lot easier
<shka_>
because of interactivity
<Plazma>
teh slime manual you mean? yea i tend to be try it , bang my head, bleed ab it, get exhausted, then read something .. not proud of it but alas
<Plazma>
trying to fix that about myself, but i've not done so well ,
<edgar-rft>
don't try to memorize all that stuff, learn it as you *need* it, it's much easier to remember then
<Plazma>
hmm,
<Plazma>
not to get too off topic but isn't hat counter intuiative to how a lot of things are taught and expected of folks to learn ?
<phoe>
I don't know; people are impossible to memorize large amounts of stuff at once anyway, so this advice seems sound to me
dmr0x80__ has joined #lisp
<phoe>
just start playing with it and then learn as you go, and ask questions, and say your personal doubts, and explore stuff and so on
X-Scale` has joined #lisp
dmr0x80__ has quit [Client Quit]
<Plazma>
fair enough
<Plazma>
i remember a lot of crusty C programmers were rude to me when i was learning and basically refusd to talk to me unless i went through K&R C and did every exercise or at least tried it, and said that was the only way..heh
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
<phoe>
#clschool exists for people who want to learn Lisp
<edgar-rft>
education theory is like statistics, teachers teach was is appropriate for the average student, but many people are just simply "unaverage" :-)
<Plazma>
edgar-rft: fair :D also most people who think they know statistics have no clue, and even those that do know it, don't that well :p
<Plazma>
phoe: damn you all got everything
<phoe>
Plazma: as I mentioned before, #lisp has a lot of history :D
kaftejiman has joined #lisp
iAmDecim has joined #lisp
<edgar-rft>
if you're un-average it makes not much sense to learn statistics, because it produces results that are pretty much useless for you
<Plazma>
(tell that to the television news people :P)
<phoe>
I bet that if you decide to start a television news people discussion on #lispcafe then people there will pick up the topic
<edgar-rft>
a) I worked for radio/television news for more than 30 years and yes, that's b) the reason why I don't listen to it
<Plazma>
phoe: apologies
<Plazma>
i was going to ask something about low level things possible in lisp but i realized i didn't google it yet
Alloc has quit [Ping timeout: 265 seconds]
<phoe>
depends on how low level
<edgar-rft>
Common Lisp is both, a high-level but also a surprising low-level language
<phoe>
if it's about accessing foreign memory, then that's mostly doable
ebrasca has quit [Remote host closed the connection]
Alloc has joined #lisp
<phoe>
if it's about inline assembly, that's tough but doable on some implementations
<Inline>
ecl
<Inline>
heh
<Plazma>
i can't recall if it has pointers or not,
<phoe>
standard Common Lisp doesn't have pointers on its own
iAmDecim has quit [Ping timeout: 264 seconds]
<phoe>
but there's a portabiility layer called CFFI that allows you to work with raw memory and with C libraries that access raw memory
<phoe>
it's usable in all modern CL implementations.
<Plazma>
so to make CL more functional would one need add on or libraries? i feel like as long as we avoid changing the original state we basically have a mostly functional language
<Plazma>
and do copy by value
<phoe>
sure, that's doable, CL is multiparadigm
<phoe>
if you avoid any mutating operations then you can write functional code in it
<Plazma>
i guess i'm wrapping my head around what/how functional code differs, and it seems as long as you don't mess with the original state and copy by value , then that's kinda the crux of it
<beach>
*sigh*
<phoe>
the output of a pure function depends only on its inputs
<phoe>
that's regardless of the language that you write the function in
<Plazma>
ahh ok
<phoe>
so it's not really Lisp-specific
<phoe>
the Lisp-specific part is that you can mix parts that are pure with parts that have side effects
<tychoish>
mutability is a cool feature but it's orthogonal. :)
<shka_>
functional has different meaning
<shka_>
s
<phoe>
welp
* phoe
should not do explaining when he's tired
<edgar-rft>
may I come up with the functional vs misfunctional joke?
<tychoish>
disfunctional
<beach>
That would be "dysfunctional".
<tychoish>
you're dysfunctional
<Plazma>
hah
<tychoish>
(kidding)
<phoe>
hey come on now that was rude
<phoe>
:(
<edgar-rft>
I'm not a victim of education theory so I'm spelling words like *I* want :-)
sjl_ has joined #lisp
<Plazma>
i feel like lisp would make a really good language for real/complex/functional analysis stuff too
<phoe>
you mean maths and/or logic?
<tychoish>
people have definitely done that kind of thing.
<phoe>
there's systems for that
<phoe>
ACL2 for theorem proving, Macsyma/Maxima for maths
<phoe>
and lots of other smaller pieces of software
<Plazma>
phoe: maths yes, i'm familiar with maxima/sagemath and gap
narimiran has quit [Ping timeout: 240 seconds]
<Plazma>
but i was meaning writing a cas in lisp or even for equation valuation
<Plazma>
granted there are better things out there that do that :D
<phoe>
CAS? what does that mean?
<beach>
Computer Algebra System
* phoe
is thinking compare-and-swap
<phoe>
oh yes, I see
bsd4me has joined #lisp
michael` has quit [Ping timeout: 272 seconds]
bsd4me has left #lisp [#lisp]
<edgar-rft>
acronyms are *good* :-)
iAmDecim has joined #lisp
<edgar-rft>
there are so many meanings to choose from
<beach>
minion: What does CAS stand for?
<minion>
Compositely Agaze Soldado
<Josh_2>
Thanks minion
treflip has joined #lisp
<Josh_2>
cleared that one right up! :P
<minion>
you're welcome
<beach>
minion: Thanks!
<Plazma>
oh yea computer algebra system sorry
AmatureProgramme has joined #lisp
iAmDecim has quit [Ping timeout: 264 seconds]
<edgar-rft>
Crappy Ass Shit
<Plazma>
also accurate
Lycurgus has quit [Quit: Exeunt]
skapata has joined #lisp
skapata has left #lisp [#lisp]
<shka_>
CLOSE AIR SUPPORT!
<Inline>
Can A Squirrel
<Inline>
lol
<sm2n>
maxima is a CAS written in lisp though
<Plazma>
what?
<sm2n>
as in, yes it is suitable
<sm2n>
there's a chapter in norvig's PAIP book on it
<sm2n>
though he doesn't get into the fancy stuff
<Plazma>
is scheme/scijp still considerd more of a educational tool?
<jackdaniel>
there is also a window manager called doors
<jackdaniel>
on admich github repository
<Inline>
hmmm
<Inline>
never heard of doors
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<Inline>
and what was gopher about again ?
<Inline>
i heard from but never used
IPmonger has joined #lisp
<jackdaniel>
it was about showing content instead of ads
<Inline>
i thought it's a network protocol first
<sm2n>
alternative www protocol basically
<Inline>
aah
<Inline>
ok then
<shka_>
Plazma: anyway, learning CL is not so daunting as it may appear, practical common lisp remains relevant book and although CL may look alien and weird it is actually a very well designed language with a well defined concepts (mostly), interactive approach also allows to make you effective use of your time
<sm2n>
vs http/html/css/js
<sm2n>
gopherspace is probably the most active it's ever been rn actually
<shka_>
also, to be honest, you don't need to know a lot of CL to write useful code
<sm2n>
and there's a successor protocol of sorts called gemini
<sm2n>
hm, I'm guessing no one has written a clim gemini client
<shka_>
so good luck and god speed :-)
<sm2n>
sounds like a good project
<Plazma>
shka_: cool, it seems i can compile it to a binary if i need like i would anything else, and it looks like it could be used for web stuff if i need it to be, etc
<jackdaniel>
if you have questions about clim, there is #clim channel
<sm2n>
I'm in it already
<sm2n>
but thanks
<sm2n>
seems someone wrote a gemini server in cl, but that's it
<sm2n>
from cursory search
<shka_>
Plazma: yes, CL is a flexible, general purpose language. It also has multiple implementations, including one running in the JVM.
iAmDecim has quit [Ping timeout: 256 seconds]
<Plazma>
cool
<shka_>
there is also ECL that compiles to C, which is good for C interop
<Inline>
armed bear common lisp
<Inline>
abcl
<shka_>
yeah
<Inline>
that's the one for the jvm
<Inline>
so you can combine java with
<Inline>
heh
<shka_>
so in summary, CL is still useful although people will look at you funny for writing it
Alloc has quit [Ping timeout: 265 seconds]
scymtym has quit [Read error: Connection reset by peer]
<Plazma>
shka_: yea and i think closure and other things have been used to write some successful commercial products too, so that's reassuring, despite the funny looks and chastiziation from others
<Inline>
would be good to scroll the screen in mcclim apps via keys
<shka_>
Plazma: lisp is one of those languages that was used in one form or another to tackle almost every problem in IT
<shka_>
so it is a well proven at least
jprajzne has quit [Quit: jprajzne]
<shka_>
anyway, I like Lisp, hopefully you will like it as well :-)
<shka_>
gotta go, nice to see new face here
<shka_>
you can join #lispcafe to write offtopic
<Plazma>
yea i' have been, thanks
bitmapper has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
scymtym has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.3)]
Josh_2 has joined #lisp
rumbler31 has joined #lisp
iAmDecim has joined #lisp
simendsjo has joined #lisp
iAmDecim has quit [Ping timeout: 260 seconds]
<Plazma>
assuming there is a way to do static typing with lisp if i wanted to?
mindCrime_ has joined #lisp
<Josh_2>
you can declare types
<beach>
I advise against type declarations, unless you are a very experienced Common Lisp programmer, and you know precisely what such declarations mean.
<Josh_2>
Need em for some extra speed and power xD
<beach>
Right, but newbies mess up the speed in oh so many more significant ways.
<Plazma>
fair enough, interesting it's dynamic and strong typed though
<Plazma>
but maybe not that weird
tiwEllien has joined #lisp
<Josh_2>
normally (declare (speed 3) (safety 1)) will get you plenty of speed and powaaaaa
<beach>
That's really bad advice to a beginner.
<Josh_2>
Hmm
<dra>
beach: Why?
<Josh_2>
Plazma: what I said should be a mental note, doesn't mean you should do it though
<beach>
dra: Because beginners mess up things like data structures, and micro optimizations aren't going to help that. It is much better to have a high debug setting and to concentrate on algorithmic complexity.
<dra>
beach: Thanks!
<beach>
dra: Then, when everything works, IF there is some bottleneck (which is not often the case), some select modules could benefit from micro optimizations.
<beach>
I do all my work with (speed 0) (compilation-speed 0) (safety 3) (debug 3)
<Plazma>
Josh_2: of course
simendsj` has joined #lisp
simendsjo has quit [Ping timeout: 240 seconds]
tiwEllien has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 272 seconds]
iAmDecim has joined #lisp
dra has quit [Quit: Leaving]
<sm2n>
makes a big difference for when you know your problem domain though
<sm2n>
I wrote a cpu raytracer recently, and without the declarations would've never gotten sweet sweet simd operations
<sm2n>
don't remember exact figures but I think the difference was on the order of a magnitude
<shka_>
numeric stuff is the one domain where it matters
<shka_>
BUT you can add type declarations later
<sm2n>
yup
<sm2n>
I didn't bother at first
<shka_>
for most of the development you don't worry about the speed anyway
iAmDecim has quit [Ping timeout: 256 seconds]
<shka_>
well, obviously you do worry, but that's about the design choices, not about the efficient code produced by the compiler
Oladon has joined #lisp
<sm2n>
there are good arguments against compiler optimization in general too
<sm2n>
basically, that the faster computers get, the larger portion of time is spent in tight loops
<sm2n>
hence optimization effort is wasted on code that isn't hot, and hot code is better hand optimized anyway
<Josh_2>
as long as you aren't producing software like electron I think It's okay
<sm2n>
pretty much
gko_ has quit [Ping timeout: 256 seconds]
Lord_of_Life_ has joined #lisp
kaftejiman has quit [Remote host closed the connection]
<Josh_2>
"Performance remains important for occasional hot spots:small segments of code applied to tons of data." I think this is a very important point
aeth has quit [Ping timeout: 240 seconds]
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<sm2n>
yeah, and I think this is the essential usecase for compiler macros?
mindCrime_ has quit [Ping timeout: 240 seconds]
<sm2n>
I guess you could do (speed 0) everywhere but use compiler macros for hot spots liberally
aeth has joined #lisp
<sm2n>
I want to try this now
<shka_>
sm2n: you can just (locally (optimize (speed 3)) ... in those few places where you want to inline memory access and stuff
<sm2n>
that's true
Alloc has joined #lisp
ralt has joined #lisp
Alloc has quit [Ping timeout: 244 seconds]
Alloc has joined #lisp
aleamb has joined #lisp
luckless_ has quit [Remote host closed the connection]
luckless_ has joined #lisp
EvW has joined #lisp
guile-guest39 has joined #lisp
guile-guest39 has quit [Remote host closed the connection]
simendsj` has quit [Quit: ERC (IRC client for Emacs 27.1)]
<rumbler31>
trying to build a standalone application. I know all the steps to produce standalone binaries, but I'm trying to figure out the best way to make this repeatable. Right now I only depend on plokami and usocket
simendsjo has joined #lisp
<rumbler31>
I need a funciton that will load those libraries into an image, define all the functions, then generate the binary.
<rumbler31>
quicklisp has a "dist snapshot" mechanism.
<rumbler31>
I'm mainly talking out loud here but also looking for some ideas
bilegeek has joined #lisp
<rumbler31>
it seems like if I go the quicklisp dist snapshot route, I'll be making a folder structure that I can check into source control where one folder are the dependencies, a make file calls the lisp image and evals a lisp file that loads the dependencies and defines the functions and then generates a new image. But it feels rather unlispy in that its not just another asdf package
orivej has joined #lisp
narimiran has joined #lisp
<phoe>
rumbler31: Shinmera's deploy
Inline has joined #lisp
<rumbler31>
phoe: thanks I'll look it up.
<rumbler31>
phoe: also thanks for your work on the online meetups
<phoe>
<3
<rumbler31>
while i'm at it, I'm trying to figure out a way as a user of a library to continue in the face of errors when calling a library function. For instane, with plokami, if the pcap file that is read has a truncated packet, an error is signaled during plokami:with-pcap-reader. I want to learn if its possible to pass "all the packets found so far" and simply ignore the error.
<phoe>
plokami should establish a restart that makes it possible
<rumbler31>
if I'm the library author I think I can use handler bind to make a restart, but if the library hasn't been written that way, how do I go about making my own ... restart
<phoe>
wait what
<phoe>
handler-bind doesn't establish restart
<rumbler31>
forgive me its been a long time since I played with restarts
<phoe>
restarts*
simendsjo has quit [Ping timeout: 240 seconds]
<phoe>
well basically
<rumbler31>
but in general its up to the library to provide the restart, I can't as a user sorta, make my own around the error?
contrapunctus has left #lisp ["Disconnected: closed"]
<phoe>
not in the general case
<phoe>
xristos: ^
<phoe>
would this be possible? how does libpcap behave in case of a corrupted file of sorts?
contrapunctus has joined #lisp
<phoe>
is it possible to only get the packets that were successfully read until the error?
<phoe>
if that's possible, then establishing such a restat would work
contrapunctus has left #lisp ["Disconnected: closed"]
<rumbler31>
I figured it out in this case actually
<rumbler31>
a handler case around the macro itself. the macro calls a line of code for each packet, in that line I push the results of the packet processing to a lexical variable. A handler case around the macro captures the error and returns the list that has been made already
<rumbler31>
but I guess I am lucky in the way the library author has exposes the functionality so I could do it this way, otherwise I guess I'd have to write my own restart in the library, right?
<xristos>
you don't have to use the macro
<xristos>
you can go a layer down
<xristos>
there are multiple apis exposed there, from as close to the C as you can get, to intermediate and a higher level ones in Lisp
vegansbane has quit [Read error: Connection reset by peer]
<xristos>
i need to find some time and push what i've actually been using for the last 10 years, which is a near complete rewrite
<xristos>
plokami works but it's old (first CL library I ever wrote and published)
<xristos>
and lacks a lot of new libpcap features
vegansbane has joined #lisp
justache has quit [Remote host closed the connection]
contrapunctus has joined #lisp
justache has joined #lisp
<rumbler31>
holy cow man
<rumbler31>
I was about to make a feature request to support another low level, uhm... packet format I forget what they're called. I think plokami can't read cooked captures
<rumbler31>
I'm basically using it right now as a poor man's udp replay tool
<rumbler31>
I've used it for sensor processing though, its come in handy, so thank you
akoana has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
<xristos>
for SLL, you can add the appropriate datalink type to pcap.lisp
<xristos>
that should do the trick, no other changes needed
treflip has quit [Quit: WeeChat 2.6]
<rumbler31>
I think I tried that and it didn't work but I'll try it again and see how far I get
cylb has joined #lisp
dominic34 has quit [Remote host closed the connection]
<sm2n>
woo I have clouseau running
<sm2n>
this is pretty nice
borei has joined #lisp
sjl_ has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
zazzerino has joined #lisp
<shka_>
sm2n: yeah, way better then a slime inspector
<shka_>
and can be specialized as well
<shka_>
it makes you think how nice it would be to have full IDE written the same way as that inspector
narimiran has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 240 seconds]
sjl_ has joined #lisp
aeth has joined #lisp
AmatureProgramme has quit [Quit: Leaving]
gaqwas has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
C-16 has joined #lisp
skapata has left #lisp [#lisp]
justache has quit [Remote host closed the connection]
justache has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
justache has quit [Remote host closed the connection]
justache has joined #lisp
AmatureProgramme has joined #lisp
kaftejiman has joined #lisp
TwoNotes has joined #lisp
aartaka has joined #lisp
TwoNotes has quit [Client Quit]
mindCrime_ has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
froggey has quit [Remote host closed the connection]
aartaka has joined #lisp
froggey has joined #lisp
MichaelRaskin has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
aartaka_d has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has quit [Ping timeout: 260 seconds]
froggey has quit [Remote host closed the connection]
froggey has joined #lisp
cosimone has quit [Quit: Quit.]
rumbler31 has quit [Ping timeout: 260 seconds]
bio__ has joined #lisp
tsrt^ has quit [Read error: Connection reset by peer]
iAmDecim has joined #lisp
paul0 has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
justache has quit [Remote host closed the connection]
justache has joined #lisp
tiwEllien has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
tiwEllien has quit [Quit: WeeChat 2.9]
zazzerino has quit [Remote host closed the connection]