schoppenhauer has quit [Ping timeout: 264 seconds]
earl-ducaine has quit [Read error: Connection reset by peer]
earl-ducaine has joined #lisp
damke_ has joined #lisp
schoppenhauer has joined #lisp
damke has quit [Ping timeout: 264 seconds]
aoeu has quit [Ping timeout: 260 seconds]
pyericz_ has quit [Quit: This computer has gone to sleep]
pyericz_ has joined #lisp
cmecca has quit [Ping timeout: 255 seconds]
jealousmonk has joined #lisp
epony has quit [Read error: Connection reset by peer]
Chream_2 has quit [Ping timeout: 264 seconds]
jealousmonk has quit [Read error: Connection reset by peer]
earl-ducaine has quit [Ping timeout: 256 seconds]
cibs_ is now known as cibs
DataLinkDroid has quit [Quit: Ex-Chat]
jealousmonk has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
jealousmonk has quit [Quit: Leaving]
arescorpio has quit [Excess Flood]
damke has joined #lisp
damke has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
damke_ has quit [Ping timeout: 264 seconds]
<beach>
pierpa: Thanks!
nika has joined #lisp
schoppenhauer has quit [Ping timeout: 264 seconds]
dtornabene has joined #lisp
damke has joined #lisp
schoppenhauer has joined #lisp
marusich has joined #lisp
<vtomole>
stylewarning: Just finished the noise paper, starting the Clifford paper. I'm not sure how many programmers are familiar with Group theory (I assume it's very little), so I like how you give a quick introduction to it. I do suggest that people read the noise paper first as it gives a short introduction to Quantum computing.
damke_ has joined #lisp
pyericz_ has quit [Quit: This computer has gone to sleep]
cmecca has joined #lisp
cmecca is now known as Guest62920
damke has quit [Ping timeout: 264 seconds]
<stylewarning>
actin
<stylewarning>
vtomole: thanks!
damke_ has quit [Ping timeout: 260 seconds]
<vtomole>
stylewarning: On the Clifford group paper section 2 where you list the Pauli matrices, should the Z matrix have -1 instead of i on it's bottom right index?
Guest62920 has quit [Ping timeout: 260 seconds]
ryanbw has quit [Remote host closed the connection]
iqubic has joined #lisp
iqubic has quit [Remote host closed the connection]
iqubic has joined #lisp
nalik891 has joined #lisp
<dtornabene>
curious if anyone knows of a way to programmatically create a postgres DB instance either from postmodern or another library
<dtornabene>
so far as I can tell postmodern leaves that up to you
Lord_Nig- has joined #lisp
Lord_Nightmare has quit [Ping timeout: 264 seconds]
Lord_Nig- is now known as Lord_Nightmare
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
iqubic has quit [Remote host closed the connection]
<stylewarning>
vtomole: wow, nice catch! I didn't notice the many times i looked
eschatologist has quit [Ping timeout: 276 seconds]
<vtomole>
stylewarning: Thanks. I also have to say, I love the fact that you have working code in these papers so I can whip up a REPL and play around. Most researchers put up pseudo-code or worse, don't post any code at all.
<stylewarning>
vtomole: I plan on publishing the more complete code
damke_ has quit [Ping timeout: 263 seconds]
H4 has joined #lisp
damke_ has joined #lisp
H4 has quit [Client Quit]
damke_ has quit [Ping timeout: 264 seconds]
damke has joined #lisp
<loke>
After having read a bunch of papers I'm stunned how they can pass peer review without iuncluding any code or data.
<pillton>
loke: In what field?
<loke>
pillton: Physics
<loke>
Also, some medical research.
<beach>
Code would probably be below their dignity.
damke_ has joined #lisp
<loke>
Yeah. Reproducibility isn't a thing.
<loke>
:-)
<pillton>
You assume that reviewers have the time to review the code.
<beach>
pillton: It is not just for them. It's for the general public.
<beach>
Without complete information, the experiments can't be reproduced.
<beach>
I had that problem with the International Computer Music Conference.
<beach>
There would be papers describing commercial, closed, code. Nobody could check their results.
<pillton>
You also have to consider an institutions attitude to intellectual property.
<beach>
Of course.
damke has quit [Ping timeout: 264 seconds]
<loke>
beach: IMHO, such papers shouldn't be allowed.
<beach>
pillton: But then they should not be published in a scientific conference.
<beach>
pillton: They get to choose one or the other, but not both.
<beach>
loke: Exactly!
damke has joined #lisp
<pillton>
Sure. I am in two minds about it. You have to cut corners a lot to make deadlines.
<beach>
pillton: How is that related?
<loke>
beach: I'm curious if this is a problem in CS. Remarkably, I haven't read many CS papers, and the ones I have read are mostly about functional programming research, where they usually implement a whole language. Those languages are mostly available, I think, but I've never looked at them. :-) (a lot of FP research is pure nonsense IMHO)
H4 has joined #lisp
<loke>
OK, I went off on a tnagent,m but my question is: Do CS papers ever not include code?
<pillton>
beach: Well, if you ask people to supply code, then you also have to accept the fact that the quality of the code will be low given the time constraints imposed by the paper deadline.
<loke>
pillton: The code isn't magically becoming higher quality if the code is not released.
<beach>
loke: Yes, many of them include just algorithms in pseudo code. Which is probably better anyway, since the specific language may obscure the results.
damke_ has quit [Ping timeout: 264 seconds]
<beach>
pillton: Oh, I see what you mean. But then, that gives the reviewer the opportunity to do a conditional accept, with code improvements being the condition.
<jackdaniel>
having vaguely phrased paper with a few benchmarks is not worth much (especially when you are unable to implement it yourself, because it is too vague), they are just a way to say: hey, look, we're doing some cool stuff
<loke>
I mean, look at Knuth. It's deservedly well regarded, and he releases his code. His code is absolutely terrible, but that doesn't take away from his accomplishments.
<pillton>
loke: That is my point. They probably don't publish the code because it is held together with Bandaids and duck tape.
lnostdal has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
<loke>
pillton: Well, that's not much different from about 99% of commercial software. :-)
nalik891 has quit [Ping timeout: 240 seconds]
<loke>
At least in the Enterprise world.
<jackdaniel>
and such statement doesn't require publication, they could have tweeted, that they are doing some "cool stuff" ;-)
<pillton>
loke: Yes, because the chain of command simply doesn't care.
H4 has quit [Client Quit]
<loke>
But that argument is similar to saying that “I have a beautiful proof for a^n+b^n=c^n, n<2 but the margin is too small”
lnostdal has joined #lisp
<beach>
loke: I am glad I am not the only one who considers Knuth's code to be absolutely awful. I am often surrounded by theoreticians who consider him a god, so I must be careful what I say in that presence.
damke has quit [Ping timeout: 264 seconds]
<loke>
Sure, the margin may be too small, and the code may be too ugly, but at least people didn't trust Fermat's assesment until Wiles game up with a proper proof
<loke>
beach: I've noted that most theoreticians find no joy in producing beautiful code.
<beach>
pillton: It is not a human right to have a paper published in a scientific journal or a scientific conference. If people are not willing to make the code good enough for the standards of the discipline, the journal or conference should have the full right to reject the paper.
<loke>
beach: They have the right. They're just no using it.
<pillton>
beach: Sure, but you would have to pretty much change the entire system as it is currently.
vlatkoB has joined #lisp
<beach>
pillton: I have colleagues who are working on that.
<beach>
I am close to retirement, so I don't care so much anymore.
<loke>
pillton: Not that such a change wouldn't be beneficial, but still, you can start slowly. I believe the movement for reproducibility is doing that.
damke has joined #lisp
<beach>
pillton: ACM is in it as well, and that's a good sign.
vtomole has quit [Ping timeout: 260 seconds]
<loke>
beach: SO you intend to retire?
<beach>
loke: Administratively, yes, at some point. I will have to. My activities will continue, though.
damke_ has quit [Ping timeout: 264 seconds]
epony has joined #lisp
<pillton>
loke: There are a lot of fields where reproducibility would require ethics approval.
lnostdal_ has joined #lisp
lnostdal has quit [Ping timeout: 265 seconds]
<loke>
pillton: That's a separate issue. CS and Physics definitely don';t.
<loke>
And the issue I had with medicine was mainly based on the software used to massage the data
fikka has joined #lisp
<loke>
“We used X to filter out irrelevant data points”. What's X? THey never say.
<pillton>
Don't get me started on the peer review process.
Guest62920 has joined #lisp
<jackdaniel>
"How to create evil AI?" :)
<loke>
I mean, I don't work in academia so my exposure to papers are when I read about something and I want to see the source. I have never been part of the process myself, but it doesn't take an expert to see when the content of a paper is lacking.
<loke>
Interestingly enough, I find older papers to be a lot better in many ways, especially in CS.
<loke>
They're at least much more clear.
<loke>
(it can be argued it was because the field was younger, and the topics were simpler?)
<loke>
But it's true even for Physics.
<White_Flame>
I agree. Looking through old LISP-era (sic) papers, they were great in the past
fikka has quit [Ping timeout: 264 seconds]
<White_Flame>
I wonder what the sheer volume of publication back then vs now is, and how much shovelware came from both times
<pillton>
White_Flame: Toilet paper is being produced at an alarming rate.
<loke>
White_Flame: I guess so? I heard that prominent researchers could spend several years on a single paper back then, but they have to pblish much more these days.
Guest62920 has quit [Ping timeout: 245 seconds]
vtomole has joined #lisp
fikka has joined #lisp
dessm has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 260 seconds]
slyrus_ has quit [Quit: Leaving]
wigust has joined #lisp
Karl_Dscc has joined #lisp
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
oleo has quit [Quit: Leaving]
marusich has quit [Quit: Leaving]
asarch has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
hhh47 has joined #lisp
hhh47 has quit [Client Quit]
fikka has joined #lisp
d4ryus1 is now known as d4ryus
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
slyrus_ has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 276 seconds]
fourier has joined #lisp
scymtym has quit [Ping timeout: 264 seconds]
Guest62920 has joined #lisp
fourier has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
Guest62920 has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
damke_ has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
damke has quit [Ping timeout: 264 seconds]
johnnymacs has joined #lisp
<johnnymacs>
What are the minimum functions that you need to implement a lambda calculus that can make any other lambda calculus
<johnnymacs>
in other words what are the minimum atoms to a lambda calculus
safe has quit [Read error: Connection reset by peer]
<Shinmera>
lambda
damke_ has quit [Ping timeout: 264 seconds]
happy-dude has joined #lisp
fikka has joined #lisp
<johnnymacs>
How can I encode a lambda expression as a list with integers in it
<TMA>
johnnymacs: unless you take the lisp-2 route where there is separate namespace for functions, then you will need funcall in addition to lambda
<White_Flame>
better to start with APPLY rather than FUNCALL; it'd be more flexible
<johnnymacs>
I am curious how I can serialize and deserialize lambdas
<johnnymacs>
like lets say I wanted to pass a lambda in json
Guest69321 has quit [Ping timeout: 268 seconds]
Guest69321 has joined #lisp
<TMA>
johnnymacs: well, you need to encode (1) a variable (2) an application (3) a lambda term;
<TMA>
johnnymacs: so for example (λu.u u) (λu.u u) would be: [2, [3, 1, [2, [1, 1], [1, 1]]], [3, 1, [2, [1, 1], [1, 1]]]]
<White_Flame>
a polish representation would be interesting
<White_Flame>
erm, polish notation
<White_Flame>
I think it would work as just 2 3 1 2 1 1 1 1 3 1 2 1 1 1 1
<TMA>
White_Flame: well, the parentheses could be unambiguously deduced from just the numbers
deng_cn1 has joined #lisp
<White_Flame>
I've done a few forward polish systems, and they're ridiculously easy to implement in common HLLs
deng_cn has quit [Ping timeout: 260 seconds]
deng_cn1 is now known as deng_cn
hiroaki has joined #lisp
Chream_ has quit [Ping timeout: 260 seconds]
epony has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
nullman` has quit [Ping timeout: 255 seconds]
damke_ has joined #lisp
nullman has joined #lisp
damke_ has quit [Ping timeout: 265 seconds]
SenasOzys has quit [Remote host closed the connection]
vlatkoB_ has joined #lisp
Guest62920 has joined #lisp
vlatkoB has quit [Ping timeout: 260 seconds]
Guest62920 has quit [Ping timeout: 264 seconds]
heisig has joined #lisp
chens has joined #lisp
chens has quit [Client Quit]
asarch has quit [Quit: Leaving]
Mental has joined #lisp
Mental is now known as _Mental
_Mental has quit [Client Quit]
Mental has joined #lisp
varjag has joined #lisp
Mental is now known as _Mental
damke_ has joined #lisp
nalik891 has joined #lisp
verisimilitude has joined #lisp
<verisimilitude>
I find the issue with academia to be all of the mental masturbationd and faculty fellatio; that is, most of academia has its head up its ass and is proud of it.
<White_Flame>
it's all about gaming the metrics
<White_Flame>
because judgment is bad, policy has taken over
<verisimilitude>
Yes.
<verisimilitude>
Someone's feelings could get hurt.
<verisimilitude>
Of course, academia's problems also involve malicious administrations and other woes that do anything but teach or progress.
<verisimilitude>
Let's not forget public research paying for private journals.
<verisimilitude>
I don't see much Lisp in academia, however.
<jackdaniel>
it is a very harsh opinion - is it because you work in academia or rather a peanut gallery judgement?
<verisimilitude>
That's private.
<verisimilitude>
Most of the academics seem to have realized playing with functional languages, producing useless results that ostensibly have practical benefits, leads to more papers.
<verisimilitude>
Regardless, jackdaniel, I will tell you that I've had many discussions about this with university professors I'm acquainted with.
<TMA>
I have pondered what's wrong with academia. I have come up with several possible hypotheses. (And no solutions.)
<verisimilitude>
I'm aware of universities that were planning to demolish their libraries so they could rebuild them and add coffee shops and other nonsense.
<verisimilitude>
Burn it to the ground, TMA.
<jackdaniel>
are they aware you consider them as pals having heads up their asses and being proud of it? or you kept it for yourself?
<TMA>
verisimilitude: that too, is not a solution, although it might feel satisfactory
* jackdaniel
gets back to his bugquest
<verisimilitude>
These particular people didn't, I wouldn't write, but many of them did and I'm not one to hide my disgust with others.
Cymew has joined #lisp
<verisimilitude>
Most of them did, in one way or another, however.
<verisimilitude>
Also, I never wrote they were friends.
<verisimilitude>
But, yes, I was very open about ``So and so is a stupid jackass and here's why.''.
<jackdaniel>
I'm not going to argue whenever academia is good or bad (I simply don't have enough information to judge), but I have a strong impression you are extremely rude person and it has nothing to do with honesty whatsoever
<verisimilitude>
Oh no, a rude Lisp programmer.
<jackdaniel>
rude person, I don't think status has much to do with it
vtomole has quit [Ping timeout: 260 seconds]
<verisimilitude>
My disgust extends beyond anything resembling an on-topic discussion here, so I won't delve further into it, but one need only look at the garbage being taught.
<verisimilitude>
Anyway, driving this back to Lisp, what have you all been working on lately?
fikka has joined #lisp
<verisimilitude>
Also, I don't want to paint myself in a bad light with you, jackdaniel; I'm typically only rude to people who deserve it and I don't know you at all.
SaganMan has joined #lisp
hhdave has joined #lisp
hhdave has quit [Client Quit]
<jackdaniel>
I know some people who work at universities and I'm sure they do not deserve this. I simply stated my opinion, that being rude is not something I'm fine with (disregarding of who you are). that said - this is indeed offtopic.
nalik891 has quit [Ping timeout: 245 seconds]
joh11 has joined #lisp
hhdave has joined #lisp
nalik891 has joined #lisp
hhdave has quit [Ping timeout: 265 seconds]
hhdave_ has joined #lisp
Guest62920 has joined #lisp
<Shinmera>
verisimilitude: Academia is off-topic. Please go to #lispcafe
damke_ has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
joh11 has quit [Ping timeout: 264 seconds]
Guest62920 has quit [Ping timeout: 268 seconds]
* beach
resists going to #lispcafe for this discussion.
<beach>
jackdaniel: I admire your patience.
pfdietz has quit [Ping timeout: 265 seconds]
deng_cn has quit [Ping timeout: 260 seconds]
deng_cn has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
pfdietz has joined #lisp
skbierm has joined #lisp
skbierm has left #lisp [#lisp]
hajovonta has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
<hajovonta>
hi
<beach>
Hello hajovonta.
eSVG has quit [Ping timeout: 276 seconds]
<phoe>
helloooo
kajo has joined #lisp
rotty has quit [Ping timeout: 260 seconds]
happy-dude has quit [Quit: Connection closed for inactivity]
playful-owl has joined #lisp
<phoe>
I joined mastodon. Find me at @phoe@functional.cafe.
oldtopman has quit [Quit: *pouf*]
damke_ has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
<Xof>
I missed an off-topic discussion I have opinions about! Oh no!
damke has quit [Ping timeout: 264 seconds]
<beach>
Yeah, me too. But in this case, I don't think facts will change the opinion of the initiator.
<beach>
I also think it was a case of misjudging the audience. Probably because that person is relatively new to #lisp.
<phoe>
I honestly don't care and would just nudge the discussion to #lispcafe if Shinmera wasn't there to do it before me.
<dtornabene>
stupid question time: I'm trying to use the sbcl repl and load postmodern ... and failing? I'm using the incantation shown in the quick reference of the postmodern docs and it doesn't seem to be working
<beach>
phoe: I am not trying to continue it. Just explaining to Xof.
<jackdaniel>
dtornabene: what is the failure error?
<jackdaniel>
how do you load postmodern?
Guest62920 has joined #lisp
<dtornabene>
i should note I used quicklisp to load it originally
<dtornabene>
jackdaniel: I'll grab it for you, just a sec
<phoe>
dtornabene: are you loading from a clean REPL?
<dtornabene>
jackdaniel: i figured it out, I had polluted the namespace and was getting symbol conflicts, by restarting the repl, thanks for checking, appreciated
agspathis has joined #lisp
<dtornabene>
hahaha
<phoe>
yep, exactly this
<dtornabene>
nice timing
<dtornabene>
yeah, thats exactly what it was
<jackdaniel>
happy to play your rubber duck ,p
<dtornabene>
thanks phoe
<dtornabene>
and jackdaniel
<phoe>
<3
rumbler31 has quit [Ping timeout: 255 seconds]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
<TMA>
dtornabene: have you perchance typed some expression ivolving db-null before the use-package?
<dtornabene>
not yet
<TMA>
dtornabene: ah, you found out before that you have poluted your namespace
<dtornabene>
TMA: i figured it out tho, symbol conflicts from a polluted namespace in the repl
<makomo>
does quicklisp expect that the filename of the ASD file is the same as the name of the system?
<makomo>
i have a file "irg-lab.asd" with two systems, "irg-lab1" and "irg-lab2". trying (ql:quickload :irg-lab1) or (ql:quickload :irg-lab2) fails
<makomo>
however, if i do (ql:quickload :irg-lab) i get an error, but then after then (ql:quickload :irg-lab1) and (ql:quickload :irg-lab2) work
<makomo>
it seems like the loading of :irg-lab (which corresponds to the filename of the asd file) loads the file and reads the systems, and then the following loads work?
<makomo>
what's going on?
<makomo>
is quicklisp weird or am i violationg asdf/quicklisp's conventions
<beach>
ASDF expects the system name and the file name to be the same.
<makomo>
ahh, that finally explains the previous weird behavior i had
<phoe>
except in file foo.asd you may define systems named FOO, FOO/BAR, FOO/BAZ, FOO/QUUX
<beach>
makomo: Otherwise, it would have to read very ASDF file on your computer to determine in which file the right system is located.
<makomo>
beach: yeah pretty much, i thought that was quicklisp's job. i mixed up the roles i guess
<phoe>
quicklisp only resolves and downloads the dependencies. the actual loading is ASDF's job.
<makomo>
i.e. quicklisp has a repo of dirs with asd files and it will go through all of them
<makomo>
mhm
<phoe>
all the .asd files are actually indexed by ASDF.
<makomo>
"through all of them meaning" reading them and seeing if there's a system of that name inside, but now that i think about, that would be weird
<makomo>
phoe: is the convention foo/bar necessary or was that just an example name?
<makomo>
i've also seen names like "foo.bar", "foo.baz", etc.
<makomo>
could you have the main system "foo" and then completely unrelated names such as "hello"?
fikka has joined #lisp
<phoe>
makomo: system named foo.bar needs to be declared in foo.bar.asd
<phoe>
the slash is required
<phoe>
the slash is required if you want to declare them in a single ASD file*
<makomo>
ahh, wow, never knew that
fikka has quit [Ping timeout: 276 seconds]
<jackdaniel>
because it is fairly new requirement
<jackdaniel>
(it doesn't bleed on the edge, but still :)
damke_ has quit [Read error: Connection reset by peer]
damke has joined #lisp
lnostdal_ has quit [Ping timeout: 264 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
Guest62920 has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
damke__ has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Guest62920 has quit [Ping timeout: 265 seconds]
damke has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
dddddd has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
damke has joined #lisp
damke__ has quit [Ping timeout: 264 seconds]
<mfiano>
phoe: There are open ASDF bugs regarding the slashes in names, so that shouldn't be relied on to work correctly. One was fixed a couple months ago, so about 2 years too soon for SBCL to care.
leighzi has joined #lisp
iqubic` has joined #lisp
iqubic has quit [Ping timeout: 245 seconds]
<jackdaniel>
ASDF codebase is above my personal cognitive horizon, I can never know if some fix won't break some other (unrelated) part
fikka has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
fikka has joined #lisp
<Younder>
jackdaniel, Is incorporating Climacs in McClim something any one is working on? I notice the Climacs webpage hasn't been updated for 10 years.
DataLinkDroid has quit [Quit: Ex-Chat]
quazimodo has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
<beach>
Younder: Climacs is already incorporated in McCLIM in that the part that is called Drei is used as an input editor.
Guest62920 has joined #lisp
<beach>
Younder: I am working on a new version of Climacs which much better support for editing Common Lisp code. That's the reason (first) Climacs is not being worked on.
fikka has quit [Ping timeout: 265 seconds]
<jackdaniel>
Younder: it could use some work, when I've tried it (installed climacs from quicklisp) it worked fine but had some errors at times (and/or glitches), don't remember exactly
<jackdaniel>
Drei also has its warts. If you plan to ponder these things I'd suggest starting with drafting a post about using Drei
<jackdaniel>
that should give you a nice understanding of how thigns work + you could fix some obvious bugs + community would benefit from it
<Younder>
thx, jackdaniel, beach for the heads up
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<jackdaniel>
when I'm done with this ECL iteration (I've just finished McCLIM iteration), I'll make some new bounties for McCLIM - if you have any suggestions please lmk on mail (i.e which bugs are most annoying etc)
<Xach>
makomo: for best results, the system name and the file name must match
damke has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
python476 has joined #lisp
fikka has joined #lisp
nalik891 has quit [Read error: Connection reset by peer]
nika has quit [Remote host closed the connection]
Nouv has joined #lisp
random-nick has joined #lisp
beach` has joined #lisp
beach has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
<jackdaniel>
makomo: it looks like some malicious site. it tried to spoof windows system installer to bait me clicking 'download windows repair tool' (and I have Linux)
<makomo>
jackdaniel: yeah lol, i posted it as a joke (but maybe i should have given a warning)
<makomo>
since i'm getting a compiler note "couldn't allocate space on stack", i went to google for it
<makomo>
and that's what came up :')
fikka has joined #lisp
beach` is now known as beach
dilated_dinosaur has quit [Ping timeout: 240 seconds]
dtornabene has quit [Quit: Leaving]
shka_ has joined #lisp
dilated_dinosaur has joined #lisp
agspathis has quit [Remote host closed the connection]
leighzi has quit [Quit: Leaving]
cylb_ has joined #lisp
Guest61466 is now known as kolb
jason_m has joined #lisp
Nouv has quit [Remote host closed the connection]
Doremus has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
<Doremus>
Hi everyone ! I work on a state of art about interoperability and i would know when (date and Common Lisp version) the first version of CFFI was release on Common Lisp ?
fikka has joined #lisp
dcluna has quit [Ping timeout: 268 seconds]
dcluna_ has joined #lisp
nullniverse has joined #lisp
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<Xach>
Doremus: cffi is from 2005
<Xach>
Doremus: what do you mean by "common lisp version"?
<Xach>
Common Lisp has one version from 1994
<random-nick>
also, cffi is just a compatibility layer, the real FFI is implemented by the implementation
schweers has quit [Read error: Connection reset by peer]
tomlukeywood has joined #lisp
schweers has joined #lisp
<Xach>
oh, good point.
<Doremus>
Xach: Thanks for the date of CFFI released. For the Common Lisp Version i thought there had been several versions but I was wrong apparently.
okflo` has joined #lisp
<Doremus>
random-nick: Yes, but i'm interested mostly by the concept of FFI which has been formulated with the CFFI lib... i supposed
milanj has quit [Read error: Connection reset by peer]
nmajo has quit [Ping timeout: 255 seconds]
lnostdal has joined #lisp
tomlukeywood has quit [Quit: tomlukeywood]
fikka has joined #lisp
<jackdaniel>
cffi lib just spanned a few implementations which have already existed
<jackdaniel>
if they existed then concept was already formulated
nirved has quit [Ping timeout: 256 seconds]
milanj has joined #lisp
lnostdal has quit [Ping timeout: 260 seconds]
pierpa has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
epony has joined #lisp
zbir` has joined #lisp
nmajo has joined #lisp
Guest62920 has left #lisp [#lisp]
fikka has joined #lisp
dmiles has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
nirved has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
lnostdal has joined #lisp
jason_m has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
dmiles has joined #lisp
hajovonta1 has joined #lisp
hajovonta has quit [Ping timeout: 264 seconds]
Lord_Nightmare2 has joined #lisp
shka_ has quit [Ping timeout: 260 seconds]
Doremus has quit [Quit: Page closed]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
hajovonta has joined #lisp
Lord_Nightmare has quit [Ping timeout: 264 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
siraben has joined #lisp
hajovonta1 has quit [Ping timeout: 256 seconds]
deng_cn1 has joined #lisp
deng_cn has quit [Ping timeout: 255 seconds]
deng_cn1 is now known as deng_cn
pierpa has joined #lisp
EvW has joined #lisp
okflo`` has joined #lisp
MasouDa has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
okflo` has quit [Ping timeout: 260 seconds]
zbir` has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<phoe>
Are the non-primary values correct? I don't think they should both be NIL because SBCL correctly found a compile-time error and printed information about it.
<hajovonta>
I'm working on a statistical library. I'm learning some basic and intermed statistic concepts, and recently I found that implementing ideas in Lisp is a great way to solidify my knowledge
<verisimilitude>
What manner of style warnings have you been receiving; SBCL can be quite bothersome with some of what it warns.
<verisimilitude>
In that case, I'll only lightly peruse the source, phoe.
<phoe>
verisimilitude: style warnings? What do you mean?
EvW has joined #lisp
<phoe>
I get all kinds of style warnings, usually when I screw something up in the code I write. The final code I produce hopefully has no style warnings altogether.
<verisimilitude>
TODO
<verisimilitude>
Take care of STYLE-WARNINGs when defining :FUNCTIONs.
<verisimilitude>
I've found that SBCL complains about perfectly good code, so this seems like something that may be difficult, depending on what you're doing.
<phoe>
oh, that's an old TODO - I think these were about FTYPE clobbering, I need to check if that TODO still remains there.
<verisimilitude>
Alright, then.
<phoe>
It's possible that I have to DEFGENERIC before I DECLAIM FTYPE because if I do it the other way, DEFGENERIC might overwrite the previously stated FTYPE with a new one.
<verisimilitude>
Would it be incorrect to think of ``protocol'' here as being synonymous with ``finite state machine''?
Kundry_Wag has quit [Read error: Connection reset by peer]
troydm has joined #lisp
<phoe>
A protocol is something that ties together data structures and operations.
<phoe>
It consists of things that can be operated on, and of operations that can be performed.
<phoe>
I don't think this is equivalent to a FSM since an operation may produce a completely new state each time it is invoked, theoretically.
<verisimilitude>
I figured I should've omitted the ``finite''.
Kundry_Wag has joined #lisp
<verisimilitude>
This is interesting, phoe, but since you've told me you'll be uploading a rewrite soon, I'll hold off on getting a good understanding of how this works.
<phoe>
The license will be LLGPL I think, so it's open for usage in any kind of commercial/noncommercial projects but requires its modified source to be published.
<verisimilitude>
Yes, I was having issues accessing that URL.
<verisimilitude>
Well, now I'm not, so I'll take a look.
<phoe>
Yep. That's a chapter from beach's upcoming book that I'm basing my library upon.
jibanes has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
<Josh_2>
beach is writing a Lisp book?
<phoe>
Josh_2: more than one AFAIK
jibanes has joined #lisp
<Josh_2>
ooooo
<verisimilitude>
Is the title yet solidified?
<Josh_2>
Should call it "Lisp on a beach"
<Josh_2>
Or "beaching Lisp"
<phoe>
beach: ^
<phoe>
verisimilitude: I don't know yet, maybe the author will be able to respond better.
<verisimilitude>
Alright.
joh11 has quit [Quit: Leaving]
nika has joined #lisp
cpc26_ has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
hajovonta has quit [Quit: hajovonta]
Danishman has joined #lisp
cpc26 has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
random-nick has quit [Quit: quit]
<verisimilitude>
I'm supposing, under this model, beach, that SETF forms its own protocol; with a brief glance, this would seem to violate your first restriction, but I suppose it's obvious how it doesn't.
blackwolf has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
random-nick has joined #lisp
beaky has quit [Quit: WeebChat 2.0]
Kundry_Wag has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
alfix has joined #lisp
rk[ghost] has quit [Quit: leaving]
pierpa has joined #lisp
alfix has quit [Client Quit]
warweasle is now known as warweasle_workin
rumbler31 has joined #lisp
BlueRavenGT has joined #lisp
happy-dude has joined #lisp
Guest69321 has quit [Read error: Connection reset by peer]
Guest69321 has joined #lisp
Karl_Dscc has joined #lisp
mrSpec has joined #lisp
mrSpec has quit [Changing host]
mrSpec has joined #lisp
cage_ has joined #lisp
antoszka has joined #lisp
SenasOzys has joined #lisp
nika has quit [Read error: Connection reset by peer]
nika has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
igemnace has quit [Ping timeout: 260 seconds]
<beach>
OK, almost finished with the slides for my second (and last) ELS talk. That should give enough time for my favorite coauthor to catch most of the remaining typos and such.
gingerale has quit [Quit: Don't worry, I'll return]
FreeBirdLjj has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
cage_ has quit [Quit: Leaving]
cage_ has joined #lisp
quazimodo has joined #lisp
lnostdal_ is now known as lnostdal
<phoe>
verisimilitude: its own protocol? how?
<phoe>
#'FOO is an operation, #'(SETF FOO) is another operation
fikka has quit [Ping timeout: 240 seconds]
<phoe>
the macro SETF in this case is just a tiny wrapper around #'(SETF FOO) that makes sure the arguments are only evaluated once and in proper order; otherwise, everything else is delegated to the function #'(SETF FOO)
siraben has quit [Ping timeout: 260 seconds]
figurehe4d has quit [Remote host closed the connection]
<phoe>
beach: I really like the way you do graphs. The "after two steps", "after three steps", "after four steps" approach is really fun when you view them in fullscreen and can just compare them one after another.
<beach>
phoe: Thanks.
<beach>
phoe: I use a very old program, namely Xfig. Then I copy the figure of one step to the figure of the next, and make some small modifications to the copy.
<beach>
That way I am sure they pretty much align.
<phoe>
beach: I see.
fikka has joined #lisp
<beach>
Probably not optimal, but it works for me.
FreeBirdLjj has joined #lisp
<phoe>
beach: locally optimal, for sure. (:
rumbler3_ has joined #lisp
<beach>
Heh, sure.
SaganMan is now known as LookoutBoy
nowhereman_ has quit [Ping timeout: 256 seconds]
jack_rabbit has joined #lisp
nika_ has joined #lisp
nika_ has quit [Client Quit]
<verisimilitude>
I was combining SETF and the (SETF ...) functions, phoe.
nika_ has joined #lisp
<phoe>
verisimilitude: what exactly do you mean?
<verisimilitude>
I'll explain.
nika has quit [Ping timeout: 260 seconds]
EvW has quit [Ping timeout: 276 seconds]
rumbler3_ has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 268 seconds]
beaky has joined #lisp
<verisimilitude>
So, at a casual glance, one may think that the protocol {CONS, CAR, CDR} would violate that first rule with {(SETF CAR), (SETF CDR)}, but I thought it made sense that SETF and functions meant to be called by it could form an independent protocol that merely used some of the same symbols.
varjag has joined #lisp
<verisimilitude>
Does {SETF} alone compose one protocol, under this model, instead?
<phoe>
I don't think so
<phoe>
You could, for example, do a protocol that has {CONS, CAR, CDR, RPLACA, RPLACD} I think
<phoe>
Which is equivalent to {CONS, CAR, CDR, (SETF CAR), (SETF CDR)}
hhdave_ has quit [Ping timeout: 260 seconds]
Naergon has joined #lisp
<phoe>
In this model, (SETF FOO) is just Yet Another Operation, just with a slightly more funny name.
<verisimilitude>
Wouldn't that mean the protocol {CONS, CAR, CDR} is just as incomplete as {CONS, CDR}, compared to {CONS, CAR, CDR, RPLACA, RPLACD}?
<phoe>
depends on your definition of "incomplete"
<phoe>
a protocol is complete when no data is "loseable" within it
<verisimilitude>
The first two are from the document.
<verisimilitude>
The last one, however, adds fundamental operations the first lacks.
<phoe>
define "fundamental operations"
<phoe>
the first one is functional, the last one is mutative
<phoe>
in some cases, you are forbidden from mutating anything. Like, (defmacro foo (&whole whole) ...) - the WHOLE argument must not be modified.
igemnace has joined #lisp
<verisimilitude>
It's an operation you can't otherwise perform, changing the CAR or CDR of a CONS.
<phoe>
you can traverse that argument by means of the protocol {CAR, CDR}.
<phoe>
Yep. If your protocol states that you must be able to modify parts of a cons cell, then you need operations for that.
<verisimilitude>
It's a fundamental operation of the CONS.
<phoe>
Depends.
<phoe>
Depends on whether you need to be able to mutate cells, or if you do not need it.
<phoe>
If you need mutability, then {CONS, CAR, CDR} will not be enough for you.
<phoe>
If you do not need mutability, then {CONS, CAR, CDR, RPLACA, RPLACD} contains unnecessary operations.
pierpa has quit [Ping timeout: 260 seconds]
warweasle_workin is now known as warweasle
<verisimilitude>
It's been in Lisp since the early beginnings, which I'd think solves the design argument of it.
<phoe>
You try to raise an argument here that a cons cell *MUST* be mutable. No, it does not have to be.
<phoe>
It often is, it often is not. The CL standard has many cases in which mutating a cons cell invokes undefined behavior.
<phoe>
So there essentially need to be two protocols for dealing with cons cells - for immutable conses, and for mutable conses.
<Bike>
are you arguing about this pdf that's about the concept of a protocol
<phoe>
Bike: more or less, yep.
<phoe>
For immutable ones there's {CONS, CAR, CDR}, for mutable ones there's {CONS, CAR, CDR, RPLACA, RPLACD}.
pierpa has joined #lisp
<verisimilitude>
Wouldn't that then violate the first rule of these protocols, phoe?
fikka has joined #lisp
xaotuk has quit [Quit: WeeChat 2.0.1]
fikka has quit [Ping timeout: 276 seconds]
cage_ has quit [Read error: No route to host]
cage_ has joined #lisp
mflem has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
k-stz has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
pfdietz has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
<pfdietz>
Another aspect: do CONS have object identity? Yes if mutable, but what about immutable? EQ vs. EQUAL.
deng_cn has joined #lisp
Kundry_Wag has joined #lisp
jack_rabbit has quit [Ping timeout: 245 seconds]
agspathis has joined #lisp
attila_lendvai has joined #lisp
pfdietz has quit [Ping timeout: 245 seconds]
sjl has joined #lisp
<verisimilitude>
Since EQ, EQUAL, et al. work with T, it would seem they fit in their own protocol rather well, under this model.
jack_rabbit has joined #lisp
<verisimilitude>
What do you think of all of this, beach?
fikka has quit [Ping timeout: 255 seconds]
LookoutBoy is now known as e^i
asarch has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
MasouDa has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
H4 has joined #lisp
H4 has quit [Client Quit]
fikka has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
fikka has joined #lisp
janivaltteri has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
anon has joined #lisp
Kundry_Wag has joined #lisp
anon is now known as Guest86264
Kundry_Wag has quit [Remote host closed the connection]
Guest69321 has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Quit: Page closed]
attila_lendvai has joined #lisp
<phoe>
Hmmmm
<Josh_2>
mmmmH
<phoe>
As for the first rule of the protocols... Hm.
<phoe>
That would indeed be a case.
H4 has joined #lisp
<phoe>
beach: since operations CONS, CAR, CDR are mentioned in the protocol called "ANSI Common Lisp standard", are we able to construct any other protocol that contains these operations?
<phoe>
Namely, are you able to construct the protocol ω = {CONS, CAR, CDR} mentioned in 5.4?
fikka has joined #lisp
H4 has quit [Client Quit]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
<jackdaniel>
given cool topics you talk about probably nobody will be interested in me working on testing framework? (not unit test framework but rather CLIM application to manage test plans - similar to teslink in spirit)
fikka has quit [Ping timeout: 264 seconds]
* jackdaniel
just read the backlog
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
MasouDa has joined #lisp
fikka has joined #lisp
<beach>
phoe: "ANSI Common Lisp standard" is not a single protocol according to my definition.
fikka has quit [Ping timeout: 264 seconds]
Chream_ has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
<makomo>
what exactly can you do with a vector that's adjustable but doesn't have a fill pointer?
Kundry_Wag has quit [Remote host closed the connection]
<beach>
makomo: You can make it bigger or smaller. Say you implement a stack with an adjustable vector, then you can grow the vector when it is full and shrink it when it is not full enough.
<verisimilitude>
There's a certain pleasure in building reusable software, but one can't always do this; there comes a point when things are simply better very tightly integrated.
<verisimilitude>
What do you think?
<makomo>
_death: beach: i see. adjust-array was what i needed to get me going, thanks
H4 has joined #lisp
<verisimilitude>
If you don't tightly integrate it, you tend to find yourself building ostensibly reusable software that will only ever be passed the same arguments, achieving the same thing in a roundabout manner.
fikka has joined #lisp
H4 has quit [Client Quit]
<jackdaniel>
approach good as any other. if it matches problem domain well (i.e I don't feel urge to extend kettle controller)
agspathis has quit [Remote host closed the connection]
<jackdaniel>
then it is fine. adding extensibility for a sake of being able to extend software doesn't make much sense to me.
<verisimilitude>
In the specific case I have in mind, with relation to what I've been programming, it's an end software; I actually found myself rewriting it once, because it wasn't tightly integrated enough.
<jackdaniel>
I like how PG put it in one of his essays: you grow language towards your application
<jackdaniel>
and then you write a simple interface for your newly written language (which probably matches what you call "end software")
<jackdaniel>
s/for your/of your/
<jackdaniel>
s/interface/client/
megalography has joined #lisp
attila_lendvai has quit [Ping timeout: 260 seconds]
nika_ has quit [Quit: Leaving...]
ckonstanski has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 255 seconds]
tomlukeywood has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
quazimodo has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
quazimodo has joined #lisp
fikka has joined #lisp
tomlukeywood has quit [Quit: tomlukeywood]
Kundry_Wag has joined #lisp
damke_ has joined #lisp
attila_lendvai has joined #lisp
damke has quit [Ping timeout: 264 seconds]
hiroaki has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
verisimilitude has quit [Remote host closed the connection]
deng_cn has quit [Ping timeout: 255 seconds]
deng_cn has joined #lisp
nmajo has quit [Ping timeout: 246 seconds]
verisimilitude has joined #lisp
hiroaki has joined #lisp
verisimilitude has quit [Remote host closed the connection]
fikka has joined #lisp
cage_ has quit [Quit: Leaving]
rumbler31 has joined #lisp
ghard``` has joined #lisp
pierpa_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
shwouchk_ has quit [Quit: Connection closed for inactivity]
nmajo has joined #lisp
verisimilitude has joined #lisp
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
Cymew has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
Arcaelyx_ has joined #lisp
Kundry_W_ has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
scymtym has quit [Remote host closed the connection]
flip214 has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 264 seconds]
Arcaelyx has quit [Ping timeout: 265 seconds]
okflo`` has quit [Remote host closed the connection]
dxtr_ has joined #lisp
flip214 has joined #lisp
flip214 has joined #lisp
flip214 has quit [Changing host]
Kundry_W_ has quit [Ping timeout: 264 seconds]
dxtr has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
jstypo has quit [Quit: I think, therefore I drink]
<aeth>
Imo, start concrete and then abstract from there or you'll write abstractions that you'll never need (not even once!).
<aeth>
Refactor continuously and eventually you'll get the right level of abstraction
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Cymew has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
<aeth>
I think it's extremely easy in CL to write code that's too clever or too abstract. Nothing's worse than M-.ing through someone's extremely clever, hundreds-of-lines, undocumented macro.
<TMA>
on the other hand sometimes a more general version of a problem is easier to solve -- but that still needs a concrete problem to begin with
<Bike>
what is bringing this on or is it an example of itself
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
<TMA>
in my case it is a setter that is in fact a toggler; it is something like (defun set-x (object &optional (new-val (not (get-x object)))) (unless (eq (get-x object) new-val) ...))
Kundry_Wag has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
<TMA>
a general setter would just do the setting, bolting the toggling over that is simple and more to the point than to try do 2-in-1
Kundry_Wag has quit [Ping timeout: 260 seconds]
<aeth>
Speaking of toggling, what's the best way to toggle between 1 and 0 (for APIs that expect 1 or 0 instead of true and false)? This? (mod (1+ foo) 2)
<_death>
(logxor x 1)
karswell has quit [Remote host closed the connection]
karswell has joined #lisp
<aeth>
Oooh, they have different disassemblies in SBCL
<aeth>
(mod (1+ foo) 2) does the usual (mod some-integer some-power-of-2) trick and logxor obviously uses XOR
<Xach>
lisp is a portable assembler
<aeth>
The xor is the faster toggle-bit, especially when the number to toggle is 1 instead of 0. This is not surprising.
<aeth>
And when optimizing speed 3... it uses one fewer instruction
<verisimilitude>
Why would you not use LOGNOT?
<verisimilitude>
Ah, that's why.
<verisimilitude>
Oh well.
<aeth>
verisimilitude: I think xor is one of the fastest asm instructions for Intel? I could be wrong.
<verisimilitude>
I wouldn't know.
<aeth>
verisimilitude: and as for lognot: (let ((x 0)) (lognot x)) => -1
<verisimilitude>
Yes, that's why.
<aeth>
Xach: Imo, Lisp is much more suitable for low level performance hacks using logical operators. In C, you get unreadable code. In CL, just make it a function declared inline. I guess in C, you could do the same thing and the optimizer would automatically inline it, but it's not idiomatic C.
damke has joined #lisp
<aeth>
(Of course, in C, I guess you'd just use ! so in this case it doesn't matter.)
<random-nick>
in C, you can also make a preprocessor macro :^)
<Bike>
i kind of doubt you need to worry about which alu operator is faster...
<aeth>
random-nick: yeah, but that's a holdover from the days when compilers were dumb. The function should be inlined by a smart enough C compiler.
Josh_2 has quit [Read error: Connection reset by peer]
<verisimilitude>
I've read some benchmarks, aeth, that I believe show you can get good performance if you're exclusively XORing registers, but that's hardly useful or a realistic program.
nmajo has quit [Remote host closed the connection]
<aeth>
random-nick: you're right, though, that if someone did any abstraction at all they'd use a preprocessor macro for it, though
damke_ has quit [Ping timeout: 264 seconds]
<verisimilitude>
On that topic, I do find it queer in a way for processors to offer certain logical operations, such as, say, shifting.
<verisimilitude>
It would be better to simply have a multiply and divide that are optimized if the number is a power of two, as an example.
<aeth>
verisimilitude: Whenever there's something that doesn't seem right it's probably because of backwards compatibility forever.
<verisimilitude>
I simply meant in a fresh design.
<aeth>
Making it easier to port existing compilers, then?
pierpa has quit [Ping timeout: 260 seconds]
<verisimilitude>
What?
<verisimilitude>
Also, this isn't too bad, considering what SBCL produces:
<verisimilitude>
(if (zerop (the unsigned-byte n)) 1 0))
<verisimilitude>
(declare (unsigned-byte n))
<verisimilitude>
(lambda (n)
<verisimilitude>
This is clearly resembling the optimal if you need a relation the LOG functions don't provide.
<phoe>
verisimilitude: you don't need THE if you have DECLARE
<aeth>
verisimilitude: not quite the same thing, though, I was talking about something defined as a bit
damke has quit [Ping timeout: 264 seconds]
<aeth>
more assumptions can be made
megalography has quit [Ping timeout: 240 seconds]
<verisimilitude>
I know, phoe.
<verisimilitude>
Formatting wise, I suppose removing the DECLARE would be better, since it would then fit on just one line.
gingerale has joined #lisp
<verisimilitude>
Alright.
<aeth>
verisimilitude: Although perhaps it's better to not assume that it's a bit, if it's an inline function that's used in general.
<aeth>
If it's a public function somewhere someone along the line is going to pass in 2 or something
damke has joined #lisp
nmajo has joined #lisp
gingerale has quit [Quit: Don't worry, I'll return]
<verisimilitude>
Anyway, what are you working on lately, aeth?
dyelar has quit [Quit: Leaving.]
damke_ has joined #lisp
rumbler31 has joined #lisp
gingerale- has joined #lisp
gingerale- has quit [Client Quit]
<aeth>
A game engine.
gingerale has joined #lisp
<verisimilitude>
Is the current state of the source publicly available anywhere?
<verisimilitude>
Is this similar to Xelf?
damke has quit [Ping timeout: 264 seconds]
<aeth>
It's afaik extremely different than the existing engines out there.
<aeth>
Its focus is high-performance 3D, and it does not have any detectable runtime allocations in the engine itself. It's obviously very incomplete.
anon has joined #lisp
<aeth>
Because it's a large project, the source is full of things that I thought were good ideas years ago that aren't. So there's rarely any forward progress.
anon is now known as Guest6423
Guest86264 has quit [Ping timeout: 256 seconds]
<verisimilitude>
Have you considered a rewrite, then?
<aeth>
I'll never rewrite it again. It's the third or so rewrite.
python476 has quit [Ping timeout: 256 seconds]
<aeth>
It's modular enough that I can rewrite small parts of it as needed without needing large changes.
rumbler31 has quit [Remote host closed the connection]
<verisimilitude>
I take it that probably wasn't the case with the first iteration.
megalography has joined #lisp
Guest6423 has quit [Ping timeout: 264 seconds]
<aeth>
I probably could have made that work, but the architecture was all wrong.
ddrbt has joined #lisp
Karl_Dscc has quit [Ping timeout: 256 seconds]
<aeth>
What I currently have is, for the most part, pretty low level. Although I have one of those very elaborate, undocumented macros that I was criticising earlier to cover up a lot of that.
ddrbt has quit [Client Quit]
<aeth>
It's definitely not a style you'd want to use for CL outside of real time programming.
Cymew has joined #lisp
nowhereman_ has joined #lisp
<verisimilitude>
Is it in a state you believe others would be able to use it?
<aeth>
Absolutely not. My approach is heavily integrated, which means that I have to have rough, buggy, entirely incomplete implementations for many systems that have to be there in order to have something running, even though they're nowhere near suitable, e.g. the physics. The stuff that I can skip entirely (e.g. sound) are things that I do not have at all, currently.
<aeth>
Interestingly, even though it's a 3D engine, it's probably most usable for 2D, because you can abuse the 2D HUD and 2D doesn't really need to be that efficient, anyway.
Josh_2 has joined #lisp
rumbler31 has joined #lisp
<verisimilitude>
It's my understanding that modern hardware can more efficiently manipulate flat 3D than 2D, anyway.
Kundry_Wag has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 265 seconds]
Guest6423 has joined #lisp
Cymew has joined #lisp
<aeth>
Well, the 2D hud is just an orthographic projection overlayed in front of the 3D world iirc.
<aeth>
So just texture a bunch of squares and you have something.
<aeth>
3D would need animation, lighting, collision, physics, etc. Although you can cut out collision and (most) physics if you do a game where you control units indirectly via pathfinding afaik, like an RTS.
<verisimilitude>
Yes.
<verisimilitude>
I've always found issues when using Common Lisp programs that use the CFFI or whatnot.
<aeth>
It depends on the wrapper.
<verisimilitude>
I've not been able to experiment with qtools, as an example, since it wants an openssl shared library, for whatever reason.
<aeth>
I have no issues whatsoever with cl-opengl, which directly uses cffi. I have had nothing but issues with cl-sdl2, which uses autowrap.
random-nick has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 240 seconds]
<verisimilitude>
Installing both of openssl and libressl did nothing to correct this, of course, and so I lost interest once again.
<rumbler31>
verisimilitude: guess, that qtools will download a qt installation if necessary
<Shinmera>
It wants OpenSSL to download Qt securely
pmc_ has joined #lisp
Cymew has joined #lisp
<Shinmera>
Either way, if it doesn't work that's on CL+SSL, not Qtools.
<pmc_>
in ANSI Common Lisp by Graham, the following line is given: (set-macro-character #\} (get-macro-character #\))) How does Graham know that the function associated with right parenthesis is the function he wants associated with } right curly bracket? What does that function do?
<Shinmera>
It signals an error.
<Shinmera>
This works because the opening paren reads a full expression, including the closing paren.
<Shinmera>
Which in turn means the macro character for the closing paren only gets invoked if its found astray without a matching open paren
<verisimilitude>
There's a copy of the document, if you'd want more detail, pmc_.
<pmc_>
cool, thanks!
Cymew has quit [Ping timeout: 276 seconds]
Cymew has joined #lisp
<verisimilitude>
It's interesting to have a discussion with you, Shinmera; I've seen your work around, but never discussed anything with you before.
<verisimilitude>
Did you have issues having your programs added to Quicklisp?
<Shinmera>
No.
scymtym has joined #lisp
<verisimilitude>
That's interesting.
<Shinmera>
Why?
<verisimilitude>
I've been having issues with this for months, since December.
<verisimilitude>
I've corrected issues as they've been told to me, such as having the programs available as a single file that decompresses into its own directory, but I've still yet to have them added.
Cymew has quit [Ping timeout: 260 seconds]
<verisimilitude>
Apparently, I'm the first person to attempt to have his programs uploaded to Quicklisp pseudonymously, which Xach wanted time to mull over.
shka_ has joined #lisp
<verisimilitude>
I'd use email, but gmail blocks independent servers unless they jump through hoops; I won't use github; and that leaves me with #quicklisp, which is very inactive.
Cymew has joined #lisp
damke has joined #lisp
<Josh_2>
What about gitlab?
Kundry_Wag has joined #lisp
megalography has quit [Ping timeout: 256 seconds]
<Bike>
xach organizes the project list on github
damke_ has quit [Ping timeout: 264 seconds]
<pierpa_>
aeth: (- 1 x)
<aeth>
pierpa_: that is clever
Cymew has quit [Ping timeout: 255 seconds]
<verisimilitude>
I wasn't aware it was on gitlab, Josh_2, but I'd really prefer to not make an account at all.
zmt00 has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Ping timeout: 260 seconds]
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 256 seconds]
janivaltteri has quit [Quit: leaving]
<pierpa_>
aeth: no, is as little clever as possible! :)
Bike has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
<pierpa_>
(and note that the same trick can be used for alternating between any two values, not only 0 and 1)
<Josh_2>
I gotta write a program that uses gpu/cpu parallelisation but am not sure what to do, I've got to have atleast 3 threads and two different thread functions
<verisimilitude>
What will this program do?
<Josh_2>
and have shared resources using mutexes atomic operations or barriers and some signalling as well
<Josh_2>
idk
Cymew has quit [Ping timeout: 265 seconds]
<verisimilitude>
That's not a good sign.
<Josh_2>
I have no idea what to do that's why I'm asking
<Josh_2>
it's gpu or cpu, or both
<phoe>
you have to write a program that uses threads and mutexes for the sole purpose of using threads and mutexes?
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
<Josh_2>
uhmm well I gotta write a program that uses them
<phoe>
why?
Cymew has joined #lisp
<verisimilitude>
So, this is for some class?
<Josh_2>
Yeh it's for class
deng_cn has quit [Read error: Connection reset by peer]
<Josh_2>
as a note I did my last semesters work in CL and I got a 4.5 :P
<verisimilitude>
That's nice.
<_death>
you can implement a classic problem like dining philosophers..
<verisimilitude>
Why don't you write a CS class simulator?
deng_cn has joined #lisp
<verisimilitude>
You can have one thread bother another thread, while another thread does all of the actual work, separately.
<phoe>
_death: I thought of that but it won't be trivial with 2+ thread functions
<Josh_2>
Dining philosophers was part of one of the lectures
<phoe>
since each philosopher is an instance of the same function
milanj has quit [Quit: This computer has gone to sleep]
kajo has quit [Quit: WeeChat 2.1]
shka_ has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
<aeth>
Are there any restrictions? There are some mathematical things where threads help a ton, e.g. certain Project Euler problems.
<verisimilitude>
Perhaps you'd, instead, find more utility building a parallel WWW scraper, Josh_2; I've done this before, for my own purposes, and it's very simple.
<Josh_2>
There are no restrictions on what I can make, only time
<Josh_2>
I have until the end of this month
Cymew has quit [Ping timeout: 240 seconds]
<aeth>
I'd personally do something mathematical, then.
<_death>
phoe: the solution may involve an instance of another kind.. and the gist is that there are well known problems to choose from
<verisimilitude>
I simply generate what is to be scraped ahead and time, randomize it, and then give each thread a piece of this to process.
<Josh_2>
That sounds like a good idea, but why would they need to communicate
<verisimilitude>
You could, instead, use a lock on a procedure that generates the next piece to use, if you want to use a lock.
<verisimilitude>
Who are you asking?
<Josh_2>
Well I have to have shared resources
<verisimilitude>
Well, the second approach would work for that, then.
Cymew has joined #lisp
rumbler31 has quit [Ping timeout: 265 seconds]
LiamH has quit [Quit: Leaving.]
pierpa_ is now known as pierpa
<verisimilitude>
So, you think you'll do this, Josh_2?
<Josh_2>
Yes it sounds like an interesting project
<Josh_2>
and I can think of lots of places where parallelisation can be used
<Josh_2>
can use threads to pull sites simultaneously and threads to analyse the downloaded site
<pierpa>
this would be 'embarassingly parallel' with no shared resource
Cymew has quit [Ping timeout: 260 seconds]
<Josh_2>
well the site downloaded could be the shared resource and then the threads could access as needed
<verisimilitude>
Use DRAKMA's HTTP-REQUEST for the downloading; I've not dug into its internals much, but you shouldn't have issues.
<pierpa>
hmmm
<verisimilitude>
I'm glad to have helped, then, Josh_2.
Cymew has joined #lisp
<_death>
another classic problem is that of producers and consumers.. the shared resource would be the buffer used for holding messages
milanj has joined #lisp
<Josh_2>
or in this case I could build the downloaded site into a buffer and then use threads to access the other end?
kerrhau has quit [Ping timeout: 260 seconds]
k-stz has quit [Remote host closed the connection]
<_death>
sure, and then, when you're in a world full of pain, you'll come to appreciate the former ;)
<Josh_2>
hmm xD
<Josh_2>
the page could be the shared resource and I could have a different thread for extracting different bits of data
Cymew has quit [Ping timeout: 260 seconds]
python476 has quit [Ping timeout: 256 seconds]
wheelsucker has quit [Quit: Client Quit]
kajo has joined #lisp
Cymew has joined #lisp
energizer has joined #lisp
kark has quit [Ping timeout: 255 seconds]
<verisimilitude>
He's already doing this for a class, _death.
thelounge49 has joined #lisp
<_death>
yes, in the real world people rarely begin with "I need to write a program that uses mutexes"
thelounge49 has left #lisp [#lisp]
<Josh_2>
yh
<_death>
although "I wanna play with this library" is common for some ;)
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
Cymew has quit [Ping timeout: 240 seconds]
pmc_ has quit [Quit: Leaving]
Cymew has joined #lisp
damke has joined #lisp
rpg has joined #lisp
<Josh_2>
verisimilitude: How would I utilize signalling between threads?
<Josh_2>
Something else I gotta do
em has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 265 seconds]
deng_cn has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<rpg>
I would like to take some centralized code, and change it so that what it does now by function call will be done by invoking a (lisp) sub-process that will compute an answer and exit. Anyone doing this and, if so, how do you move data from the master into the sub-process? The arguments are too complicated to pass on the command line, but making a new file every time I invoke, in order to push data into the other process seems a little yucky.
deng_cn has joined #lisp
<Josh_2>
rpg: a tcp stream?
MasouDa_ has joined #lisp
<rpg>
Josh_2: I could probably just write to the other lisp's standard input and read its standard out....
<verisimilitude>
You could have an overarching interface thread, Josh_2.
python476 has joined #lisp
Folkol has joined #lisp
<verisimilitude>
You're not thinking big enough, rpg; what you need is to define a JSON interface.
<aeth>
Depending on how you launch the subprocess (i.e. do you do it from Lisp?), you could communicate with the I/O streams used with uiop:launch-program
<aeth>
which is probably very similar to what you're talking about with stdin and stdout
<rpg>
aeth: Yes, I'm going to do it from lisp, since I already have the outer loop written in lisp...
<rpg>
aeth: Yes, I think it would be effectively the same thing.
<rpg>
I have the sneaking suspicion that I should do this first with a temp file for the command, since it will be easier to debug.
surrounder has left #lisp ["WeeChat 2.0.1"]
Cymew has quit [Ping timeout: 240 seconds]
<Josh_2>
verisimilitude: what do you mean by an overarching interface?
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
MasouDa has quit [Ping timeout: 260 seconds]
m_ has joined #lisp
Cymew has joined #lisp
<verisimilitude>
So, have one thread that provides an interface that necessitates signaling other threads.
Bike has joined #lisp
<Josh_2>
hmmm
<Josh_2>
Not really sure what you mean
<verisimilitude>
I'll give an example then.
<verisimilitude>
Since you're forced to use signals, why not allow, say, a signal to report download status or whatnot; you could then have a thread that shows this information, periodically signaling.
Cymew has quit [Ping timeout: 240 seconds]
<Josh_2>
O
<verisimilitude>
Which class is this?
<Josh_2>
It's called "Data structures and Algorithms"
<verisimilitude>
You're basically being told to do something, with no direction, but it must conform to certain arbitrary requirements.
<Josh_2>
Pretty much, there's a few example things I could do but meh. Most people will be doing some game related AI stuff because most people are doing game dev
<Josh_2>
(most people will be use C++ the peasants)
Cymew has joined #lisp
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
verisimilitude has quit [Remote host closed the connection]
orivej_ has joined #lisp
eminhi has joined #lisp
aoeu has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
verisimilitude has joined #lisp
eminhi has quit [Client Quit]
<verisimilitude>
Anyone who starts out thinking ``How can I use threads and mutexes?'' is either experienced with it or an idiot; you seem to be neither, yet this is how you're being taught.
<verisimilitude>
One of the better lessons you'll learn from a university, Josh_2, is how abominable the education system is.
<Josh_2>
xD You don't have to tell me that
Cymew has quit [Ping timeout: 260 seconds]
<Josh_2>
I have used threads before but never mutexes etc but it is only the assessment, there has been lots of practice exercises through the semester
<verisimilitude>
Even then, a lack of shared state is the hip new thing and I'd be inclined to do things that way if I could help it.
adjustingmaitai has quit [Read error: Connection reset by peer]
<Josh_2>
huh?
Cymew has joined #lisp
<Josh_2>
secretly taking back that "either" xD
<verisimilitude>
So, the cool new parallel programming method works in terms of messages on nodes, rather than shared state with locks and all of that.
<Josh_2>
ahh alright
<verisimilitude>
This is what Erlang does and is also realized in hardware such as Green Array's GA144 chip.
<verisimilitude>
That machine has 144 tiny Forth machines connected to their neighbours.
_Mental has joined #lisp
<pierpa>
Make a railroad simulator. With a graphical interface for extra credit :)
verisimilitude has quit [Remote host closed the connection]
<Josh_2>
Okay so I gotta make some functions to download a webpage, and to extract hyperlinks from that webpage
<Josh_2>
I will then deal with the threading
Cymew has quit [Ping timeout: 240 seconds]
<Josh_2>
First am gonna eat me some blueberry yogurt (very Lisp related)
Cymew has joined #lisp
<bjorkintosh>
ah. flavors.
<aeth>
I thought CLOS obsoleted Flavors and CommonLOOPS?
Cymew has quit [Ping timeout: 240 seconds]
<edgar-rft>
I think blueberry yogurt is the new CLOS
<Josh_2>
To be fair, I would do my work but I keep watching machining/welding videos on Youtube
<Xach>
Josh_2: that is a common affliction
Cymew has joined #lisp
<Josh_2>
Watching machining/welding videos?
<Xach>
it is a constant distraction for me
<Josh_2>
Same
* Xach
must go out and drawfile his lathe banjo, adios
Cymew has quit [Ping timeout: 260 seconds]
megalography has joined #lisp
damke_ has joined #lisp
Cymew has joined #lisp
sjl has quit [Ping timeout: 255 seconds]
rumbler31 has joined #lisp
Kaisyu has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 265 seconds]
sz0 has joined #lisp
_Mental has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lemonpepper24 has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Remote host closed the connection]
anunnaki has quit [Ping timeout: 256 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Cymew has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
rpg has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
emma has joined #lisp
emma has quit [Changing host]
emma has joined #lisp
earl-ducaine has joined #lisp
David-A has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
<earl-ducaine>
CFFI question: tryinig to create type with 16 byte alignment (since CFFI doesn't directly support __int128_t) But there doesn't seem to be any way within CFFI to create an object of arbitrary alignment.
Cymew has joined #lisp
energizer has quit [Quit: Leaving]
fikka has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
<earl-ducaine>
One way would be to alocate an array of sufficient size that you could arbitrarily choose the location to start you 128 byte aligned object....
orivej_ has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
Cymew has joined #lisp
anunnaki has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
damke has joined #lisp
Cymew has joined #lisp
wxie has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
karswell_ has joined #lisp
rumbler31 has joined #lisp
karswell has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
fisxoj has joined #lisp
dieggsy has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]