mister_m has quit [Remote host closed the connection]
mister_m has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 256 seconds]
taiju has quit [Ping timeout: 256 seconds]
taiju has joined #commonlisp
seok has quit [Ping timeout: 265 seconds]
lisp123 has joined #commonlisp
pjb has quit [Ping timeout: 256 seconds]
lisp123 has quit [Ping timeout: 240 seconds]
tyson2 has joined #commonlisp
cuz has joined #commonlisp
waleee has quit [Ping timeout: 256 seconds]
rt has joined #commonlisp
rt is now known as robin
Xach has quit [Changing host]
Xach has joined #commonlisp
seok has joined #commonlisp
notzmv has quit [Ping timeout: 256 seconds]
contrapunctus has left #commonlisp [#commonlisp]
robin has quit [Ping timeout: 252 seconds]
contrapunctus has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
xlei has quit [Read error: Connection reset by peer]
notzmv has joined #commonlisp
xlei has joined #commonlisp
cuz has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: Lost terminal]
jeosol has quit [Quit: Ping timeout (120 seconds)]
elf_fortrez has joined #commonlisp
pjb has joined #commonlisp
jeosol has joined #commonlisp
<beach>
Good morning everyone!
<Josh_2>
Good morning beach
Gnuxie has quit [Read error: Connection reset by peer]
luis` has quit [Remote host closed the connection]
dieggsy has quit [Read error: Connection reset by peer]
katco has quit [Read error: Connection reset by peer]
loke[m] has quit [Read error: Connection reset by peer]
akanouras has quit [Remote host closed the connection]
Mrtn[m] has quit [Write error: Connection reset by peer]
etimmons has quit [Remote host closed the connection]
taiju has quit [Ping timeout: 240 seconds]
loke[m] has joined #commonlisp
taiju has joined #commonlisp
elf_fortrez has quit [Ping timeout: 246 seconds]
katco has joined #commonlisp
dieggsy has joined #commonlisp
Mrtn[m] has joined #commonlisp
akanouras has joined #commonlisp
Gnuxie has joined #commonlisp
etimmons has joined #commonlisp
luis` has joined #commonlisp
Oddity has quit [Ping timeout: 250 seconds]
Oddity has joined #commonlisp
Mrtn[m] has quit [Quit: node-irc says goodbye]
loke[m] has quit [Quit: node-irc says goodbye]
Gnuxie has quit [Quit: node-irc says goodbye]
katco has quit [Quit: node-irc says goodbye]
etimmons has quit [Quit: node-irc says goodbye]
akanouras has quit [Quit: node-irc says goodbye]
dieggsy has quit [Quit: node-irc says goodbye]
mister_m has quit [Remote host closed the connection]
luis` has quit [Quit: node-irc says goodbye]
taiju has quit [Ping timeout: 240 seconds]
Krystof has quit [Ping timeout: 272 seconds]
taiju has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 265 seconds]
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
Alfr has quit [Ping timeout: 252 seconds]
lad has quit [Ping timeout: 272 seconds]
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 265 seconds]
lisp123 has joined #commonlisp
peterhil has quit [Ping timeout: 258 seconds]
derelict has quit [Ping timeout: 256 seconds]
lisp123 has quit [Ping timeout: 265 seconds]
derelict has joined #commonlisp
lisp123 has joined #commonlisp
[deleted] has joined #commonlisp
livoreno has quit [Ping timeout: 252 seconds]
derelict has quit [Ping timeout: 240 seconds]
pve has joined #commonlisp
Inline has quit [Quit: Leaving]
shka has joined #commonlisp
<susam>
Good morning, everyone!
treflip has joined #commonlisp
pjb has quit [Ping timeout: 256 seconds]
lisp123 has quit [Ping timeout: 272 seconds]
livoreno has joined #commonlisp
[deleted] has quit [Ping timeout: 265 seconds]
<energizer>
I heard some lisps let you define a struct, instantiate it, and then change the layout of the type, and that the layout change will propagate into the instances. Does cl have something like that?
<moon-child>
something fun I realised: a trivial definition of list* is (defun list* (&rest xs) (reduce #'cons xs :from-end t))
<mfiano>
Clojure wants its xs back
<moon-child>
heh, I don't know clojure; got that from haskell
<moon-child>
(granted, I don't know haskell either, but)
<phadthai>
some implementations may allow similar functionality with defstruct objects but it is non-standard and allows implementations to compile more efficiently (a modified structure then usually requires all dependent code to be rebuilt)
<phadthai>
but yes, clos was designed with live modifications in mind
shka has quit [Ping timeout: 240 seconds]
dsk has joined #commonlisp
livoreno has quit [Read error: Connection reset by peer]
livoreno has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<energizer>
thanks
<beach>
For the record, SICL struct instances are also standard objects, so they allow redefinition just like instances of standard classes.
<beach>
But then, SICL doesn't exist (yet), so such information is not very useful at the moment.
Cymew has joined #commonlisp
cage has joined #commonlisp
loke[m] has joined #commonlisp
Gnuxie has joined #commonlisp
katco has joined #commonlisp
Mrtn[m] has joined #commonlisp
dieggsy has joined #commonlisp
akanouras has joined #commonlisp
etimmons has joined #commonlisp
luis` has joined #commonlisp
Alfr has joined #commonlisp
Mrtn[m] has quit [Quit: Client limit exceeded: 20000]
lisp123 has joined #commonlisp
loke[m] has quit [Quit: Client limit exceeded: 20000]
Gnuxie has quit [Quit: Client limit exceeded: 20000]
katco has quit [Quit: Client limit exceeded: 20000]
akanouras has quit [Quit: Client limit exceeded: 20000]
etimmons has quit [Quit: Client limit exceeded: 20000]
dieggsy has quit [Quit: Client limit exceeded: 20000]
Krystof has joined #commonlisp
luis` has quit [Quit: Client limit exceeded: 20000]
loke[m] has joined #commonlisp
katco has joined #commonlisp
dieggsy has joined #commonlisp
Mrtn[m] has joined #commonlisp
akanouras has joined #commonlisp
Gnuxie has joined #commonlisp
etimmons has joined #commonlisp
luis` has joined #commonlisp
Krystof has quit [Ping timeout: 258 seconds]
Krystof has joined #commonlisp
hendursa1 has joined #commonlisp
hendursaga has quit [Ping timeout: 244 seconds]
<pve>
Hi, when querying a system for information, would you rather have a simple approach like (mycompany.customer:search-by-email "bob@foo.com") where pre-defined queries are just mapped to functions, or a more elaborate approach like (execute-query (make-instance 'customer-query :email "bob@foo.com")), where they are mapped to classes instead?
<pve>
(I mean like a database, not an ASDF system)
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Mrtn[m] has quit [Quit: Client limit exceeded: 20000]
Gnuxie has quit [Quit: Client limit exceeded: 20000]
katco has quit [Quit: Client limit exceeded: 20000]
etimmons has quit [Quit: Client limit exceeded: 20000]
akanouras has quit [Quit: Client limit exceeded: 20000]
dieggsy has quit [Quit: Client limit exceeded: 20000]
lotuseater has joined #commonlisp
luis` has quit [Quit: Client limit exceeded: 20000]
loke[m] has quit [Remote host closed the connection]
loke[m] has joined #commonlisp
Gnuxie has joined #commonlisp
dieggsy has joined #commonlisp
etimmons has joined #commonlisp
katco has joined #commonlisp
Mrtn[m] has joined #commonlisp
akanouras has joined #commonlisp
luis` has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
<mfiano>
Not sure you'll be getting meaninful results with such an open-ended question, but I'd prefer the former, as to not allocate memory, and the ability to do partial application more easily on an as-needed basis.
lisp123 has joined #commonlisp
<pve>
mfiano: thank you, good points
Mrtn[m] has quit [Remote host closed the connection]
etimmons has quit [Remote host closed the connection]
akanouras has quit [Remote host closed the connection]
loke[m] has quit [Remote host closed the connection]
dieggsy has quit [Remote host closed the connection]
Gnuxie has quit [Read error: Connection reset by peer]
luis` has quit [Write error: Connection reset by peer]
katco has quit [Read error: Connection reset by peer]
lisp123 has quit [Ping timeout: 272 seconds]
<mfiano>
From an API perspective, composition is very important with queries. You might want to limit the number of results, filter them in some way, sort by some criteria, join two queries in some way, etc, which is part of the query. I think a DSL would be better than calling an evaluator on a function or a class, and that's an implementation detail anyway.
<dsk>
pve: IANAE, but I would generally prefer the latter, more flexible option, maybe with an interface that allows things like (query :email "bob@foo.com") and (query :forename "Bob" :age 42). If consing is actually a problem, you can always memoize the function that creates the query objects.
<mfiano>
I ttherefor think a DSL would be best, see for example the :sxql system.
<pve>
mfiano: and yes, perhaps too open-ended, I was just wondering if someone had dealt with sql databases and hade to make the same choice.
<mfiano>
Whenever I am working with SQL databases I have far too many queries for either approach
<mfiano>
I prefer sxql or hard-coded strings
<pve>
mfiano: do you end up with sql all over the code base?
mayuresh has joined #commonlisp
<mayuresh>
hello. :)
<minion>
mayuresh, memo from flip214: # setxkbmap -option caps:ctrl_modifier ....
<pve>
dsk: that seems like a good idea
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
<pve>
ideally I would like to contain the sql queries as much as possible
<mfiano>
How much they are contained depends on how extensible you want them, and probably a bit of how much you want to repeat yourself, without some sophisicated macrology.
<pve>
mfiano: yes.. so I guess it's safe to say there's no simple answer
lisp123_ has joined #commonlisp
<pve>
mayuresh: I am using postgresql
<mayuresh>
pve: do check out that book, it even has examples in "common lisp".
CrashTestDummy2 has quit [Ping timeout: 258 seconds]
<pve>
wow really?
<mayuresh>
yeah
<mayuresh>
pve: the book basically teaches you how to optimise your code and sql together.
<pve>
oh is it dims book?
<mayuresh>
what's a dims book?
<pve>
no I mean the irc nickname "dim"
<mfiano>
Yes
<pve>
I meant "dim's"
<pve>
cool!
<mayuresh>
ah, you mean dimitri! yes, it is.
lisp123 has quit [Ping timeout: 252 seconds]
<pve>
at first I was skeptical, but this looks pretty interesting actually
<mayuresh>
i was totally blown away by what's been presented in that book.
Alfr has quit [Ping timeout: 246 seconds]
<mayuresh>
it is an expert's distilled wisdom.
<mfiano>
It better be for the price :)
<mayuresh>
:D
<pve>
I consider myself decent at SQL, but I suck at connecting/interfacing my application to the DB.. will this book help me with that?
<mayuresh>
yes, also it will teach you when to write what in sql and what in code
<mfiano>
$130 for a medium-length paperback book...whew
<mayuresh>
mfiano: i think he also sells a digital edition.
<mfiano>
Sure, but I limit my digital reading to academic papers...and mindlessly traversing wikipedia
<mfiano>
For threaded messaging, if you can deal with the spam, use usenet. If you can deal with the web, use reddit.
peterhil has joined #commonlisp
selwyn has joined #commonlisp
<mayuresh>
somehow, the books/material using scheme go a lot more deeper into computer science than books using "common lisp".
<mayuresh>
i stumbled upon a book called "concrete abstractions" which is an intermediary step between "simply scheme" and 'sicp'.
<beach>
Common Lisp has always been more pragmatic and industrial.
<beach>
For example, from the start, they were concerned with performance. Not so much with Scheme.
<mayuresh>
i think i am on the right track while working with scheme to learn deep computer science material before moving over to "common lisp" as my final destination.
<mayuresh>
or rather my final language.
<mfiano>
Scheme is a very simple language, being only about 100 pages specified. It is a good teaching aid, mostly, and to be near feature-parity with CL, many extensions (SRFI's) would be needed.
<beach>
I learned (and used) Scheme before I learned Common Lisp, but now I consider it like learning Latin just to learn Spanish one day.
<mfiano>
I am with beach. Scheme is not very...practical, and doesn't carry over much to CL.
<mayuresh>
beach, because you learned latin before, your spanish is really good now.
<beach>
It is a matter of total time spent to get to the final objective.
<beach>
You will do even better if you study Sanskrit before latin.
rogersm has joined #commonlisp
<beach>
But you are probably right that the books that use Scheme tend to be written by more theoretically inclined people, so they are more "CS-y" than the books on Common Lisp. In case that's what you want.
<ecraven>
one of the benefits of Scheme is that it is much easier to understand R7RS fully than to understand CLHS fully. and many things transfer from Scheme to CL well (but many things need to be learned too ;)
<beach>
But I don't think that's related to the languages, other than that Scheme attracts theoreticians more.
<ecraven>
mayuresh: if you want to reach CL, there's not much use in learning Scheme first, as you want to go to CL anyway
<ecraven>
one of these days I'd love to create a proper benchmark between SBCL and Chez Scheme
<ecraven>
Chez really generates very fast code (as long as you don't use floats :P)
<mfiano>
I would say the best way to learn Common Lisp is to take your time, writing actual code, after a brief introduction to the language. I started Common Lisp 16 or so years ago when PCL was released, with no real prior programming experience, only having read about half of the book before it had me experimenting on my own, and the rest is history.
<mfiano>
But most definitely, skip the Scheme step. There is some overlap, but not much, or at least less than the chance of confusing concepts when working in one or the other.
<mayuresh>
cool.
<ecraven>
I agree, I've read many books on CL, but am not actually a good CL programmer, as I've never used it very much
<mayuresh>
i think it would do me good to work through theoretical computer science using scheme (since it's a lisp) and then move to practical software development/engineering using commonlisp.
<mfiano>
We are saying that path is probably not a good one, if you value your time, and can accept the extra difficulty that you will face in learning CL without Scheme exposure.
<mfiano>
compared to learning CL without Scheme exposure*
<ecraven>
you can also do both, imho the languages are different enough that you don't mix things up, and if you do, you'll better understand them ;) but to learn Scheme and expect it to *help* you with learning CL might be a bit of a misconception
<ecraven>
it will certainly help you understand some of the decisions that went into CL better, as you will see alternative paths not taken ;)
<mayuresh>
i calculated that i'll be spending between 3 to 3.5 years more on the scheme with computer science path, which is a minor thing while compared to the great exposure i'll receive while working with commonlisp the rest of my life here on.
<mayuresh>
i'm 44 at the moment, single, and unaffiliated with industry.
<mayuresh>
i am planning to work with commonlisp because i think i'll enjoy it, but i wish to be well educated and informed about the internals too.
<mfiano>
Personally I would replace the Scheme part with a solid understanding of key data structures and algorithms.
<beach>
I agree with mfiano.
<ecraven>
even I agree, and I'm a Scheme fan ;)
<ecraven>
if your goal is CL, then go for the goal (and learn whatever you *think* Scheme would teach you directly)
<beach>
And even something like compiler design. I find a lot of programmers who don't know what compilers are capable of, tend to write dumb code as a result of their incorrect mental model of what the compiler does.
xsperry has quit [Remote host closed the connection]
<beach>
Some of my students would avoid defining lexical variables inside a loop, because "then the variable has to be created in every iteration", so they defined their variables with way too large a scope.
mayuresh has quit [Ping timeout: 268 seconds]
<mfiano>
Some basic compiler theory will help a lot, yes.
<beach>
I guess the advice was not appreciated. Oh well.
<mfiano>
Not appreciated?
<beach>
mayuresh left.
<mfiano>
His reason for leaving was a ping timeout, likely a server netsplit or network error on their end.
<beach>
I was half joking.
<mfiano>
Oh ha
kakuhen has quit [Quit: Leaving...]
[deleted] has joined #commonlisp
mayuresh has joined #commonlisp
<mayuresh>
i particularly like the fact about commonlisp that it has remained stable for
<mayuresh>
+such a long time.
<mayuresh>
even scheme has had multiple revisions come out.
<mayuresh>
i think commonlisp was done just right when it was standardised.
<ecraven>
well, CL is an entire language + libraries.. Scheme is not, you have to use implementation-specific code for everything practical
<mayuresh>
and it's the macros that make it that much more magical.
<mfiano>
It took a lot of time, money, and effort by a lot of smart individuals.
<ecraven>
Scheme (implementations) have exactly the same sort of macros that CL does, that's no different.. but CL has extensive *standardised* libraries across implementations
<mayuresh>
i read the introduction to "on lisp" and it was very inspiring.
<ecraven>
also, CL has pervasive CLOS
<mayuresh>
true.
livoreno has quit [Ping timeout: 258 seconds]
<ecraven>
maybe read "ansi common lisp" by the same author, do all the exercises, then read "on lisp", do all the exercises..
<mayuresh>
okay.
<ecraven>
many people seem to like Practical Common Lisp
frgo has quit [Remote host closed the connection]
<mayuresh>
seibel is bringing out 2e.
<mfiano>
He actually stated he will not
<mayuresh>
ah.
<mayuresh>
i read it on his twitter timeline that he's soliciting suggestions.
<mfiano>
However, I think phoe is working with Edi Weitz on CLR 2e
frgo_ has joined #commonlisp
<mayuresh>
what is clr?
<mayuresh>
commonlisp recipes?
<mfiano>
Yes that was a while ago, but he mentioned he will not be about a week ago.
<mfiano>
Yes
<mayuresh>
any reasons stated why he'll not be bringing out 2e?
<ecraven>
ah, the number of times I've missed displaced arrays in Scheme ... :-/ CL really is a complete language+library
<mayuresh>
time constraints?
<mfiano>
Unspecified.
<mayuresh>
okay, i really gotta go, stomach growling big time, gotta have something.
rogersm has quit [Ping timeout: 268 seconds]
<mayuresh>
ttyl
mayuresh has quit [Quit: Leaving]
<mfiano>
ecraven: Isn't there provisions for changing the shape of an array and how it is indexed etc?
<mfiano>
I think I remember reading that in the Guile manual some time ago, though that might not be an extension I suppose.
<ecraven>
it is all extensions, there's not even a standard way of getting an aliased subset of a byte array
<ecraven>
Scheme really only has the bare minimum (and often less ;)
<ecraven>
r7rs-large is about to change much of that, but it's been in the works for years, and will take years more
<mfiano>
Ah yes, as I mentioned, would need a bunch of extensions (some non-existent) to be close to CL
<mfiano>
That's the most disappointing thing to me about Scheme (not that I use it to be disappointed)
Cymew has quit [Ping timeout: 256 seconds]
<mfiano>
It's all a bunch of extensions, spread out among hundreds of implementations or a handful of specifications.
<mfiano>
I was sad to learn that when I read up on it some time ago (and I thought CL was fragmented)
<mfiano>
s/or/of/
<ecraven>
mfiano: one of my main gripes is that it is very strongly monomorphic.. so there's string-length, vector-length, bytevector-length, (list-)length, and about 15 other ...-lengths in the various srfis..
<ecraven>
I understand the reasoning, but that is just insane to actually *use*
<ecraven>
and this applies to *every* polymorphic procedure... especially for sequences, this is really hard to use
<ecraven>
but adding polymorphism to the base language is a very controversial topic, so
<ecraven>
I don't think that will ever happen
<mfiano>
I see
<ecraven>
I used to be a very strong supporter of lisp-1, wishing there were a lisp-1 CL, but I've since grown older and less strict in that view :D
<ecraven>
in the end, both are nice languages, but CL is definitely the one to use when your main goal is to actually get something to run
<ecraven>
also, the debuggability of CL is - in my limited experience - just unmatched in *any* other language (by far))
<ecraven>
meaning the way you can introspect and mutate a running program
[deleted] has quit [Read error: Connection reset by peer]
<mfiano>
Most definitely agreed.
livoreno has joined #commonlisp
<mfiano>
Languages that boast interactivity/hot code reloading are more like a bad joke in comparison, like Julia or Nim.
<ecraven>
that's why I've been working on r7rs-swank, but it's just a pale shadow of an actual full SWANK ;)
<ecraven>
I've never used those two for actual work
<ecraven>
I should get tracing working in r7rs-swank, I'm still using a lot of format-debugging
<mfiano>
I'm mostly a game developer/generative graphics tinkerer, so I appreciate the interactivity of CL more than most anything else
<mfiano>
Being able to iteratively recompile bits of my code at will and visually see those changes saves a lot of time, especially since such minor changes are tweaking colors and such. The downtime of the stop/recompile/restart process would not help with such minutia
<ecraven>
that's another example, there is no unified multi-threading support in Scheme implementations, so I haven't found a good way to run the REPL in a separate thread from the code....
<mfiano>
That's unfortunate
karlosz has quit [Quit: karlosz]
tyson2 has joined #commonlisp
Cymew has joined #commonlisp
attila_lendvai_ has quit [Ping timeout: 272 seconds]
random-nick has joined #commonlisp
<Posterdati>
ecraven: common lisp is also used in contexts for which you cannot physically access the computer, like space probes/rovers
<mfiano>
I'm not sure what answer you get and what you expect. I was just noting that (char= #\w #\ω) => NIL
tyson2 has quit [Ping timeout: 256 seconds]
<mfiano>
I don't believe this is a bug, but a dimensional analysis lesson.
McParen has joined #commonlisp
<McParen>
Hello, does anybody know how to contact the people running common-lisp.net? I wrote to their contact mail, I wrote to the admin mailing list, but I never got a reply.
<mfiano>
McParen: gendl may know.
<Xach>
there is a #common-lisp.net channel
<mfiano>
Posterdati: Infact, that link you posted mentions: "Thus a disc rotating at 60 revolutions per minute (rpm) is said to be rotating at either 2π rad/s or 1 Hz, where the former measures the angular velocity and the latter reflects the number of complete revolutions per second."
<Posterdati>
which is not exact either
<Posterdati>
frequency is not angular speed
<Posterdati>
"complete revolution per seconds" is one of definition
<Posterdati>
the complete revolution IS NOT radian
<Posterdati>
you can use rev / s
<mfiano>
It should be 2pi radians
<mfiano>
Which is infact what I get as a result
<beach>
Posterdati: "radian" is considered dimensionless in physics.
<Posterdati>
mfiano: I know what "dimensional analysis
<Posterdati>
" is
<beach>
Privately, I often use units that are considered dimensionless in physics, in some kind of extended dimension analysis, like byte, page, cache line, sector, pixel, etc.
<Posterdati>
beach: lucky you! :) eheheh
<mfiano>
So what do you expect with the above?
<beach>
I am not sure what a library is supposed to do if I multiply a frequency by 2π. It can't really guess that the unit should change. Perhaps, 2π just happens to be an arbitrary coefficient.
<ecraven>
Posterdati: I know, most Schemes *implementations* have some specific way to access threads, but nothing that is standardised, so it's not as useful as CL (even though threads are not part of the CL standard)
<Posterdati>
mfiano: ~314 rad/s
tyson2 has joined #commonlisp
<mfiano>
I'm also not sure
<mfiano>
But google will give you ~1973 as well
<Posterdati>
ecraven: the problem is that threads rely on OS libraries
<Posterdati>
f = 1 / T, T = period of the phenomenon, could be ANY periodic phenomena
<mfiano>
Yeah converting 2pi hz to rad/s is funny
<mfiano>
err 50(2pi)hz to rad/s
<pve>
mfiano: You mentioned generative graphics, do you use it when making games?
<mfiano>
Sure
<gendl>
McParen: what email did you try for common-lisp.net? And yes, there is #common-lisp.net
<mfiano>
I wasn't aware. Thanks gendl
<pve>
mfiano: That's fascinating. Do you happen to know if it is possible to create natural objects like trees, bushes, grass, etc. I mean things you might have in a typical 2D game scene.
<pve>
I've always assumed it's too hard to do.
<mfiano>
For trees look into L-systems; it's rather simple. For more natural stuff, you may get far with noise-based or cellular automaton
<mfiano>
Note that many channels (topics) won't allow you to join without registering your account, which I see you have not. This channel is not one of them, though.
<Guest96>
thanks, McParen -- will try clicking on that
<Guest96>
I seem to have missed any "getting started" instructions --- it's all just empty space to see, and a list of users
<mfiano>
IRC is a real time chat platform. If you see empty space, it means no one is currently chatting.
<phoe>
zulu.inuoe has truly achieved masterhood with this one
<shka>
oh god
<shka>
please no
<beach>
Heh.
<beach>
Great1
derelict has joined #commonlisp
* shka
cries in the corner
* OlCe
cries but laughs as well...
elf_fortrez has joined #commonlisp
<OlCe>
But doing an obfuscated code contest in CL is cheating if you don't forbid messing with readtables...
<phoe>
if you can fit something meaningful in your readtable in 2048 bytes or so, along with your payload, then I think it's worth being seen
<OlCe>
Ha ha
hendursa1 has quit [Quit: hendursa1]
<tyson2>
sorry, I don't think that Lisp needs an obfuscated code contest
<OlCe>
Never thought about it but I'm now already pretty sure that CL can beat C hands on for code obfuscation.
<jackdaniel>
`',foo is a rather popular idiom (i.e not meant for obfuscation)
<jackdaniel>
I sometimes see bugs in macros like `(something-something '(,@args)) where the desired form is `(something-something (list ,@args)) ; since it is not a singular case I think that there is some kind of programmer-blindness rooted in such construct
elf_fortrez has quit [Quit: Client closed]
<phoe>
you mean so that the resulting list is fresh instead of literal?
<phoe>
like, guaranteed to be fresh?
<jackdaniel>
hah, you've fallen to this too
<jackdaniel>
no, to guarantee that args are evaluated
<phoe>
:(
<phoe>
oooh
<phoe>
yes, I see it now
<jackdaniel>
programmer blindness /me nods to himself
<OlCe>
jackdaniel: Second form could be replaced by `(something-something ,args) as well, if preserving list structure is not important, or conversely something-something does not touch it.
<jackdaniel>
it can't
hendursaga has joined #commonlisp
<OlCe>
jackdaniel: Why couldn't it?
<pve>
I still don't see it, can someone please explain like I'm 5? :(
<phoe>
OlCe: if args is e.g. (1 2 3) then you do not want to expand into (something-something (1 2 3))
<phoe>
you rather want (something-something (list 1 2 3))
<phoe>
or (something-something 1 2 3) which has slightly different semantics
<jackdaniel>
say args are (foo bar), then `(ss '(,@args)) -> (ss '(foo bar)) ; `(ss ,args) -> (ss (foo bar)) ; `(ss (list ,@args)) -> (ss (list foo bar))
<OlCe>
Sure, forgot the '
<phoe>
or (something-something '(1 2 3)) which has the trap that jackdaniel mentioned
<jackdaniel>
these are three very different things
<phoe>
oh, so you meant (s-s ',args)
<OlCe>
`(something-something ',args)
<OlCe>
Yes
<jackdaniel>
your example implies that foo is a function
<jackdaniel>
the example with quote implies that foo and bar as treated as symbols
<jackdaniel>
the example with (list ,@args) implies that foo and bar are evaluated
<jackdaniel>
converserly dependoing on what ss does they may be further quoted or treated differently, but that's beside the point
<OlCe>
So it's seems I've fallen to it as well... ;-)
<OlCe>
Although I have been using the second form regularly in macros.
<phoe>
this would make a nice blogpost I think
cage has quit [Remote host closed the connection]
<dieggsy>
I've got something rather odd happening where i do a (mapcan #'some-fn some-list) in the repl and it works fine the first time but hangs if i try the exact same thing again
<dieggsy>
not really sure where to start investigating that
<dieggsy>
...i think it even happened when i copy-seq'ed the list
<beach>
I am guessing you have a literal list.
<beach>
Hmm.
<dieggsy>
it's not a literal list
<beach>
Maybe you are creating a circular list then.
<dieggsy>
huh. maybe so
<dieggsy>
I'd have to look at the specifics of my functions. i didn't write them lol
<Bike>
does some-fn not return fresh lists? that would do it
<beach>
I guess if the same list is processes twice, there is that risk.
<dieggsy>
Bike: oh, i don't think it does actually
<Bike>
mapcan nconcs the results together, see
<dieggsy>
ah, that's. destructive huh
<phoe>
dieggsy: use (mapcar #'copy-seq some-lists)
<phoe>
or alexandria:mappend instead of mapcan
<dieggsy>
neat, thanks guys. i hate destructive functions with a passion jaja
<phoe>
then you're gonna be good friends with mappend
<Bike>
yeah, the lack of mappend in the standard kinda blows, but at least alexandria has it
IAmRasputin has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
<kathe>
i think xach (mr. beane) is the most powerful force in promoting commonlisp.
<kathe>
one should just follow his twitter timeline.
<kathe>
and then there's mr. rainer joswig too.
<kathe>
mr. joswig is totally a commonlisp jedi master. :)
<kathe>
anyone here working with commonlisp under ubuntu?
<jackdaniel>
many
<kathe>
i tried to get the hyperspec via "apt" the ftp url failed.
<kathe>
wrote to martin simmons, he asked me to download it over http.
<kathe>
that worked.
<jackdaniel>
good for you ,)
<kathe>
:)
<kathe>
it's quite impressive the way it was marked up via a lisp program.
<kathe>
the original was a set of text files from xerox.
<kathe>
again the original is unavailable.
karlosz has joined #commonlisp
<kathe>
are any of the french around at the moment? say beach!
<kathe>
i mean the person named "beach".
<jackdaniel>
yes, he is on this channel (although currently away from keyboard, will be in early morning tomorrow probably)
<Bike>
beach is out for the day
Alfr has joined #commonlisp
<kathe>
yeah, beach usually is on around mid-day my time.
<kathe>
we chat a bunch.
<kathe>
he's crazy mad about "practical common lisp".
<kathe>
is browsed through 'pcl' on the gigamonkeys website.
<kathe>
it seems working through 'pcl' is like going through community college.
<kathe>
kind of exposure to trade craft.
<kathe>
but not in depth knowledge about the foundations
<kathe>
like what paul graham delivers.
<jackdaniel>
kathe: while expressing ones attitude to books and various lispers (i.e by praising them) is certainly fun for these people - this isn't very much on topic on this channel
<kathe>
jackdaniel: didn't know about these restrictions. sorry, will not happen again.
<kathe>
just joined 10 days back.
<kathe>
wasn't aware.
<jackdaniel>
no worries. this channel is known for strict on-topicness (well, not always very strict, but still)
<jackdaniel>
there is #lispcafe for offtopic (but there are less people than here)
<kathe>
i like on-topicness. :)
<jackdaniel>
great!
<kathe>
i tried hanging out on clschool
<kathe>
not much activity there.
<kathe>
though found out about cliki from there. :)
<kathe>
i am using a console 'irc' client called "ircii", how do i check who's online?
<kathe>
sorry about the off-topic line.
<kathe>
would appreciate receiving links to tutorials on the web.
<kathe>
there was a book called "irc hacks" which has gone out of print.
<Bike>
most irc clients have it under /names or something
<kathe>
thanks bike
<kathe>
okay didn't find anything relevant on google, now searching for a 'gui' 'irc' client for ubuntu.
<kathe>
is mr. rainer joswing in/on this channel? right now!
<McParen>
has for the type of trolling performed by c.l.l. "gavino" ever been coined a name?
<kathe>
there are trolls here too?
<kathe>
that's sad.
<Bike>
c.l.l is usenet, not here
<kathe>
okay.
<McParen>
something similar to "sealioning" but for the type of people who ask an endless series of trivial questions, one more nonsensical than the other, trying to wear down people trying to answer them?
Lycurgus has joined #commonlisp
<kathe>
McParen, that gavino person does all that "on purpose" or is it just naivete?
<Lycurgus>
on purpose
<McParen>
"The term sealioning, coined by David Malki in his webcomic Wondermark, describes someone who pretends to be clueless about an issue in order to waste your time."
<kathe>
man, where do such people find the time and motivation to do it?
<Lycurgus>
gavino is a celebrity level troll
varjagg has joined #commonlisp
<kathe>
gavino must be quite a mean person by nature.
<phoe>
or with a distorted personality
<kathe>
phoe, do you intend to mean deranged? ;)
<phoe>
it takes real distortion to keep on doing abusive things like that year after year after year
<phoe>
kathe: that too
<kathe>
i faced such a guy on the forth channel, he was russian.
<kathe>
forth on freenode.
<kathe>
i've forgotten his name and handle, but he used to work on gforth.
<kathe>
he contributed to gforth heavily, yet kept abusing forth on a forth channel.
<kathe>
never mind.
* phoe
hmmms, gently opens the #lispface door
<kathe>
about commonlisp, has anyone attempted using sublimetext for commonlisp development?
<phoe>
kathe: yes, see slymlime as a slynk client
<phoe>
slyblime*
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
selwyn has joined #commonlisp
mister_m has joined #commonlisp
<kathe>
thanks phoe.
<kathe>
phoe, i heard that you are working with weitz on clr2?
selwyn has quit [Read error: Connection reset by peer]
<kathe>
okay, i gotta go now.
<kathe>
phoe, if you are working on clr2, loads of good luck.
<kathe>
bye
<kathe>
ttyl.
kathe has quit [Quit: Leaving]
frgo_ has joined #commonlisp
frgo has quit [Ping timeout: 256 seconds]
tyson2 has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
treflip has quit [Remote host closed the connection]
prxq has joined #commonlisp
<phoe>
minion: memo for kathe: yes, I am working on clr2; thank you!
<minion>
Remembered. I'll tell kathe when he/she/it next speaks.
<McParen>
If I have a class person and slot age, is it more common to name the accessor person-age or just age? And if I have a subclass child, is it common to define an accessor for the inherited slot child-age, or should person-age be used also for child?
<McParen>
Are there drawbacks to naming the accessors the same way as the slots?
<Bike>
usually just age, and you can use the same accessor for both
<Xach>
McParen: i find it helps to think of the functions first, then design the classes to support the functions, not the other way around
<Xach>
McParen: i don't always use that style all the way through, but i do find it helps when thinking about things.
<McParen>
Xach: in this case, the functions are not supposed to do more than just access the slots.
<Xach>
McParen: the fact that it accesses a slot is an implementation detail - if i want a function that returns the age of an object, I call it AGE. And if that is a matter of accessing a slot, that makes the choice in :reader or :accessor easy - but it could just as well be computing from some other slot and some other info.
<Xach>
Or not using a standard object instance at all
<Xach>
Again, I don't always end up designing this way, but it helps me think about it more clearly
<McParen>
I want to access a property named "position", but that is unfortunately already named in the standard cl package, and since I do not want to break :use, I opted to add the class name to position, widget-position. So I wondered whether it is "intuitive" to add the same accessor for child classes, so that if you want to access "button-position" for example, you do not have to find out its parent class.
<Bike>
you don't need to add accessors. an accessor that works on a parent class works on the child as well
<McParen>
Bike: I know, but my question was whether this is customary in CL APIs or not, or do APIs commonly just provide the accessor for the parent.
<Xach>
McParen: I don't think there's any single common pattern, i have seen a lot of different styles. my preference is not to have classes be part of names like that (to the degree possible - the symbol clash is a good example of when a workaround is needed somehow)
<Bike>
it's not so much "customary" as "required". you are talking about defclass, right? you can't make an accessor that works on a parent and doesn't work on the child without going really out of your way
<Xach>
They're called "generic" functions for a reason
<McParen>
That I know. ;)
<Bike>
if you mean, do CL APIs usually expose several differently named functions that access the same slot, the answer is no
<Bike>
it might happen occasionally, i guess
<Xach>
different functions that access the same slot is really handy!
<Xach>
i just don't think it's done in a way just to incorporate the class hierarchy into the accessor
<Bike>
right
<Bike>
that doesn't do anything but make it more of a pain to figure out which function to use
<McParen>
Bike: that was essentially my question, yes. so thanks.
shka has quit [Ping timeout: 272 seconds]
cage has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
Alfr has quit [Quit: Leaving]
mister_m has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
slyrus has joined #commonlisp
bilegeek has joined #commonlisp
frgo has joined #commonlisp
AnimalClatter has joined #commonlisp
frgo has quit [Read error: Connection reset by peer]
frgo__ has joined #commonlisp
frgo_ has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #commonlisp
dsk has quit [Ping timeout: 240 seconds]
McParen has left #commonlisp [#commonlisp]
bilegeek has quit [Quit: Leaving]
tyson2 has quit [Ping timeout: 268 seconds]
akoana has joined #commonlisp
Oladon has quit [Quit: Leaving.]
tyson2 has joined #commonlisp
pve has quit [Ping timeout: 268 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
cuz has quit [Ping timeout: 272 seconds]
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.2)]
mister_m has joined #commonlisp
IUSR has quit [Read error: Connection reset by peer]
gendl has quit [Ping timeout: 272 seconds]
iisi has quit [Read error: Connection reset by peer]
jmercouris has quit [Read error: Connection reset by peer]
AnimalClatter has quit [Quit: WeeChat 3.0.1]
lad has quit [Remote host closed the connection]
jmercouris has joined #commonlisp
iisi has joined #commonlisp
gendl has joined #commonlisp
notzmv has quit [Ping timeout: 252 seconds]
IUSR has joined #commonlisp
notzmv has joined #commonlisp
notzmv has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
varjagg has quit [Ping timeout: 268 seconds]
silasfox has quit [Ping timeout: 240 seconds]
silasfox has joined #commonlisp
frgo__ has quit [Remote host closed the connection]
frgo has joined #commonlisp
char has joined #commonlisp
<char>
For arrow macros, is there any idomatic way to pass arguments to nth argument to the next function? would an n-> macro make sense and would it fit into binding-arrows phoe?
wilfred has joined #commonlisp
attila_lendvai has quit [Ping timeout: 268 seconds]
akoana has quit [Quit: leaving]
random-nick has quit [Ping timeout: 272 seconds]
mister_m has quit [Remote host closed the connection]
mister_m has joined #commonlisp
<phoe>
char: -<>
<contrapunctus>
Josh_2: is there an existing Matrix protocol client library you used for your bot? I couldn't find one despite much searching...
<phoe>
I don't see how a n-> would be a big improvement over it
<phoe>
I mean, you'd need to specify an argument number instead of a location of the argument
<phoe>
so you'd be trading something like (n-> x 3 (f a b c d)) for (-<> x (f a b <> c d))
<phoe>
and the latter is cleaner to me beacuse of its explicit argument positioning
notzmv has joined #commonlisp
taiju has quit [Remote host closed the connection]