kevingal_ has quit [Remote host closed the connection]
kevingal has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
really2 has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 260 seconds]
Josh_2 has quit [Ping timeout: 276 seconds]
Tordek has quit [Ping timeout: 276 seconds]
wooden has quit [Read error: Connection reset by peer]
random-nick has quit [Quit: quit]
wooden has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
curtosis[away] has joined #lisp
cyraxjoe has joined #lisp
thatpythonboy has quit [Ping timeout: 245 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
Tordek has joined #lisp
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
charles` has quit [Ping timeout: 264 seconds]
kingcons has joined #lisp
jello_pudding has joined #lisp
elusive has quit [Quit: Leaving]
carkh has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Nilby has quit [Ping timeout: 264 seconds]
semz has quit [Ping timeout: 260 seconds]
charles` has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
shifty has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
dbotton has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
CrazyPython has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
shifty has quit [Ping timeout: 265 seconds]
contrapunctus has joined #lisp
dbotton has quit [Client Quit]
shifty has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
john__ has joined #lisp
gaqwas has quit [Ping timeout: 246 seconds]
shifty has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
curtosis has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
gitgoood has joined #lisp
gitgood has quit [Ping timeout: 260 seconds]
marusich has quit [Ping timeout: 245 seconds]
<beach>
Good morning everyone!
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
pankajsg has joined #lisp
karlosz has joined #lisp
hsmath has joined #lisp
<fiddlerwoaroof>
morning, beach!
marusich has joined #lisp
karlosz has quit [Quit: karlosz]
Lycurgus has joined #lisp
loli has quit [Quit: WeeChat 3.0.1]
sz0 has quit [Quit: Connection closed for inactivity]
aartaka has joined #lisp
adlai has joined #lisp
<adlai>
why does nobody want to maintain Anaphora
<adlai>
it's not as though fielding pull requests and WONTFIXing issues takes any more mental overhead than never checking a spam folder
* adlai
would rather maintain Anaphora than open a pull request on LOCAL-TIME, but apparently his homework is the latter
DateMasamune2000 has joined #lisp
DateMasamune2000 has quit [Remote host closed the connection]
<fe[nl]ix>
adlai: go ahead and take it over. I doubt anyone will object
* adlai
wonders whether the library dependency graph has anything useful to say on the topic
<adlai>
fe[nl]ix: my primary objection is that I tend to stifle development, due to insufficient use of positive emoji.
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
<adlai>
possibly even due to indistinguishably using sarcasm, irony, and drunken rage; and this tends to make the social media (what else is GitHub these days !? ) less of an all-inclusive garden of children.
karlosz has joined #lisp
<adlai>
so while I honestly don't mind being the bad man who closes pull requests with "No, fuck off", and responds to issues with "Please redirect your sweet time towards the ANSI compliance tests, they are dying of unlove", that is probably not what the Common Lisp community needs in the twenty third decade or whenever this is.
<adlai>
[I repeat myself, intentionally] Henry Baker's paper archive has gone offline, apparently along with the entire webserver that hosted it. Wikipedia is already linking to https://web.archive.org/web/20200212080133/http://home.pipeline.com/~hbaker1/ although I do wonder whether anyone has available an archive of just the signal, to save others the trouble of sifting through HTML noise
curtosis has joined #lisp
<fe[nl]ix>
oh god, we need to preserve those
Lycurgus has quit [Quit: Exeunt]
karlosz has quit [Quit: karlosz]
Oladon has joined #lisp
Bike has quit [Quit: slpe]
edgar-rft has joined #lisp
skapata has quit [Remote host closed the connection]
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
aartaka has quit [Ping timeout: 256 seconds]
john__ is now known as gaqwas
gaqwas has quit [Changing host]
gaqwas has joined #lisp
edgar-rft has quit [Remote host closed the connection]
<aggin>
looks just like what fiddlerwoaroof sent in emacs
tweet[m] has joined #lisp
<fiddlerwoaroof>
As far as newlines go, I've found it's a good idea to put a newline between each argument, if the arguments are "complicated"
<fiddlerwoaroof>
So, (+ 1 2 3) is fine, but (+ 1\n(+ 2 3)\n(+ 3 4))
<aggin>
so do you think the IF statement had to be separated on different lines ?
<aggin>
that k looks lonely over there :(
cage_ has joined #lisp
<jdz>
Use a proper descriptive name for the variable.
<jdz>
Both k and v.
<jdz>
And rename lst to list.
<fiddlerwoaroof>
Yeah, putting the whole if expression on a single line makes my head hurt :)
<jdz>
aggin: Also you maybe mean NOT instead of NULL in the conditional.
<aggin>
oh yeah, I could've used NOT instead
<beach>
aggin: The only place where Common Lisp has "statements" is inside a TAGBODY. Usually, an expression meant to be evaluated is called a "form".
<jdz>
aggin: Looks like jsown:val-safe returns a generalized boolean (it does not end in -p). Does it return the same value as jsown:val if the value is "safe"? In that case you should use let to bind the result of jsown:val-safe.
<aggin>
jdz: yeah it returns the same value as jsown:val when it's safe
<aggin>
what would you recommend the name of the var I bind it to ?
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
VincentVega has joined #lisp
Demosthe1ex is now known as Demosthenex
AussieBoy has joined #lisp
AussieBoy has left #lisp [#lisp]
AussieBoy has joined #lisp
terpri_ has joined #lisp
terpri has quit [Ping timeout: 264 seconds]
<VincentVega>
Is there some moral equivalent of something that would be defmethod defclass :after? I need to do some external setup for certain classes which depends on the class metadata. So when the class is redefined in any way, I want to redo that setup. Superclass changes also count. At which MOP functions should I be looking at?.
aartaka has joined #lisp
dhil has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
<phoe>
equivalent, what do you mean?
<phoe>
oh, you want to do something when a class is redefined
<beach>
Hello saganman. Quite well thank you. I guess it peaked a bit a week or so ago when I submitted this paper to ELS: http://metamodular.com/SICL/call-site-optimization.pdf Since then, I have been working on register allocation for SICL/x86. If my technique for register allocation works out, it may be publishable some day.
<beach>
saganman: What about your work?
kevingal has joined #lisp
<saganman>
beach: I remember you were working on bootstrap or boot section or something.
<beach>
saganman: The SICL bootstrapping procedure is pretty much working, but there are a few elements missing, and I am re-working the MIR-to-LIR phase with better register allocation. Also, the technique in that paper changed a bit the different phases, so I am adapting them.
<saganman>
nice beach, I remember you were working on that for like over a year
<beach>
Oh yes. It's the essence of SICL, so it must be worked on.
<saganman>
My business is good. Almost completed last project so I have loads of money literally. The clc manufacturing industry has run into some problems.
<beach>
Excellent!
kenran has quit [Quit: leaving]
warweasle has joined #lisp
VincentVega has quit [Ping timeout: 240 seconds]
aartaka has quit [Read error: Connection reset by peer]
Josh_2 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
CrazyPython has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
<iekfkk>
m4 has many uses in code generation, but (as with any macro processor) problems can be hard to debug.[3]
long4mud has joined #lisp
recalloc has quit [Ping timeout: 245 seconds]
cpape``` has quit [Quit: ERC (IRC client for Emacs 26.3)]
cpape has joined #lisp
<beach>
iekfkk: It depends on the kind of macro system you have.
<iekfkk>
CL?
<beach>
iekfkk: If it is just textual substitution, then, yes, things are hard.
<beach>
Common Lisp macros work on the internal representation of code, which is much much better.
<beach>
The feature that makes that possible is called homoiconicity.
iekfkk is now known as pcre
charles` has joined #lisp
<beach>
pcre: Now, code using macros is intrinsically harder to understand than code using functions, because the evaluation rule can be different for each macro. And that is why Common Lisp programmers should use functions whenever the problem is such that the semantics of function calls works.
<beach>
pcre: What is the reason for your question?
<pcre>
should i use macros and expect debugging to be easy
curtosis is now known as curtosis[away]
<semz>
this feels like a troll question
<pcre>
hmm maybe i am becoming retarded
<beach>
pcre: You should not use macros unless you need to introduce new (s-expression-level) syntax.
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<beach>
pcre: It is a common newbie error to overuse macros.
<beach>
pcre: Again, like I said, when the semantics of a function call is fine, then there is no reason to use a macro.
<beach>
pcre: Does that make sense to you?
<pcre>
ofc
<beach>
So when you read about how bad macros are, it is nearly always in the context of macros that do textual substitution, simply because the people writing such things for some reason like to ignore homoiconicity.
<beach>
pcre: As I often say, people go to a lot of trouble to avoid learning Common Lisp.
drdee has quit [Quit: Leaving]
really2 has joined #lisp
<pcre>
why don't they reform sbcl to rival C
<Xach>
pcre: in what respect?
cosimone has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
<semz>
the benchmark game isn't representative of much. the C and C++ is full of vector intrinsics, the haskell is "fortran in any language", serial programs get pitted against parallel programs...
<aeth>
plus, they've been fixed benchmarks for over a decade now, haven't they? So any language implementor can optimize those tasks in particular, for free advertising
<pcre>
semz: haskell is fortran?
<aeth>
pcre: semz is saying that the Haskell is written in Fortran style rather than in Haskell style
<semz>
^
<semz>
the haskell code is completely unidiomatic
saganman is now known as blackadder
really2 has quit [Ping timeout: 256 seconds]
<pcre>
C code too
<pcre>
except python all code seems very different
<beach>
pcre: What is your point? Are you trying to convince everyone here to abandon Common Lisp in favor of Julia and C++?
<pcre>
no C++, but julia too is homoiconic
<beach>
It doesn't look like it to me.
<beach>
Besides, homoiconicity is not the only reason that Common Lisp is a good programming language.
<pcre>
really?
<beach>
CLOS, the condition system.
<beach>
I don't know Julia, but I am looking at the manual, and I can't figure out why you say Julia is homoiconic.
<aeth>
Julia is a language aimed at numerical/scientific computation in particular. That's not going to be too appealing to people who use general purpose programming languages for... general purpose stuff. You might as well be pitching R or MATLAB in here.
<aeth>
It is going to make it show up on benchmarks well, though
<beach>
pcre: That's pretty lame compared to Common Lisp.
<beach>
pcre: With that definition, Java is homoiconic as well.
<pcre>
and python as well, but... homoiconicity lies in implementation's AST not the language itself, so it's implementation defined
<mfiano>
Julia is often not considered homoiconic anymore, especially for people that know a thing or two about Lisp. Its compiler is written in Lisp, though.
<beach>
pcre: Another extremely important feature of Common Lisp is that it has a standard that was created by an independent organization. Independent in that that organization does not supply Common Lisp implementations. As I point out in my talks to industry, a project leader who chooses a language without an independent standard for some project, should be fired.
CrazyPython has quit [Read error: Connection reset by peer]
<pcre>
they claim it's homoiconic on the front page of metaprogramming
<beach>
pcre: Anyway, it is quite inappropriate to come here and try to convince people to use Julia rather than Common Lisp.
<beach>
pcre: People claim so many things.
<pcre>
i see homoiconicity as implementation-dependent
<pcre>
except lisp where it's enforced
<beach>
I don't even know what that is supposed to mean.
<pcre>
it's AST can be clean just like lisp, and therefore manipulated just like lisp....
<beach>
The Common Lisp standard dictates how code is represented internally, and it is an immediate result of the surface syntax.
<mfiano>
There's a reason Julia's parser was written in an actual homoiconic language.
<beach>
pcre: Again, what is your point?
<pcre>
S-expr is one way to go about it, M-expr another and general expression Expr which are used in julia...
<beach>
pcre: It seems you thought that homoiconicity is the only reason we use Common Lisp, and that you are now convinced that Julia is homoiconic too. Given that you are now also convinced that Julia is faster than a good Common Lisp implementation, there is probably no reason for you to use Common Lisp.
<pcre>
i think you are not believing that julia is lisp-like macros but i won't argue
<beach>
pcre: I don't care whether you agree or not.
puchacz has joined #lisp
<pcre>
beach: you read my mind
<pcre>
but i like S-expr
<pcre>
so i learn CL but not use it
<_death>
what is this weird :call thing.. in Lisp, (/ (+ 4 4) 2) is (/ (+ 4 4) 2), not (call / (call + 4 4) 2)
<beach>
pcre: I am sorry to hear that.
<puchacz>
hi, if I (setf *special-variable* new-value) without a dynamic binding (i.e. modify the global value), am I guaranteed not to overwrite any dynamic bindings that already exist in other threads?
<beach>
pcre: I for one like CLOS and the MOP. I like method combinations. I like the condition system, and I like the fact that the standard can't change in arbitrary ways.
<mfiano>
puchacz: Threads are not part of the astandard, so there is no guarantee.
<mfiano>
standard*
<beach>
puchacz: Since the standard does not mention threads, it is implementation specific.
<beach>
puchacz: But most implementations share the global value, and make other bindings per thread.
<puchacz>
mfiano, beach - thanks. I will not do it then. I will use 2 variables instead, one global for setf, the other for dynamic bindings
<puchacz>
and without threads, (setf *special-variable* new-value) when outside a dynamic binding just changes the global place, and inside dynamic binding - the dynamically bound place, right?
<beach>
Depends on what you mean by "outside".
<puchacz>
beach - in a code that is not in (let ((*special-variable* value-1)) ...) and not anything called by this code
<beach>
Then yes. If there are no dynamic bindings, then the global value is altered.
<puchacz>
and if there is? i.e. I am inside this let or somethign called by this let?
<beach>
Though watch out for let-like constructs too.
aartaka has joined #lisp
<beach>
It is always the most recent binding that is affected.
<puchacz>
ok, thanks
<puchacz>
however I think I will try to avoid setfing a special variable
<beach>
Even MAKUNBOUND affects only the most recent binding.
<puchacz>
confusing, and threading behaviour is undefined
<beach>
puchacz: I don't think you will find an implementation that behaves differently from what we told you.
<beach>
puchacz: People use languages without a standard every day, like Python, Julia, etc. They see no problem.
<beach>
I hear there are even project leaders of important commercial projects who choose languages without a standard.
<puchacz>
we have a standard, I see it as an advantage, why not use it:) ?
<beach>
puchacz: It is not "undefined" in that there is not a phrase in the Common Lisp standard that says that this behavior is undefined. It is just that the standard does not mention threads.
<puchacz>
the standard even
<beach>
Oh, you are right. It is a great advantage.
<beach>
But if you need stuff that is not in the standard, then you have no choice.
entel has joined #lisp
<beach>
And if every implementation defines the behavior in the same way, then the risk is minimal.
<pcre>
would you see python as having a standard?
<puchacz>
no :)
rdd` has quit [Ping timeout: 256 seconds]
<pcre>
do you see python's BNF and reference as a standard?
<puchacz>
python's usefulness has a lot to do with their numerical / machine learning library wrappers around C libraries
<puchacz>
my understanding is these wrappers are not portable and they only work with C
<puchacz>
Cpython I mean
Lycurgus has joined #lisp
<puchacz>
anyway, beach, I agree that we routinely use threads that are outside of the standard already, but it is not the reason for me to push the limits and use a construct like setf-ing a dynamic variable across threads, it may be less "informally standardised" across implementations.
<pcre>
beach: perhaps you don't see cpython's reference as a standard, so you'd use CL for ML/AI?
<pcre>
and not to mention mobile apps UI and desktop UI
<pcre>
has anyone written mobile apps in CL?
<heisig>
pcre: I am using CL for ML/AI (among other things). And I there are some mobile apps written in CL. There is even a steam game being developed in CL.
<pcre>
puchacz: can you write android UI in CL?
<pcre>
heisig: hmm i searched it's seems slike a barren desert like C
<puchacz>
you can write a lot of app in CL (ECL or Lispworks) and communicate with Java GUI via JNI
<puchacz>
so not fully in CL but a lot of it can be in CL
<pcre>
It uses the ECL implementation for the Lisp side, and Qt5/QML for the UI. Qt/gtk is crap
<pcre>
julia too has qt problem
<puchacz>
Lispworks uses Java for Android GUI
villanella has joined #lisp
<Lycurgus>
anybody used CLOG?
ficl has joined #lisp
<Lycurgus>
or anything cl that just works the html5 dom
<Lycurgus>
(to effect a gui, not just the standard web server stuff)
<alanz>
Lycurgus, I am no expert in cl or guis, but I have played a bit with CLOG. It looks pretty good, and they guy developing it is very helpful and committed to it
<Lycurgus>
rebbi botton
flazh has quit [Ping timeout: 276 seconds]
<alanz>
yes, he hangs out here
<alanz>
sometimes
<Lycurgus>
with what nick?
<alanz>
dbotton, iirc
<Lycurgus>
ah, ty
flazh has joined #lisp
<alanz>
if you look at the repo, there is a discourse, and discussions on github too
<Lycurgus>
i too started to play with it
ljavorsk has joined #lisp
<Lycurgus>
didn get to point of any screens tho
rixard has quit [Read error: Connection reset by peer]
rixard has joined #lisp
<Lycurgus>
which I take it 'looks pretty good' means you did
rickygee_ has joined #lisp
elusive has joined #lisp
<pcre>
Lycurgus: how did you know about CLOG
<Lycurgus>
pcre, it's on cliki
villanella has quit [Quit: villanella]
<fiddlerwoaroof>
I tend to think react-native + parenscript + cl would be a good mobile app setup
<fiddlerwoaroof>
Even better if someone wanted to reimplement react-native's strategy in CL . . .
notzmv has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Quit: Exeunt]
aindilis` has quit [Remote host closed the connection]
taof has joined #lisp
blackadder has quit [Quit: WeeChat 1.6]
notzmv has joined #lisp
dmc00 has joined #lisp
cosimone has joined #lisp
rixard has quit [Read error: Connection reset by peer]
rixard has joined #lisp
rickygee_ has quit [Ping timeout: 264 seconds]
pcre has quit [Ping timeout: 260 seconds]
curtosis[away] has joined #lisp
cosimone has quit [Remote host closed the connection]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
notzmv has quit [Ping timeout: 245 seconds]
gaqwas has quit [Ping timeout: 265 seconds]
luni has joined #lisp
dilated_dinosaur has joined #lisp
asarch has joined #lisp
<asarch>
Do you have to declare all the parameters of the function in the (defgeneric ...) section?
<Xach>
(defgeneric foo (<variable-name>) ...) - but they need not match the name in the defmethod.
<Xach>
asarch: no, defgeneric is not concerned with classes.
<asarch>
REALLY?!!!
<Xach>
They are not attached to classes.
<Xach>
Really.
<asarch>
I thought that for each defmethod there has to be a defgeneric before
<Xach>
asarch: that is a normal way to do it, but it is not mandatory.
<asarch>
Thank you!
heisig has quit [Ping timeout: 265 seconds]
pankajsg has quit [Ping timeout: 265 seconds]
<asarch>
Thank you very much! :-)
<Xach>
I'm not sure how you got from what I wrote to a revelation about defgeneric/defmethod like that, but if it helps, I'm glad.
<asarch>
My notes wasn't complete about this
<asarch>
And PCL uses this funny notation: (defgeneric withdraw (account amount) ...) (defmethod withdraw ((account bank-account) amount) ...)
<Xach>
asarch: that notation is normal
<Xach>
asarch: that is what i also described
<asarch>
?
<asarch>
"bank-account" is the name of the class, right?
<Xach>
asarch: yes
<asarch>
So, in the defgeneric declaration you don't actually need to specify the name of the class at all?
<Xach>
asarch: there is no "the" class - defgeneric is generic, not specific to a class.
<Xach>
asarch: and you do not put class names in the defgeneric lambda list
<asarch>
I see
dhil has quit [Ping timeout: 264 seconds]
<asarch>
My notes are wrong then
<asarch>
:-P
<Xach>
asarch: it may help to read some "real" code too
<asarch>
I remember when I was at junior high-school, our English teacher was writing some examples of the question "Which" and one of my classmates wrote "Cuich one do you like most?" instead of "Which one..."
<asarch>
I know, but so far, all my code didn't use the defgeneric declaration (and I couldn't find the copy of the Sonya's book)
<Xach>
if you do not have a defgeneric, it is automatically created when a defmethod for a name is first seen. i don't like that style very much, but some don't mind.
cchristiansen has joined #lisp
<Xach>
it does not mean there is no defgeneric, just that one was implicitly created
<asarch>
So, why defgeneric at all?
mindCrime_ has quit [Ping timeout: 260 seconds]
<Xach>
asarch: it is a good place for the documentation of the function
<Xach>
there is a :documentation option
<Xach>
you can also specify things like method combination there, but that's somewhat uncommon
<asarch>
Ok
<Xach>
asarch: a group of generic functions working together in a documented way can form a protocol. and then the most generic behavior can be defined for a broad class of objects, with specialization via more specific methods when needed. this is discussed in a nice way in PCL.
<Xach>
AMOP has a complex but nicely-defined protocol for CLOS itself
epony has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 260 seconds]
kslt1 has quit [Quit: Lost terminal]
perrier-jouet has quit [Quit: WeeChat 3.1]
akoana has joined #lisp
gaqwas has quit [Ping timeout: 245 seconds]
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
pve has quit [Quit: leaving]
quazimodo has joined #lisp
asarch has quit [Quit: Leaving]
notzmv has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
shka_ has quit [Ping timeout: 260 seconds]
epony has joined #lisp
sturm__ has joined #lisp
mindCrime_ has joined #lisp
sturm__ has quit [Quit: sturm__]
asarch has joined #lisp
varjagg has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
bilegeek has joined #lisp
cosimone has quit [Remote host closed the connection]