jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | offtopic --> #lispcafe
bilegeek has quit [Quit: Leaving]
random-nick has quit [Ping timeout: 260 seconds]
<npfaro`> How do I write a large list to a stream such that I can read it back in later?
<npfaro`> prin1 is doing (1 2 3 4 ...)
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<npfaro`> so is `write`
<npfaro`> so does pprint
<travv0> you sure that's what's written to the stream and not just your repl printing the return value?
bendersteed has quit [Quit: bye]
judson_ has joined #lisp
VincentVega has quit [Quit: Connection closed]
<Bike> Do you mean that it's printing ellipses? That's because of *print-length*.
<phoe> npfaro`: (with-standard-io-syntax (prin1 list stream))
Oddity has quit [Quit: Quit]
patience_ has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
akoana has joined #lisp
akoana has left #lisp [#lisp]
luckless has quit [*.net *.split]
hendursaga has quit [*.net *.split]
Aurora_v_kosmose has quit [*.net *.split]
madage has quit [*.net *.split]
cantstanya has quit [*.net *.split]
jeosol has joined #lisp
DarthVoyage has left #lisp [#lisp]
<npfaro`> thanks phoe
v0|d has quit [Remote host closed the connection]
<npfaro`> Is there any way to force printing a list with each value on a new line
<Bike> you can do that kind of thing with the pretty printer, or you can do it manually
<npfaro`> Of all the knobs here http://clhs.lisp.se/Body/f_wr_pr.htm i'm not sure which one to use to get that sort of thing
<npfaro`> I guess it's not a biggie
<ralt> loke: I've seen in some logs that you managed to get signals from dbus, would you care to share some snippets to do this? I want to subscribe to a known signal but unclear what I'm supposed to do.
<livoreno> I think it's prin1
<livoreno> nevermind, it's plain print npfaro`
<ralt> loke: actually I just found your github repo with it, nevermind!
madage has joined #lisp
Aurora_v_kosmose has joined #lisp
Oddity has joined #lisp
npfaro` has quit [Ping timeout: 256 seconds]
hendursaga has joined #lisp
cantstanya has joined #lisp
luckless has joined #lisp
rumbler31_ has quit [Ping timeout: 246 seconds]
aspr has joined #lisp
cer0 has quit [Quit: leaving]
patience_ has quit [Ping timeout: 256 seconds]
dbotton has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nrh^ has joined #lisp
npfaro has joined #lisp
judson_ has joined #lisp
mathrick has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
aspr has quit [Quit: Leaving]
aspr has joined #lisp
aspr has quit [Client Quit]
aspr has joined #lisp
iskander- has joined #lisp
orivej has joined #lisp
aspr has quit [Client Quit]
iskander has quit [Ping timeout: 246 seconds]
aspr has joined #lisp
aspr has quit [Client Quit]
martinjungblut has joined #lisp
<martinjungblut> what is a good way of iterating by two elements at a time on a list?
Fare has joined #lisp
<npfaro> (loop for (a b) on '(1 2 3 4) by #'cddr collect (cons a b))
<npfaro> ((1 . 2) (3 . 4))
<npfaro> like this?
<martinjungblut> oh that's brilliant!
<martinjungblut> yes! wonderful
<martinjungblut> thanks
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 264 seconds]
X-Scale` is now known as X-Scale
<npfaro> i don't know if that's the best way haha. if anyone else has a better idea please chime in
<martinjungblut> npfaro: that was really great, though
<martinjungblut> definitely helpful
bjorkint0sh has joined #lisp
bjorkintosh has quit [Ping timeout: 260 seconds]
nullman has quit [Ping timeout: 265 seconds]
<aeth> That is a very good way to do it
<aeth> The only issue is that it won't error if it's not even
<Alfr_> martinjungblut, careful if list has a odd number of elements, then on the last iteration b will be nil; just keep that in mind that it won't error.
<martinjungblut> actually, I kind of need it that way
<aeth> destructuring bind will force an error, unlike LOOP's destructuring, but it's not as elegant. (loop for sublist on '(1 2 3) by #'cddr collect (destructuring-bind (a b &rest rest) sublist (declare (ignore rest)) (cons a b)))
<Alfr_> aeth, :D
nullman has joined #lisp
<martinjungblut> well, not need, but the nil is fine
<martinjungblut> as a newcomer, I have to say, Common LISP is a hell of an environment to write software in
<aeth> Oh, and there's an in between route, which is to do the sublist thing, but then destructure it in the next LOOP variable instead of having local d-b variables.
<aeth> Because then you can manually check
<aeth> Something like: for (a b) = (if (endp (cdr sublist)) (error ...) sublist)
<aeth> Probably not quite that simple
<martinjungblut> thanks a lot!
skapata has quit [Remote host closed the connection]
dbotton has quit [Quit: Leaving]
<npfaro> is there any way to convert a number into a list of bytes without manual bit shifting
aeth_ has joined #lisp
<Bike> clhs ldb
aeth has quit [Ping timeout: 264 seconds]
<npfaro> :O
<npfaro> beautiful
aeth_ is now known as aeth
<Bike> this only gets one byte at a time, so you'll still be constructing a list yourself
<npfaro> just what i needed
<Bike> glad to hear it
<npfaro> Is there any better idiom for an increasing counter in loop than (loop for i = 0 then (1+ i))
<Bike> (loop for i from 0 ...)
<npfaro> thanks
<Bike> clhs 6.1.2.1.1
<specbot> The for-as-arithmetic subclause: http://www.lispworks.com/reference/HyperSpec/Body/06_abaa.htm
<Bike> for all the details
<npfaro> this is like my fourth day of using CL and loop is so tasty
<loke[m]> LOOP is indeed very nice.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Fare has quit [Ping timeout: 264 seconds]
judson_ has joined #lisp
hsaziz has joined #lisp
hsaziz has quit [Client Quit]
<emaczen> What is the the timezone in encode and decode universal-time? I don't see a description in the docs
kapil_ has quit [Ping timeout: 246 seconds]
<Bike> clhs encode-universal-time
<Bike> let's see
<Bike> right, it's in the glossary
<Bike> "time zone n. a rational multiple of 1/3600 between -24 (inclusive) and 24 (inclusive) that represents a time zone as a number of hours offset from Greenwich Mean Time. Time zone values increase with motion to the west, so Massachusetts, U.S.A. is in time zone 5, California, U.S.A. is time zone 8, and Moscow, Russia is time zone -3."
Alfr has joined #lisp
Alfr_ has quit [Ping timeout: 260 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach> Good morning everyone!
<emaczen> Bike: Where is the glossary?
<Bike> if you look at the bottom menu on clhs pages, the glossary is there between "symbol index" and "x3j13 issues"
kapil_ has joined #lisp
<Bike> sometimes there are links to entries, in italics in other pages
judson_ has joined #lisp
mindCrime_ has quit [Ping timeout: 260 seconds]
patience_ has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
mindCrime_ has joined #lisp
ebrasca has joined #lisp
<ebrasca> Good morning!
<beach> Hello ebrasca.
<ebrasca> beach: How are you doing?
ym has quit [Ping timeout: 264 seconds]
mindCrime_ has quit [Ping timeout: 264 seconds]
<beach> I am doing very well thank you. I am currently working on updating the SICL specification to adapt it to the many new ideas and extracted libraries that have happened since last time I worked much on it.
ym has joined #lisp
<beach> ebrasca: What about yourself?>
andreyorst has joined #lisp
<ebrasca> beach: I am fine. I am playing with cepl.
<beach> Great!
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
judson_ has quit [Client Quit]
zmv has joined #lisp
judson_ has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
livoreno has quit [Ping timeout: 264 seconds]
nrh^ has quit []
judson_ has quit [Client Quit]
judson_ has joined #lisp
Core6069 has joined #lisp
judson_ has quit [Client Quit]
Bike has quit [Quit: sleeping]
karlosz has quit [Quit: karlosz]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
kapil_ has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
kapil_ has joined #lisp
mrcom has joined #lisp
kapilp has joined #lisp
kapil_ has quit [Read error: Connection reset by peer]
zerno_ has quit [Quit: This computer has gone to sleep]
mrcom has quit [Ping timeout: 265 seconds]
mrcom has joined #lisp
inoteajw has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
mrcom has quit [Ping timeout: 265 seconds]
Sauvin has joined #lisp
mrcom has joined #lisp
mathrick has quit [Ping timeout: 240 seconds]
mathrick has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
narimiran has joined #lisp
luckless has quit [Quit: luckless]
luckless has joined #lisp
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
waleee-cl has quit [Quit: Connection closed for inactivity]
andreyorst has quit [Ping timeout: 240 seconds]
andreyorst` has joined #lisp
j0nd0e has joined #lisp
Nilby has joined #lisp
emaczen has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
rgherdt has joined #lisp
lowryder has quit [Ping timeout: 246 seconds]
lowryder has joined #lisp
adam4567 has joined #lisp
aartaka has joined #lisp
inoteajw has quit []
mrcom has joined #lisp
rogersm has joined #lisp
dra_ has joined #lisp
dra_ is now known as dra
martinjungblut has quit [Quit: Leaving.]
pve has joined #lisp
euandreh_ has quit [Remote host closed the connection]
Cymew has joined #lisp
skapata has joined #lisp
euandreh_ has joined #lisp
<npfaro> Stupid question but how do I use the values returned by cl-json
<npfaro> ((:TRANSLATIONS ((:TRANSLATION . "Do you think that's a good thing to do?"))) (:WORD--COUNT . 7) (:CHARACTER--COUNT . 17))
<npfaro> How do i even index into this
gaqwas has joined #lisp
gaqwas has joined #lisp
<phoe> npfaro: looks like a list of plists
<phoe> oh, wait, no! it's an alist!
<npfaro> oh, so assoc?
<phoe> use ASSOC and RASSOC
<npfaro> ooh rassoc
<phoe> or alexandria's ASSOC-VALUE and RASSOC-VALUE
<npfaro> thanks
zerno_ has joined #lisp
<npfaro> another dumb question, how do you test if a string starts with a substring
<npfaro> i can't seem to find a predicate for it, so should i just make a substring and check that
<beach> clhs mismatch
<beach> maybe?
krkini has joined #lisp
kini has quit [Ping timeout: 264 seconds]
<npfaro> it'll do the trick but damn that's unorthodox
zerno_ has quit [Client Quit]
<phoe> (eql 0 (search "asdf" "asdfasdfasdf"))
<phoe> but that'll be less effective than mismatch
<beach> Absolutely.
<phoe> (eql (mismatch "asdf" "asdfasdfasdf") (length "asdf"))
<phoe> but!
<phoe> (alexandria:starts-with-subseq "asdf" "asdfasdfasdf")
<beach> npfaro: "Unorthodox" how?
<npfaro> Normally you'd have a function called starts-with? or something
<phoe> that's what alexandria provides
<beach> That's a special case.
<beach> npfaro: The mismatch function is a lot more versatile.
varjag has joined #lisp
<beach> npfaro: Perhaps it is unorthodox because most languages don't allow keyword arguments to modify the behavior, and they don't allow "out of band" return values.
<beach> npfaro: Lots of things about Common Lisp are that way, luckily. CLOS, the condition system, macros, keyword arguments, multiple values, etc.
<npfaro> The only issue is that mismatch returns nil when the arguments are equal, so (zerop (mismatch ...)) breaks when they're equal
<beach> It's a bit sad, though, that the intrinsic limitations of other languages would make them "orthodox".
ukari has quit [Remote host closed the connection]
<loke[m]> Can't you do something like (NOT (MISMATCH s1 s2 :end1 #1=(min (length s2) (length s2)) #1#))
<Nilby> In my own far off world that matters little, I say begins-with and ends-with, because I find the mismatch and search forms unintuitive.
liberliver has joined #lisp
<loke[m]> I agree with that. I prefer using the Alexandria functions for that.
<beach> loke[m]: Did you mean NULL rather than NOT?
aartaka_d has joined #lisp
<loke[m]> beach actually I meant NOT, because the CLHS specifically says that MISMATCH returns “false”
<beach> Oh dear!
<beach> Note to self: In WSCL, consider specifying that MISMATCH returns NIL as a default value.
<loke[m]> I think it makes sense. MISMATCH is a predicate function that also happens to return a useful value when returning true. :-)
<beach> That's certainly one way of looking at it.
aartaka has quit [Ping timeout: 265 seconds]
dra has quit [Quit: Leaving]
estadocuantico has joined #lisp
<loke[m]> Speaking of nil, I saw someone complaining about the terms NULL and NIL. He suggested a compromise: NILL
<beach> But, but, they are totally different.
<loke[m]> I think he meant null in Java (and others), vs. NIL in Lisp (and others)
<beach> (typep x 'nil) and (typep x 'null) are not the same.
<beach> Oh, I see.
<phoe> how about NUL
<loke[m]> I'm sure it was a joke based NILL being such a silly word.
<beach> Unlike RPLACA, you mean?
zyz has joined #lisp
<loke[m]> Unlike RPLACA
aeth has quit [Ping timeout: 240 seconds]
<loke[m]> And SUMLIS
<loke[m]> I mean SUBLIS
<edgar-rft> where's a WILL there's a NILL
jeosol has quit [Ping timeout: 248 seconds]
<edgar-rft> but that sounds willy-nilly
* beach goes back to updating the SICL specification.
<loke[m]> Hmm, RPLACA, SUBLIS... Was there a max 6 character symbol length in the first Lisp?
<beach> It may have been the case that you could fit 6 characters in a 36-bit word at some point.
<phoe> only six 6-bit chars fit in a 36-bit word
<phoe> oh yes
aeth has joined #lisp
<loke[m]> Oh yes. The IBM 704 is a 36-bit machine.
random-nick has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
galex-713 has quit [Ping timeout: 265 seconds]
estadocu` has joined #lisp
estadocuantico has quit [Ping timeout: 265 seconds]
estadocu` has quit [Remote host closed the connection]
estadocu` has joined #lisp
j0nd0e` has joined #lisp
zmv has quit [Ping timeout: 265 seconds]
estadocu` has quit [Remote host closed the connection]
estadocu` has joined #lisp
j0nd0e has quit [Ping timeout: 265 seconds]
anticrisis_ has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
<frodef> is allegro's (case sensitive) "modern mode" still alive, does anyone know?
Nilby has quit [Read error: Connection reset by peer]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
<moon-child> frodef: I don't know, but fwiw readtable-case is a thing
rogersm has quit [*.net *.split]
kaisyu[m] has quit [*.net *.split]
infra_red[m] has quit [*.net *.split]
jonathan| has quit [*.net *.split]
karstensrage has quit [*.net *.split]
astronavt has quit [*.net *.split]
phadthai has quit [*.net *.split]
XachX has quit [*.net *.split]
jdz has quit [*.net *.split]
infra_red[m] has joined #lisp
XachX has joined #lisp
karstensrage has joined #lisp
jdz has joined #lisp
rogersm has joined #lisp
jonathan| has joined #lisp
kaisyu[m] has joined #lisp
phadthai has joined #lisp
astronavt has joined #lisp
tassleoff_ has joined #lisp
karstensrage has quit [Max SendQ exceeded]
wxie has quit [Remote host closed the connection]
wxie has joined #lisp
[d] has quit [Ping timeout: 264 seconds]
7ITAAI1SC has quit [Ping timeout: 246 seconds]
jonas[m]2 has quit [Ping timeout: 240 seconds]
santiagopim[m] has quit [Ping timeout: 240 seconds]
32NAAL4OF has quit [Ping timeout: 240 seconds]
anotherone9999[m has quit [Ping timeout: 240 seconds]
[d] has joined #lisp
Lolicon[m] has quit [Ping timeout: 268 seconds]
stargazesparkle has quit [Ping timeout: 268 seconds]
infra_red[m] has quit [Ping timeout: 242 seconds]
chipk[m] has quit [Ping timeout: 240 seconds]
posthuman_egrego has quit [Ping timeout: 240 seconds]
dmiles[m] has quit [Ping timeout: 240 seconds]
loke[m] has quit [Ping timeout: 260 seconds]
katco has quit [Ping timeout: 246 seconds]
quanta[m] has quit [Ping timeout: 240 seconds]
Gnuxie[m] has quit [Ping timeout: 240 seconds]
even4void[m] has quit [Ping timeout: 240 seconds]
tmalsburg[m] has quit [Ping timeout: 246 seconds]
arichiardi[m] has quit [Ping timeout: 240 seconds]
kaisyu[m] has quit [Ping timeout: 258 seconds]
MrtnDk[m] has quit [Ping timeout: 268 seconds]
mrcom has joined #lisp
harlchen has joined #lisp
deselby has quit [Ping timeout: 244 seconds]
etimmons has quit [Ping timeout: 244 seconds]
ecm has quit [Ping timeout: 244 seconds]
solideogloria[m] has quit [Ping timeout: 244 seconds]
ThaEwat has quit [Ping timeout: 244 seconds]
cairn has quit [Ping timeout: 244 seconds]
keizerrijk[m] has quit [Ping timeout: 240 seconds]
eymebolofscrumpe has quit [Ping timeout: 240 seconds]
christopheroei[m has quit [Ping timeout: 240 seconds]
skye0[m] has quit [Ping timeout: 240 seconds]
malaclyps_ has quit [Ping timeout: 240 seconds]
jdormit[m] has quit [Ping timeout: 240 seconds]
ms[m] has quit [Ping timeout: 246 seconds]
susam has quit [Ping timeout: 246 seconds]
dieggsy has quit [Ping timeout: 268 seconds]
scymtym has quit [Ping timeout: 264 seconds]
[d] has quit [Ping timeout: 264 seconds]
[d] has joined #lisp
surabax has joined #lisp
heisig has joined #lisp
tassleoff_ is now known as tassleoff
mbomba has joined #lisp
VincentVega has joined #lisp
mbomba has quit [Client Quit]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
shenghi1 has quit [Quit: WeeChat 2.9]
shenghi has joined #lisp
adam4567 has quit [Remote host closed the connection]
VincentVega has quit [Quit: Ping timeout (120 seconds)]
pfdietz has quit [Quit: Ping timeout (120 seconds)]
VincentVega has joined #lisp
arora has joined #lisp
scymtym has joined #lisp
<pve> Hi, I'm thinking about how to organize the compilation order of my program. Is there an easy way to tell ASDF to load a file A from source (to get some basic functionality) then compile and load some other files to extend the functionality and finally compile and reload file A to ensure that the fasl is built with the full functionality?
<pve> This would be one possible alternative I'm considering..
voidlily has quit [Ping timeout: 264 seconds]
<arora> I am new to lisp, my university professor suggested to learn it for AI course, what's a good way to start?
Guest33533 has joined #lisp
<arora> is it good for AI when compared to Python?
<beach> arora: Most AI today is based on "deep learning", but for traditional AI, Common Lisp is both faster and more expressive than Python.
<beach> arora: In addition to PCL, I suggest you check out PAIP for AI.
<beach> minion: Please tell arora about PAIP.
<minion> arora: PAIP: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp
<arora> and what is PCL?
<arora> oh nevermind
<beach> minion: Please tell arora about PCL.
<minion> arora: look at PCL: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<beach> arora: But PCL is more generally about programming in Common Lisp.
<arora> Python has libraries like sklearn and numpy which makes AI easier, what does lisp have as equivalent?
<beach> arora: I don't know what those libraries do, but some others here might. Not many people here use Common Lisp for AI-like stuff.
<arora> beach: Yea that's what I thought too, I hadn't heard of Lisp being used for AI before
<arora> Thanks phoe
<arora> I know a bit of lisp because of emacs
<beach> arora: Oh, it use to be THE AI language.
<TMA> arora: From what I understand, those libraries are just python wrappers over some C and Fortran libraries. The wrappers are necessary, because python by itself is too slow for any kind of numerical computation.
<moon-child> lisp was traditionally used quite a lot for ai. The creator of lisp was also the coiner of the term 'ai'
voidlily has joined #lisp
wxie has quit [Ping timeout: 265 seconds]
mrcom has quit [Ping timeout: 265 seconds]
zyz has quit [Ping timeout: 265 seconds]
<arora> TMA: but since a lot of people use them in python, it became the "standard" of doing AI
<arora> moon-child: oh wow
ljavorsk has joined #lisp
anotherone9999[m has joined #lisp
<edgar-rft> CL has wrappers, too -> https://www.cliki.net/cl-blapack
<phoe> AI meant something different in the 70s than it means now though
<TMA> arora: This is less necessary with Common Lisp compilers that produce fast native code. However, the utility of libraries goes beyond any speedup, they reduce the amount of work a programmer is required to perform. There are Common Lisp libraries for numerical computations, for GPU interfacing, and others that can help you.
<phoe> at least implementation-wise
<edgar-rft> AI in the 1970s meant "Artificial Intelligence", AI in 2021 means "Anal Intercourse"
<phoe> well that escalated quickly
<TMA> arora: It used to be so that Latin was the language of science. Fashion changes. Python is now considered fashionable whereas lisp is thought of as démodé.
<TMA> arora: (Mostly by those that manage any development, having no knowledge of either.)
<arora> I had people in my class talk bad about lisp because it does like a prefix notation of computation, like 5 + 2 = + 5 2
<beach> arora: Ignore those ignorant people.
<beach> arora: Because they must not understand the virtues of that notation.
<arora> since its quite different from the other languages, I dont see how its useful either, why does lisp have a different notation?
<edgar-rft> Lisp indeed helped me to understand math better because I do not need to learn stupid precedence rules.
<beach> arora: The term is "homoiconicity" and it lets the programmer manipulate programs as data more easily than other notation.
winny has quit [Ping timeout: 268 seconds]
<beach> arora: Other languages insist on making such manipulation hard.
logand has joined #lisp
<beach> arora: But Common Lisp macros represent a powerful extension mechanism that is made easy with homoiconicity. Other language users have to wait for the updated standard for similar extensions.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<arora> What does homoiconicity mean in simple terms?
mrcom has joined #lisp
<beach> That programs and data have the same shape.
grobe0ba has quit [Quit: ZNC 1.7.5 - https://znc.in]
<beach> arora: Wikipedia has a page on it.
<arora> so if I understand it correctly, new code can alter old code?
<logand> common lisp macros are great, but should be used sparingly. it is much easier to use a function at compile time by wrapping it in macro as opposed to using macro at runtime by wrapping it in funcall+compile+backquote+lambda
<edgar-rft> arora: in Lisp it's for example dead easy to write code generators
<beach> Yes, but that's not how it is used very often. Instead, it is used in macros, so that the macro function (which is just code) can generate new code from some input code.
<arora> oh like templates in c++
<beach> arora: C++ templates are a joke compared to Common Lisp macros.
<edgar-rft> macros *are* programmable code generators :-)
<beach> arora: In Common Lisp, the same language (i.e. Common Lisp) is used to manipulate code as the one used to manipulate other data.
grobe0ba has joined #lisp
zerno_ has joined #lisp
<beach> arora: I don't think it is possible to understand the power of Common Lisp by comparing it the knowledge of the existing languages you know. You need to learn it to "get" it.
<arora> Alright, I will learn it and ask questions along the way.
<beach> Perfect!
<beach> arora: There is also #clschool for truly elementary questions.
<beach> arora: #lisp is more for people who use it in some non-trivial way, or people who write compilers and other language tools.
<arora> Okay I will join that too
<arora> compilers?
<arora> in lisp?
<beach> Yes, Common Lisp compilers.
<beach> Or other compilers I suppose.
zerno_ has quit [Client Quit]
<arora> That's cool
<beach> arora: In case you wonder, there is no such thing as a compiler or interpreted programming language. Those are properties of the implementation. Most Common Lisp systems compile on the fly.
<beach> as a *compileD
<beach> arora: That is why a typical Common Lisp implementation is 50 times faster than Python.
winny has joined #lisp
<arora> Aren't languages that support REPL interpreted?
<beach> Nope.
<arora> Oh
<beach> Another common misconception.
<beach> Well, you have a lot to learn, but you have started, so that's good.
etimmons has joined #lisp
deselby has joined #lisp
dmiles[m] has joined #lisp
Gnuxie[m] has joined #lisp
ThaEwat has joined #lisp
even4void[m] has joined #lisp
kaisyu[m] has joined #lisp
christopheroei[m has joined #lisp
ms[m] has joined #lisp
stargazesparkle has joined #lisp
MrtnDk[m] has joined #lisp
katco has joined #lisp
tmalsburg[m] has joined #lisp
jdormit[m] has joined #lisp
quanta[m] has joined #lisp
santiagopim[m] has joined #lisp
infra_red[m] has joined #lisp
solideogloria[m] has joined #lisp
cairn has joined #lisp
arichiardi[m] has joined #lisp
dieggsy has joined #lisp
posthuman_egrego has joined #lisp
susam has joined #lisp
skye0[m] has joined #lisp
malaclyps_ has joined #lisp
loke[m] has joined #lisp
eymebolofscrumpe has joined #lisp
ey[m] has joined #lisp
ecm has joined #lisp
chipk[m] has joined #lisp
Lolicon[m] has joined #lisp
jonas[m]2 has joined #lisp
ey[m]1 has joined #lisp
keizerrijk[m] has joined #lisp
<arora> Most of my friends are learning languages to get a job and make money and since lisp is unheard of, it is hard to find people who use that.
zerno_ has joined #lisp
<beach> If that's your goal, then sure, learn something else. On the other hand, if you like to know sophisticated programming techniques to become more productive, then Common Lisp is a good start.
<edgar-rft> arora: I already made money with Lisp, for just the simple reason that nobody wanted to do it than me (no joke).
<frodef> one of life's hard choices :-)
npfaro has quit [Read error: Connection reset by peer]
<arora> I don't really have a goal, I just wanna program and live peacefully.
<arora> edgar-rft: Wow, I read something similar about COBOL a while back.
mrios22 has joined #lisp
<beach> arora: I think you will find that Common Lisp programmers (many of which hang out here) are on the average more knowledgeable than programmers of other languages, so if you like to hang out with smart people, Common Lisp is good.
<beach> I think the reason for that is in fact that Common Lisp is a bit tough in the beginning. So only more knowledgeable people are willing to attack it. Just guessing of course.
<edgar-rft> arora: you don't jet Lisp programming job offers every week, but it's wrong that you can make *no* money with Lisp.
<beach> arora: But it won't be "peaceful". You will soon find that you will want to learn more and more.
<edgar-rft> true, Lisp is addictive :-)
<beach> Definitely!
<beach> ... so it becomes a lifelong learning experience. Which I personally love, but it's not for everyone.
<arora> I don't mind learning more, infact that's all I like. What I do mind is being annoyed for making wrong choices.
<beach> Oh, you are in the right place then.
<beach> Not many people I know who learned Common Lisp decided later that it was the wrong thing to do.
<arora> I like niche and esoteric topics because I find them interesting
<edgar-rft> welcome to the club, we make wrong choices all day long :-)
<arora> :-)
mrios22 has quit [Ping timeout: 248 seconds]
zerno_ has quit [Quit: This computer has gone to sleep]
mrcom has quit [Ping timeout: 265 seconds]
zerno_ has joined #lisp
jeosol has joined #lisp
cantstanya has quit [Remote host closed the connection]
gaqwas has quit [Remote host closed the connection]
zerno_ has quit [Quit: This computer has gone to sleep]
cantstanya has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
j0nd0e` has quit [Ping timeout: 265 seconds]
Lord_of_Life has joined #lisp
arora has quit [Ping timeout: 258 seconds]
zerno_ has joined #lisp
estadocu` has quit [Ping timeout: 256 seconds]
zerno_ has quit [Client Quit]
mrcom has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Fare has joined #lisp
j0nd0e` has joined #lisp
j0nd0e`` has joined #lisp
j0nd0e` has quit [Ping timeout: 264 seconds]
Posterdati has quit [Ping timeout: 264 seconds]
asarch has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<asarch> In Postmoden, how could I get the last inserted row id?
<asarch> *Postmodern
<Xach> asarch: I use the :returning option in s-sql
<asarch> Thank you!
<asarch> :-)
zerno has joined #lisp
asarch has quit [Quit: Leaving]
attila_lendvai has quit [Ping timeout: 244 seconds]
mrcom has quit [Read error: Connection reset by peer]
mrcom has joined #lisp
<VincentVega> Is there a way to insert a comment in a macroexpansion?
<phoe> no
<phoe> comments are not Lisp data
zerno has quit [Quit: This computer has gone to sleep]
<VincentVega> hmm ok. I guess just returning a string between other forms could generate a warning as an unused expression, right?
jeosol has quit [Ping timeout: 248 seconds]
<VincentVega> although maybe it wouldn't, like it wouldn't for an empty progn, it's a macroexpansion after all
<phoe> what are you trying to do?
<VincentVega> just insert a reminder inside a macroexpansion for those who may be inspecting it
<phoe> why though?
<phoe> insert comments in the source code of the macroexpander for people who M-. into it
zerno has joined #lisp
arora has joined #lisp
<VincentVega> thing is, you are sometimes inspecting the macroexpansion itself, to check that it's correct, or just reading it etc, you wouldn't necessarily be interested in looking at the macroexpander itself
<VincentVega> * at the macro itself
<VincentVega> it's not a big deal, but thought would be nice
<phoe> hm
<phoe> sure it could, but I don't think CL supports such constructs out of the box
<phoe> I mean, you could create some objects that are then printed readably as #| ... |# but that would be sorta hacky I guess
<VincentVega> I see, well, that's fine : )  thanks for the info
<phoe> if anything, I'd structure the macroexpander in a way that is easy to understand and test, or structure the macroexpansion in a way that conveys the necessary information through the expansion form itself
<phoe> like (define-foo ...) that expands into (progn (define-foo-bar ...) (define-foo-baz ...) (define-foo-quux ...)) for something that defines multiple things at once
<VincentVega> I am doing something like that. Just wanted to put a reminder not to forget to eval, well, based on your example, form (define-foo-bar ...)  before expanding (define-foo-baz ...) (define-foo-quux ...) cause that's a prerequisite. As I said, not a big deal, asking more out of curiosity.
<phoe> the PROGN will take care of that though
<phoe> and your DEFINE-FOO-BAZ can signal an error if the matching DEFINE-FOO-BAR was not evaluated before
<VincentVega> not when you are macroexpanding manually within emacs
<phoe> wait a second though
<phoe> you want your macroexpander to signal an error? not the expansion?
<VincentVega> wait what error : D
<phoe> I don't understand the "not when you are macroexpanding manually within emacs" part
<phoe> I should be able to macrostep into DEFINE-FOO and then DEFINE-FOO-BAZ without evaluating DEFINE-FOO-BAR first
<phoe> because, unless you use some EVAL-WHEN trickery, this is exactly how the Lisp compiler is going to perform minimal compilation on your code
<VincentVega> sly-macroexpand-1 your macro call, you will get a progn with 2 macros within. Say, the first macro defines a class. Then sly-macroexpand-1 the second macro which relies on that class and it will either signal an error because the class is undefined or it will be using the old definition of a class if it has been defined before, which is more
<VincentVega> dangerous.
<VincentVega> If your macro is building the class definition, it may be easy to forget that you need to evaluate it before verifying what the second macro is generating
<phoe> that falls into the "needs EVAL-WHEN trickery" zone
<phoe> and when I see (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) ...) in a macroexpansion then I can usually infer that the compiler state is going to be modified at this point
<phoe> and this includes defining classes in the compiler environment that will then be used inside subsequent macroexpanders
<VincentVega> Yes, i am using the eval when.
<VincentVega> But I guess you are right
<phoe> I'd say this is enough information then
<VincentVega> It can be inferred, huh
<phoe> but then I'd also separate the two macros because defining a thing and then immediately using it to define some other thing kinda violates the SRP
<phoe> I'd first explicitly DEFINE-FOO-BAR that expands into EVAL-WHEN and only then I'd DEFINE-FOO-BAZ that uses the FOO-BAR thing defined earlier
<VincentVega> srp?
<phoe> single responsibility principle
<phoe> not strictly a lisp thing, just a general programming practice
<VincentVega> Don't want to seperate, it becomes too cumbersome to call then
<VincentVega> I see
<phoe> hm
<VincentVega> I  mean if one thing always goes with the other, why sepearte? I guess it is all one and the same responsibility here: in my case I am generating methods based on the class.
<VincentVega> * has to leave for a while
<phoe> so you define some sort of class, and then make methods based on it?... hmmm
jdz has left #lisp ["Using Circe, the loveliest of all IRC clients"]
<phoe> is it only used there, in that single place? maybe then an instance would be enough instead of a whole class? I don't know your architecture so just firing questions blindly now
arora has quit [Ping timeout: 272 seconds]
VincentVega has quit [Quit: Connection closed]
aartaka_d has quit [Ping timeout: 265 seconds]
j0nd0e`` has quit [Ping timeout: 240 seconds]
arora has joined #lisp
ym_ has joined #lisp
<tinga> Why would one write (in-package #:foo) instead of just (in-package :foo)?
ym has quit [Ping timeout: 240 seconds]
<tinga> Or even just (in-package foo) in fact.
<phoe> the last interns symbols in arbitrary packages
<ralt> for the principle of least surprise
<ralt> with #:foo people don't have to wonder if it's a symbol part of the keyword package or anything like that, it's pretty clear
<phoe> using the #: notation also carries the information that you only care about the symbol name, not its package information
<tinga> OK, I see. Thanks!
Bike has joined #lisp
VincentVega has joined #lisp
attila_lendvai has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 265 seconds]
mrcom has joined #lisp
<VincentVega> phoe: I'm back : ) So, I have a metaclass which you can use to define extra slot options. Say, you could specify `:ensure-valid-on-read t` which will generate a `setf :before` which calls a compute method if the value is invalid. Or, if you have slots which act as cache and rely on other slots, you can specify all that, and the cache will be
<VincentVega> invalidated when those other slots are written to (may not make for the most efficient approach, but it does ensure that things stay valid).
Lord_of_Life has quit [Remote host closed the connection]
<VincentVega> When you throw inheritence into the mix, keeping track of things like that manually can become a headache, and having it all written out in this type of declarative approach just keeps it clean and easy to understand.
Lord_of_Life has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
arora has quit [Quit: leaving]
<jmercouris> (list 0 1 2 3) -> (0 1 2 3)
<jmercouris> (list 0 #+renderer-gtk 1 2 3)
<jmercouris> (0 2 3)
<jmercouris> Now, I want to have MULTIPLE items depend upon #+renderer-gtk
<jmercouris> any way to embed a list within this list?
<jmercouris> of course I can do stuff like (0 (1 2) 3)
<jmercouris> but I want the result to be (0 1 2 3) when the feature exists
<jmercouris> I can't for the life of me imagine how to do this
<jmercouris> in otherw words, I don't want to have to write (list 0 #+renderer-gtk 1 #+renderer-gtk 2 3)
<jmercouris> I would rather I can embed 1 and 2 in a single form
wsinatra has joined #lisp
pfdietz has joined #lisp
<jackdaniel> you can't, because the #+ reader macro works on a single form
<jmercouris> I see
<jmercouris> thank you
<pfdietz> (and (<= (length s1) (lengrh s2)) (string= s1 s2 :end2 (length s1)))
tassleoff has quit [Ping timeout: 264 seconds]
<jackdaniel> lengrh: operator not found
<beach> jmercouris: Your questions here made me curious about your background and training in software and theory, and I am wondering whether your background is typical. Do you mind sharing?
<jmercouris> I'm not sure whether my background is typical or not, as I have only experienced my own life, but I can share yes
<jmercouris> I have a degree in computational information systems from IIT, basically it is about data analysis/engineering
hendursa1 has quit [Quit: hendursa1]
<jmercouris> I am an expert in data structures, with much less emphasis on algorithms
hendursaga has joined #lisp
<jmercouris> in graduate school I studied entrepreneurship and digital networks, I further expanded my understanding of data by looking at raw real world data, doing a lot of normalization, ingestion, classification work
<jmercouris> I pioneered using machine learning to analyze the flow of information across digital social networks with regards to information diffusion
<beach> I see, thanks.
<jmercouris> so my backgrounds is primarily concerned with data processing, and less with algorithms, which is my guess as to why most CS find me oft uneducated :-D
<beach> My hunch is that this is an unusual background for Common Lisp programmers. But it's just a guess.
<jmercouris> probably, I assume most people here are quite good with math, for one
<scymtym> there is a special case in which a single reader conditional can guard multiple sub-forms of a form: (list 1 2 . #+sbcl(3 4))
<jackdaniel> scymtym: technically speaking it is still a single form
<beach> I think that's why he carefully said "sub-form".
<scymtym> jackdaniel: i tried to step around that by using the (possibly undefined) term "sub-form"
<jackdaniel> ah, right
<jackdaniel> I've just checked the glossary, my bad
jdz has joined #lisp
<jackdaniel> it is "subform" in the glossary
<beach> Indeed.
<scymtym> i consider this a situational trick anyway since it only works for conditionally appending subforms at the end
<jackdaniel> I'm still not sure why you said "special case" then
<beach> At the end of the list.
<beach> You can't do (1 2 . #+...(3 4) 5 6)
<scymtym> jackdaniel: i understood jmercouris' question as being about the general case, that is guarding and splicing at any point
<jackdaniel> uhm, thanks for elaborating - now I see
<jmercouris> scymtym: you understood correctly
<scymtym> jmercouris: ok. so the trick is probably not useful to you. but i thought it might be not that well-known and thus maybe worth sharing
xrash has joined #lisp
cage_ has joined #lisp
<Bike> if you're actually doing (list 0 1 2 3), you could make that `(0 #+renderer-gtk ,@'(1 2) 3), couldn't you? or is mixing unquoting and reader conditionals not kosher?
<jackdaniel> Bike: it is not conforming afaik
<jackdaniel> because ,@(…) is not a form
<jackdaniel> however it will work on sbcl
<jackdaniel> (because of how unsplicing is implemented)
<pfdietz> (multiple-value-call #'list 1 2 #+sbcl (values 3 4) 5 6)
<Bike> hm i see
<pfdietz> m-v-c can be quite useful at times. This is not actually one of them.
<Bike> lol.
<beach> Heh, good one!
<pfdietz> The useful case is where you're calling a function with keyword arguments that you may or may not want to include.  You could do APPLY and build up a list of arguments, but with m-v-c you can conditionally put the args right on the stack.  No consing needed.
<pfdietz> (ruricolist pointed that out to me)
<Bike> i like the thing in alexandria where curry does (multiple-value-call fn (values-list arguments) (values-list more))
<Bike> instead of (apply fn (append arguments more))
<pfdietz> Yes.
<phoe> ...I just realized that values-list should have probably been called list-values
<phoe> since it turns a list into values, not the other way around
<Bike> yeah i mix it and multiple-value-list up a lot
mrios22 has joined #lisp
<heisig> Nowadays I always name conversion functions X-from-Y. There is no ambiguity, and things line up nicely in the source code: (X-from-Y (Y-from-Z ...)).
<jackdaniel> I remember in LiSP the author has a similar concern, whether x->y or x<-y is better, and he mentions this argument that (x<-y (y<-z …)) lines nicer then the alternative
<_death> if you define a x<-z or x->z then it doesn't matter that much (look like a law of demeter thing to me)
kapilp has quit [Ping timeout: 265 seconds]
<jackdaniel> when I see i.e (x->z (y->x (q->y 42))) it is less obvious to me whether it returns z or x, because the order of symbols doesn't really match the type conversion order
<heisig> I also try to almost always use full English words instead of glyphs. Otherwise you quickly drift off to something that resembles obfuscated C code.
<heisig> Hence X-from-Y instead of X<-Y.
* jackdaniel is fed up with too long names from reading too much clim code :-)
<phoe> nihil-ex-nihil
<_death> I cycled between a->b a-to-b and a-b.. but my argument is that if you have a-to-b and b-to-c, and you wish to make a c out of a, you should write a-to-c
<jackdaniel> i.e COMMAND-ACCESSIBLE-IN-COMMAND-TABLE-P
<jackdaniel> ah, makes sense, yes
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
<scymtym> COMMAND-LINE-READ-REMAINING-ARGUMENTS-FOR-PARTIAL-COMMAND
dbotton has joined #lisp
<pfdietz> ADD-ONE-TO-COBOL-YIELDING-COBOL
<pfdietz> (the OO version)
tinga has quit [Read error: Connection reset by peer]
Vultyre has joined #lisp
neirac has quit [Ping timeout: 244 seconds]
tinga has joined #lisp
gareppa has joined #lisp
Vultyre has quit [Read error: Connection reset by peer]
X-Scale` has joined #lisp
waleee-cl has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
X-Scale has quit [Ping timeout: 272 seconds]
X-Scale` is now known as X-Scale
sjl has joined #lisp
mrchampion has quit [Read error: Connection reset by peer]
zerno has quit [Quit: This computer has gone to sleep]
cods has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
zerno has joined #lisp
gareppa has quit [Quit: Leaving]
<Fare> _death: my current favorite is b<-a
<Fare> That's the convention I use in my current software.
<beach> Fare: No doubt because you are more into Scheme these days, right?
<Fare> It composes nicely: (a<-b (b<-c (c<-d (d<-e e))))
<Fare> I am. Gerbil Scheme to be precise.
<Fare> I slowly port my software from CL to Scheme when the CL versions bitrot.
Vultyre has joined #lisp
<Fare> (mostly CL doesn't bitrot too fast)
ljavorsk has quit [Ping timeout: 244 seconds]
lucasb has joined #lisp
cer0 has joined #lisp
mrchampion has joined #lisp
Lord_of_Life has quit [Remote host closed the connection]
Inline has joined #lisp
mrios22 has quit [Ping timeout: 256 seconds]
nullman has quit [Ping timeout: 265 seconds]
Lord_of_Life has joined #lisp
caret has joined #lisp
caret has quit [Client Quit]
caret has joined #lisp
nullman has joined #lisp
andreyorst` has quit [Quit: andreyorst`]
jonatack has quit [Quit: jonatack]
andreyorst has joined #lisp
jonatack has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
tmalsburg[m] has left #lisp ["User left"]
jonatack has quit [Quit: jonatack]
mmmattyx has joined #lisp
Fare has quit [Ping timeout: 264 seconds]
<jmercouris> I'm thinking about this guy on Reddit who talks about extending CL with this new 'standard'
<jmercouris> why is this occurring so ofteN?
<jmercouris> if anything the only thing I can really condone is a authoritative list of packages for beginners: eg. use this for JSON, use this for threads, etc
<beach> So there is this very strange contradiction out there...
<beach> On the one hand, there are people like this, screaming that the Common Lisp standard is hopelessly inadequate.
<astronavt> something something xkcd standards something
<beach> On the other hand, often the same people seem perfectly happy to use languages without a standard at all.
<jmercouris> astronavt: a classic example
<jmercouris> beach: that's exactly what I don't get!
<beach> Like Java, C#, Python, you name it.
<astronavt> CL has a huge amount of batteries included. the problem is that they dont always fit the kinds of flashlights that people are designing in 2021 :)
<jmercouris> look at javascript, what kind of a joke is the standard
<jmercouris> there are NO batteries included in javascript
<jmercouris> and it is very poorly specified
<astronavt> no batteries in the language, but there is a battery level api in the browser
<jmercouris> what's wrong with just having good libraries???
<jmercouris> no one ever makes these complaints about C for example
<astronavt> arguably, they tried once, and ended up with c++
<jmercouris> ay yai yai, that was a disasterpiece
<jackdaniel> C has a new standard every few years
<jmercouris> and we have bjourne strutting around like he can turn water into wine...
<jackdaniel> and there are many good improvements in the language
<astronavt> apparently c17 was more or less a bugfix standard for c14
<astronavt> and adding ONE piece of new functionality (defer) in c2x is causing a big stir
<jmercouris> and yet, many are just using c99
<beach> Oh, this person hasn't use the condition system, but still has opinions about the standard. :)
<jackdaniel> many were just using cltl2 for some years before most implementation implemented the "rest" from ansi
<beach> That should amuse phoe!
<astronavt> jmercouris indeed, i wish people would spend their energy writing useful libraries that do useful things, instead of imagining new standards that dont accomplish anything other than navel gazing
<jackdaniel> adoption of the new standard is often inhibited by dragging compilers (i.e msvc supports c99 only since a few years ago)
<jmercouris> but with macros, you don't need new compiler/compiler features
<jackdaniel> so arguably a new cl standard would be a bad thing (worst case scenario would be the "perl scenario")
<jmercouris> it can all be extended within the language itself!
<jmercouris> we can add literally ANY construct we want
<jackdaniel> many things can't be extended without a help from the implementation
<jmercouris> why would we need to iterate on the compiler?
<jackdaniel> delimited continations is one thing
<jackdaniel> threads are another (well, kinda)
<jackdaniel> networking is another
<jmercouris> would you suggest a Common Lisp 2.0 standard that includes bordeaux thread spec?
Vultyre has quit [Quit: Leaving]
Vultyre has joined #lisp
<jackdaniel> that's not my point - I'm saying that CL standard do miss some things, and vendors plug these holes
<jackdaniel> sadly, often these plugs are not compatible
<jackdaniel> that's the point of standards - they draw a line of what /must/ be present in a conforming implementaiton
<jmercouris> is the scheme standard more or less exhaustive than CL?
<jmercouris> I'm not familiar with scheme
<jmercouris> IF less exhaustive, THEN, how do you explain its relative success? has nothing to do with the standard
<jackdaniel> there are a few scheme standards and that caused a friction in the community
<jmercouris> I think it has purely to do with the inertia of people working on/in something
<phoe> jmercouris: which scheme
<jmercouris> yeah, I don't know
<jmercouris> A scheme dialect
<jmercouris> one that is popular
booaa has joined #lisp
<jackdaniel> what is a scheme dialect?
<jmercouris> you tell me
<phoe> probably something from the list at http://community.schemewiki.org/?scheme-faq-standards
<jmercouris> a scheme implementation with a name and some features
<jackdaniel> I don't know. scheme is a language with the standard, no dialects
<jackdaniel> (at least no more than sbcl being a different "dialect" than ccl)
<jmercouris> I dont know, isn't SBCL a dialect?
<jmercouris> SBCL has SBCL specific features
<beach> Oh, there is also this idea that many Common Lisp programmers have, that Common Lisp deserves to be more widely used, and they blame the standard for that. I think they have completely misunderstood why Common Lisp is not more widely used.
<jmercouris> could it not be said to be a dialect?
<beach> jmercouris: It's an implementation of Common Lisp.
<jmercouris> beach: absolutely, a lot of it fundamentally has nothing to do with technology
<jmercouris> yeah it is, but isn't SBCL specific code also part of the SBCL dialect?
Vultyre has quit [Client Quit]
<jmercouris> can't the term SBCL both refer the implementation and the dialect?
Vultyre has joined #lisp
<beach> I would not use the word "dialect".
<jmercouris> superset? extension?
<jackdaniel> the word dialect is a slang, mostly used with "lisp dialect" -- that means i.e that cl and scheme are different lisp dialects
<beach> Sure, implementation-specific extensions exist.
<jmercouris> writing SBCL specific code is non conforming to CL, and possible, it is therefore a new language
<beach> Let me check what the Common Lisp HyperSpec says...
<jackdaniel> person who is used to read code of one will immedietely recognize some common idioms
<jackdaniel> introducing new operators to existing language does not make it a different language
<jmercouris> how not?
<jackdaniel> changing semantics described in the standard would make a different language
<jmercouris> If I say language X includes operators Q R T
<beach> jmercouris: That's not a reasonable definition. If a C compiler is distributed with a library function, that doesn't mean it is a different dialect.
<jackdaniel> consider that you add a function "foo" to your lisp image, does it make it a different language?
<jmercouris> and then I come up with language U that includes operators Q R T W is that not a new language?
<jmercouris> now we are getting really deep into what a langauge is
<beach> I don't think so , no.
<jmercouris> is it just a grammar?
<jackdaniel> every act of programming would spawn a new language, and such distinction is not very useful
<jmercouris> or a set of functions + a grammar?
<beach> jmercouris: Syntax and semantics, and standard operators.
Guest33533 has left #lisp ["Leaving"]
<jackdaniel> words are used to distinguish things, not to make them less clear
<jmercouris> not everything is very clear
<jmercouris> sometimes fuzzy mental models are more useful
<jmercouris> precision is not a god to be obeyed unquestioningly, sometimes imprecision is valuable
<beach> clhs 1.6
<beach> clhs 1.7
<jackdaniel> being precise at all cost if of course wrong, but being imprecise without a reason is worse
<jmercouris> hm interesting link beach
<jmercouris> so here is a question
<jackdaniel> s/is worse/also wrong/ (I suppose)
<jmercouris> there are many languages that use C syntax exactly
<jmercouris> but they come with a different set of operators and functions
<jmercouris> are these the same language, or different lanaguages?
<beach> And different semantics.
<jmercouris> well, what are semantics?
<beach> The meaning of every program.
<jmercouris> I could make an objective-c program that looks EXACTLY like a c program
<jmercouris> it would mean the same, and look the same
<jmercouris> and yet, they are distinct languages
<jackdaniel> if you specify, that function arguments are evaluated from left to right, and that function arguments are evaluated in /any/ order - that are different sematnics
<jackdaniel> syntax is usually a superficial representation
<jmercouris> since objective-c is C + objective-c is it fair to say that C is objective-c but objective-c is not C?
<beach> jmercouris: That's not enough. There are in fact code snippets that are simultaneously valid programs in many languages.
<beach> Java might use C syntax, but it uses reference semantics most of the time.
<jmercouris> it's still not clear to me what semantics is
<jackdaniel> https://en.wikipedia.org/wiki/Semantics_(computer_science) may be a good introduction
<jmercouris> what is it, a set of operands?
<beach> Yes.
<jmercouris> so, a set of operations it performs
<jmercouris> "Semantics describes the processes a computer follows when executing a program in that specific language"
<beach> jmercouris: For every valid form in the language, what it does (return values, side effects).
<jmercouris> so if we have the same syntax, and the same semantics
<jmercouris> we have the same language?
<beach> Sure.
<jmercouris> now, what if we add more things
<jmercouris> more semantics
<jackdaniel> arguably the syntax is not even a prerequisite
<jmercouris> is it still the same language?
<beach> jmercouris: You can't really "add more semantics".
<phoe> is C with its standard library still C?
booaa has left #lisp ["ERC (IRC client for Emacs 28.0.50)"]
<phoe> is C with a few different libraries included still C?
<jmercouris> I guess what I am asking is, is Objective-C also C?
<_death> jmercouris: C programs are also Objective C programs, because the latter is compatible with the former
<jmercouris> _death: that's not really my question
<beach> jmercouris: I should have added "standard operators" to "syntax" and "semantics".
<phoe> is every C program guaranteed to behave the same under ObjC? then it sounds like ObjC is a superset of C
<jmercouris> phoe: that's what I'm saying
<jmercouris> so isn't SBCL perhaps a superset of CL?
<beach> Oh, it is.
<_death> jmercouris: Objective C purports to be a language that extends C.. SBCL does not purport to be a language
<phoe> if we treat SBCL as a language of its own, then I guess it is
<jmercouris> how is SBCL NOT a language?
<beach> jmercouris: For one thing, it defines some semantics that is undefined in the standard.
<_death> jmercouris: SBCL is a program.. it purports to be an implementation of Common Lisp
<beach> jmercouris: Because, according to the Common Lisp standard, it is still allowed to be called Common Lisp.
<jmercouris> SBCL is not only a program, it is a specification, defined by the program itself
<phoe> I'd say it's a CL implementation with extensions
<jmercouris> beach: yes, that's fair
<jmercouris> SBCL is a reference implementation the SBCL language
<jmercouris> which is a superset of common lisp
<jmercouris> at least in my head
<phoe> hm, that's a novel way of looking at it
<beach> jmercouris: Had the Common Lisp standard said that no additional operators are allowed to be defined by an implementation, then it would not have been an implementation of the Common Lisp language.
booaa has joined #lisp
<jmercouris> beach: does the standard ever do that though? is it ever restrictive by addition rather than subtraction?
<beach> jmercouris: For example, SBCL has an additional lambda-list keyword, &more is it?
<beach> But that is allowed.
<phoe> beach: yes, sb-ect:&more AFAIR
<jmercouris> I think some stuff for hash tables as well
<phoe> jmercouris: yes, some things are mandated to NOT be extended
<phoe> e.g. the list of symbols exported by the CL package
<jmercouris> phoe: oh I did not know that
<jmercouris> that kind of makes sense though
<beach> And the number of return values.
<jmercouris> why would the number of return values matter?
<jmercouris> if I return extra info to the caller, why should they be upset?
<_death> jmercouris: it's true that when you, say, add a function to a set of functions you can think of it as extending a (maybe implicit) language.. in that case, someone who uses SBCL-specific constructs is indeed programming in the implicit SBCL language
<phoe> jmercouris: a standard function that is defined to return exactly N values must return exactly N values
<beach> Because it would change the behavior if multiple-value-call.
<phoe> otherwise stuff that uses multiple-value-call stuff is going to badly break.
<beach> Heh.
* phoe highfives
<jmercouris> fair enough...
<_death> jmercouris: and since SBCL implements Common Lisp, then you can think of it as a dialect of Common Lisp
<jmercouris> yes
mrcom has joined #lisp
heisig has quit [Quit: Leaving]
<phoe> yep, that's an interesting look at this topic
aeth has quit [Ping timeout: 272 seconds]
<jmercouris> just something I was thinking about
aeth has joined #lisp
<jmercouris> _death: that's basically my line of reasoning, yes
<phoe> I guess that from this point of view GCC also has its own flavor of C, given all of the GCC-specific extensions
<phoe> and the fact they're required to build e.g. the Linux kernel, which is written in this C dialect
<jmercouris> yes, we could call it, GCCC
<phoe> same stuff with CCL which is buildable under the CCL flavor of CL only
<jmercouris> or "Juicy" for short
<phoe> jmercouris: :D
<_death> jmercouris: but often, the useful view is that you're programming in Common Lisp with some SBCL-specific code, because we don't want to be programming an SBCL dialect, because it has no explicit specification, and may change in the future
aorst has joined #lisp
<_death> *in an SBCL dialect
<_death> also, we may want our programs to run on other implementations
<jackdaniel> from the programmer perspective it is useful to know the compiler extensions, but is calling different compilers with extensions of the same language "dialects" useful?
<phoe> (and often does, via so-called minor incompatible changes and unannounced changes in its internal structure)
<jackdaniel> that would probably mean, that there is no single implementation of the language, only "dialects"
<jmercouris> I think it is OK insofar as all dialects are supersets
<jmercouris> problems arise when they are subsets...
andreyorst[m] has quit [Ping timeout: 246 seconds]
<_death> jmercouris: also, since Common Lisp leaves implementations free to implement things differently in many cases, we should be wary of relying on the specific choices made in this implicit SBCL dialect.. programs overspecify
mindCrime_ has joined #lisp
<jmercouris> yes, sometimes it is best not to peek under the hood
<beach> In fact, the standard (perhaps not always intentionally) leaves a lot of things unspecified.
hnOsmium0001 has joined #lisp
xrash has quit [Read error: Connection reset by peer]
<beach> I think that's how people should spend their energy instead, i.e., try to define a standard with fewer things unspecified, rather than one with more or different stuff in it.
tassleoff has joined #lisp
<_death> beach: I agree.. and also there are many gotchas that may need fixing.. but I'd rather stick with this standard because I see what other people want to put in a new standard ;)
<beach> I promise not to put anything new, perhaps with the exception of package-local nicknames, in WSCL.
<beach> And maybe the semantics of special variables in the presence of threads, without requiring that threads exist.
<beach> Those are all things that pretty much every implementation does the same way.
<_death> beach: personally I see issues with package-local nicknames (I think I explained them here in the past).. I haven't used them anywhere, though I can imagine there might be a case where I would
<beach> That would be good to know about before making a decision about inclusion.
<_death> when I see phoe using a:foo here to say something about alexandria, I think it's a symptom ;)
<phoe> _death: non-trivial amounts of Lisp code already depend on package-local nicknames
<_death> phoe: sure.. but not my Lisp programs
<phoe> :D
<_death> to me it's more similar to the way we're stuck with asdf/uiop
<_death> although it has different implementations.. but no spec, so beach's work may be useful there
<_death> (yes, I know about sbcl manual.. we've discussed this before ;)
attila_lendvai has quit [Ping timeout: 246 seconds]
<phoe> modern Lisp is actually a single-implementation language without a spec
<phoe> it's just ASDF and UIOP with multiple compiler plugins
Lord_of_Life_ has joined #lisp
* phoe ducks
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
liberliver has quit [Quit: liberliver]
kapil_ has joined #lisp
<jackdaniel> and as we've heard, modern lisp is being ported to gerbil scheme as it bitrots ,-)
<beach> I would get started with WSCL if I could just get the dpANS as a single LaTeX document (containing multiple files obviously) rather than a custom TeX document per chapter.
jonatack has joined #lisp
VincentVega has quit [Quit: Ping timeout (120 seconds)]
pfdietz has quit [Quit: Ping timeout (120 seconds)]
rumbler31_ has joined #lisp
booaa has left #lisp ["Killed buffer"]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
cer0 has quit [Ping timeout: 264 seconds]
hiroaki has quit [Ping timeout: 272 seconds]
mindCrime_ has quit [Ping timeout: 264 seconds]
narimiran has quit [Quit: leaving]
charles` has joined #lisp
andreyor1 has joined #lisp
cer0 has joined #lisp
aorst has quit [Ping timeout: 265 seconds]
Inline has quit [Remote host closed the connection]
dbotton has quit [Quit: This computer has gone to sleep]
APic has quit [Quit: New Screen + irssi]
jibanes has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
APic has joined #lisp
ikrabbe has joined #lisp
<tinga> Is RANDOM cryptographically secure? I.e. can it be used to generate session secrets?
VincentVega has joined #lisp
<phoe> no
<phoe> use ironclad for cryptographically secure number generation
<phoe> ironclad interfaces with the OS randomness sources by default
<tinga> I'm getting a message "Session secret is unbound. Using Lisp's RANDOM function to initialize it." from somewhere in the startup of this app (not sure yet where), so I'll have to track that down I guess.
<tinga> Thanks for your answer.
<phoe> I just had the funniest idea of replacing *standard-output* with a Gray stream that calls BREAK whenever anything writes to it, so you can inspect what exactly produces the output you are looking for
<phoe> gosh that's a surprisingly niche and surprisingly useful idea
<tinga> Found it in "dists/quicklisp/software/hunchentoot-v1.3.0/session.lisp"
jibanes has joined #lisp
<ikrabbe> to interface with os randomness you have also to assure that this device is secure. If you are really interested in cryptography you should think about a hardware crypto device.
<tinga> Sure
jonatack has joined #lisp
<v3ga> newbie question. so I used quickproject to create a skeleton project and it adds #: before the project name. (defpackage #:project-name ...) it does that in both of the lisp files created.
<v3ga> when I created the project I did add in a direct path but without a trailing '/' it created the project directory but i did get a cowerce warning...
<beach> Your two utterances are unrelated, right?
<phoe> the "coercing ... to directory" is expected, use trailing slashes the next time
rogersm has quit [Quit: Leaving...]
<phoe> and the #: was actually answered a few hours ago... :D
jibanes has quit [Ping timeout: 264 seconds]
<v3ga> phoe: lol ok, I went ahead and made another project the correct way. I expected as much for ther coerce warning
jibanes has joined #lisp
<v3ga> beach: well I wasn't sure if my goof was the cause. I see now that's not the case.
<phoe> yes, these are unrelated
<phoe> the #:foo notation for system and package names is used when the symbol's package doesn't matter and we just want the name
<Xach> slight tangent.
<phoe> hm?
<Xach> when implementing a didactic thing with the same behavior as the package system, i found it a lot easier to understand things when designators were forbidden.
<Xach> when working with symbol management, using symbols in place of strings can really slow down building intuition when you are learning.
<phoe> ooh, so (defpackage "FOO" ...)?
<Xach> and list designators do too
<v3ga> oh...ok, just familiarizing myself. It struck me as similar to clojures var reader macro #'
<v3ga> gotcha. thanks
<ikrabbe> When using keyword statements like :|some name| I get the error "illegal terminating character after a colon: #\|"
<Xach> phoe: not that one particularly, but SHADOW for example takes a designator for a list of string designators.
<v3ga> I was just thrown off because it looked a little different from a tutorial that i'm going through. Now I see...
<Xach> so you could do (shadow 'cl:car) and it actually means ("CAR"), and the home package doesn't matter
<ikrabbe> this happens after loading some files. Is that error known to someone, or should I search my own code for the problem?
<phoe> ikrabbe: huh? could you give me some examples?
<phoe> :|foo bar| evaluates fine for me
<ikrabbe> Hmm, seems I acted bad on the readtable... phoe: (devfar testvar :|yes thats my problem ;)|)
<phoe> oh, you had a custom readtable? with a custom macro on #\| ?
PuercoPop has joined #lisp
caret has quit [Quit: Leaving]
<PuercoPop> VincentVega: Regarding inserting comment sin macro-expansions you could use (progn "Comment as a string here" ...) as way to do so. But I think it is better to leave a comment in the macro with an example expansion tbh.
Blukunfando has joined #lisp
<ikrabbe> phoe: yes possibly I had one, I don't have one, right now: (get-macro-character #\|)
<ikrabbe> NIL
<phoe> good, that is as it should be
<phoe> escape characters are not reader macros
<ikrabbe> Yes but still it fires the error. Somehow I fetched a char-trait possibly
<ralt> ohai PuercoPop
<ralt> sorry for all the PRs :P
<VincentVega> PuercoPop: Yeah, I think I am gonna go with that, an extra bit of information won't hurt, especially that there are no warnings or other downsides that I can see.
<PuercoPop> ralt: np, Thanks for the contribs. Now if you want to write one to use the secret service API through dbus ^_^. I'll probably look into your latest one after work today
orivej has joined #lisp
<ikrabbe> but still I have the error. strange
Lycurgus has joined #lisp
<phoe> ikrabbe: could you post the erring code?
<ikrabbe> Actually it is somewhere in my local libraries I load when I start my workspace, with some experiments and other stuff in it
<ikrabbe> I first have to find the problem
<ralt> PuercoPop: secret service?
<ralt> I was planning on adding a gpg-agent integration with the existing pinentry module
<ralt> Ah, you use Gnome Keyring?
<ralt> Look at the pinentry module. If gpg-agent is setup right, it asks for your password in stumpwm.
Inline has joined #lisp
VincentVega has quit [Quit: Connection closed]
jeosol has joined #lisp
VincentVega has joined #lisp
judson_ has joined #lisp
<VincentVega> What's "safe code"? "CLOS slot types form a notable exception. Types declared using the :type slot option in defclass are asserted if and only if the class was defined in safe code and the slot access location is in safe code as well." http://www.sbcl.org/manual/#Controlling-Verbosity
gaqwas has quit [Remote host closed the connection]
<phoe> VincentVega: code compiled with high safety
<phoe> (declare (optimize (safety 3)))
<VincentVega> declaim?
<VincentVega> or declare?
<phoe> depends
charles` has quit [Ping timeout: 260 seconds]
<phoe> you can use both, declare is for local declarations, declaim is for global proclamations
<VincentVega> I see, well I do (declaim (optimize (speed 0) (debug 3) (safety 3)))
Inline has quit [Remote host closed the connection]
<phoe> in your sbclrc?
<VincentVega> I could swear this was enough to cause an error in class where initform 0 was with type string
<phoe> yes
<VincentVega> no, i evaluate it in repl before quicklisp loading it
<phoe> OK
<VincentVega> but now it just compiles fine
<phoe> there's been lots of similar breakages when SBCL started recognizing this sort of stuff as errors
<phoe> like, across all of Quicklisp
<VincentVega> interesting
mr-iznogud has joined #lisp
tyson2 has joined #lisp
mr-iznogud has quit [Remote host closed the connection]
Sauvin has quit [Remote host closed the connection]
Core6069 has quit [Quit: CoreIRC for Android - www.coreirc.com]
andreyorst has quit [Ping timeout: 240 seconds]
lowryder has quit [Ping timeout: 265 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
zerno has quit [Quit: Leaving]
lowryder has joined #lisp
andreyor1 has quit [Read error: No route to host]
andreyorst has joined #lisp
<ikrabbe> phoe: I found the code I guess, do you have a preferred pastebin for that?
luckless has quit [Remote host closed the connection]
luckless has joined #lisp
anticrisis has joined #lisp
<ikrabbe> actrually the readtable seems to be restored to its original afterwards, so I still don't know if this happens here.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<PuercoPop> ralt: Secret Service is the fdo API, gnome-keyring is one of the implementations. Althought tbh I use my own gpg-backed solution from Emacs for my personal needs.
tassleoff has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
<phoe> ikrabbe: still, I'd use a custom readtable for that
<ralt> PuercoPop: have you tried the pinentry module?
<phoe> like, explicitly create a new readtable, set the macro character inside it only, and then read with this readtable set
<ikrabbe> yes, but I want to find out what happens
<PuercoPop> ralt: No, I haven't mainly because my homegrown solution works 'good enough'. But I remember you had a stumpwm contrib for passwords
<phoe> let me reindent your code first...
<ralt> oh I forgot about that
<ralt> yeah it was some integration with https://www.passwordstore.org/
mrcom has quit [Read error: Connection reset by peer]
judson_ has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
judson_ has quit [Client Quit]
charles` has joined #lisp
<phoe> I assume that the second set-macro-character might be invalid, because it does not set non-terminating-p
<phoe> but I don't know what happens then if save-mac is NIL
judson_ has joined #lisp
<phoe> is NON-TERMINATING-P respected then?... there's no need to have it, huh
<phoe> still, you're mutating global state, my first advice would be to grab yourself a custom readtable for that
judson_ has quit [Client Quit]
judson_ has joined #lisp
ukari has joined #lisp
judson_ has quit [Client Quit]
<phoe> readtables aside, I kinda wonder what this code is meant to do
<phoe> it seems to do something with characters?...
<phoe> and I don't think charkey needs to be a macro
<phoe> you're aware that CL has characters as primitive data types, right?
<ikrabbe> it reads the output of an ascii program (actually the plan9 one) and builds a table of keywords with the names from the ascii table, that I can remember better, than the CL character names
iamFIREcracker has quit [Ping timeout: 260 seconds]
<phoe> oh, okay
<ikrabbe> also it was just a programming experiment, that is quite usefull
<ikrabbe> (tostring '("This is a" :nl "simple multiline string." :nl "Actually I used the code to write sed statements with" :tab " and " :esc "chracaters".)
<ikrabbe> )
<phoe> haha! nice
<ikrabbe> I wondered for years now how to escape the quoting problem, when writing commands for remote contexts, because what you do there is:
<ikrabbe> ssh -l user system "bash -c \"sed -e \\\"s/\\\\\\\\/\\\\\\\\\\\\\\\\/\\\"\"" # of course with a bit more sense ;)
<ikrabbe> then I found lisp as the only language to get around that problem without too much problems.
<ikrabbe> Now I write my commands as embedded lists: '("ssh" "-l" "user" "system" ("bash" "-c" ("sed" "-e" ("s/\\/\\\\/"))))
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
<ikrabbe> and I can decide through the level how many escapes I need for such \" and \\ characters.
dbotton has joined #lisp
galex-713 has joined #lisp
gaa has joined #lisp
judson_ has joined #lisp
<ikrabbe> currently I evaluate McClim Interfaces which seem perfect for my devops tasks
judson_ has quit [Client Quit]
judson_ has joined #lisp
matryoshka has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
gaa has quit [Read error: Connection reset by peer]
rfn has joined #lisp
gaa has joined #lisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.1)]
jprajzne has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 265 seconds]
galex-713 has joined #lisp
hjudt has joined #lisp
<ralt> ikrabbe: devops tasks?
<ralt> you piqued my interest
gigetoo has quit [Ping timeout: 265 seconds]
hiroaki has joined #lisp
siavoshkc has joined #lisp
gaa is now known as argh
nullman has quit [Remote host closed the connection]
argh is now known as arg`
arg` is now known as gaa
gaa is now known as arg`
arg` is now known as arghh
arghh is now known as haha
haha is now known as hoho
hoho is now known as argh
argh is now known as arghh
arghh is now known as orgh
gigetoo has joined #lisp
summerisle has quit [Quit: In my vision, I was on the veranda of a vast estate, a palazzo of some fantastic proportion.]
orgh is now known as urgh
urgh is now known as urg
summerisle has joined #lisp
urg is now known as gaa
mathrick has quit [Ping timeout: 246 seconds]
Nilby has joined #lisp
summerisle has quit [Client Quit]
summerisle has joined #lisp
cage_ has quit [Quit: Leaving]
shka_ has quit [Ping timeout: 240 seconds]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Inline has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
galex-713 has joined #lisp
nullman has joined #lisp
Inline has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
aartaka has joined #lisp
rfn has quit [Quit: ERC (IRC client for Emacs 27.1)]
mindCrime_ has joined #lisp
judson_ has joined #lisp
judson_ has quit [Client Quit]
luni has joined #lisp
madage has quit [Remote host closed the connection]
judson_ has joined #lisp
madage has joined #lisp
judson_ has quit [Client Quit]
mr-iznogud has joined #lisp
mindCrime_ has quit [Read error: Connection reset by peer]
judson_ has joined #lisp
judson_ has quit [Client Quit]
VincentVega has quit [Quit: Ping timeout (120 seconds)]
VincentVega has joined #lisp
<v3ga> so how do you go about removing an
<v3ga> so how do you go about removing an undefined variable warning. i've tried makunbound and unintern...neither one of those seem to be what I want.
<phoe> defvar
scymtym has joined #lisp
<phoe> define your variables so that they are not undefined
<phoe> or rather: either defvar or let with friends
<v3ga> phoe: what about with functions? 'defun'? how would you avoid it in that case
<phoe> avoid what exactly
<phoe> what does your code look like? please use a pastebin
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
<v3ga> phoe: basically i'm getting an undefined variable for a function I mispelled and removed. https://pastebin.com/Nr398e6q
<v3ga> i originally made '(defun scrambled-sitcom)' and now I get a style-warning for it.
<aeth> the bug is in game-over-p
<aeth> You take in scramble-sitcom as a variable, and then try to print scrambled-sitcom
<aeth> Well, not print, just POSITION
<aeth> You should also be getting an error for an unused variable
<aeth> (Well, warning)
<phoe> as aeth mentioned - it's a typo
<aeth> This is a case where having variables and functions with the same name can lead to confusion because you were thinking the issue was renaming the function, when the issue was related to a typo in a variable name.
<v3ga> aeth: Oh! and yes, I was. I see.
gaa has left #lisp ["ERC (IRC client for Emacs 28.0.50)"]
<v3ga> ok, thank you.
<v3ga> Jesus It's right there too... I'm coming from clojure and not used to a usable stacktrace. -_-
harlchen has quit [Remote host closed the connection]
judson_ has joined #lisp
nckx has quit [Ping timeout: 256 seconds]
rtypo has joined #lisp
nckx has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
Nilby has quit [Remote host closed the connection]
rlp10 has quit [Quit: leaving]
aeth has joined #lisp
wsinatra has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #lisp
dbotton has quit [Quit: Leaving]
galex-713 has quit [Ping timeout: 265 seconds]
galex-713_ has joined #lisp
wsinatra has joined #lisp
andreyorst has quit [Read error: Connection reset by peer]
matryoshka has joined #lisp
galex-713_ has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
rpg has joined #lisp
surabax has quit [Quit: Leaving]
hjudt has quit [Ping timeout: 272 seconds]
mr-iznogud has quit [Ping timeout: 265 seconds]
Nilby has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
mrcom has joined #lisp
galex-713 has quit [Remote host closed the connection]
wsinatra has quit [Quit: WeeChat 3.0]
orivej has joined #lisp
galex-713 has joined #lisp
snits has quit [Ping timeout: 260 seconds]
snits has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
dyelar has quit [Quit: Leaving.]
sz0 has joined #lisp
attila_lendvai has quit [Ping timeout: 265 seconds]
<jmercouris> Bike: is clasp via ros install up-to-date?
<Bike> sorry, i don't know. i have never used roswell and don't know much about it.
<jmercouris> Bike: have you attempted to connect clasp to any C++ GUI?
<Bike> not sure. usually we use jupyter as the gui at this point, which is in the browser
<jmercouris> I see, thanks
sjl has quit [Ping timeout: 240 seconds]
igemnace has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 265 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]