<no-defun-allowed>
well, static-vectors won't load at all due to the cffi problem
quazimodo has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
fucking finally, i just had to make another version of my library and remove anything to do with that client, since even #-server-only wouldn't mask it out
smokeink has joined #lisp
atgreen__ has joined #lisp
ebrasca has quit [Remote host closed the connection]
jack_rabbit_ has quit [Read error: Connection timed out]
jack_rabbit_ has joined #lisp
wkelly has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
is there an equivalent to with-hash-table-iterator that can be used outside its dynamic extent?
devon has quit [Ping timeout: 268 seconds]
<verisimilitude>
Is MAPHASH not sufficient for what you want?
<no-defun-allowed>
no, i need to get at the values semi-lazily ideally
<no-defun-allowed>
that said, there won't be that many values to store in a list if the hash table fits in memory
jack_rabbit_ has quit [Ping timeout: 268 seconds]
<verisimilitude>
Well, nothing else comes to mind as related to your problem, then.
<no-defun-allowed>
eh well, it'll do as an example for my library
<aeth>
no-defun-allowed: alexandria has a hash-table-keys but it iterates over the whole hash-table and conses up a list of keys
<no-defun-allowed>
yeah, i decided on hash-table-alist
igemnace has joined #lisp
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
wusticality has joined #lisp
_whitelogger has joined #lisp
Lycurgus has joined #lisp
X-Scale has joined #lisp
zotan has quit [Ping timeout: 245 seconds]
zotan has joined #lisp
dale has quit [Quit: dale]
Lycurgus has quit [Quit: Exeunt]
quazimodo has quit [Ping timeout: 245 seconds]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
dddddd has quit [Ping timeout: 268 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
dddddd has joined #lisp
keep_learning has quit [Remote host closed the connection]
keep_learning has joined #lisp
Jack_Rye has joined #lisp
myrkraverk has quit [Ping timeout: 268 seconds]
wusticality has quit [Ping timeout: 244 seconds]
mrcom has quit [Read error: Connection reset by peer]
mrcom has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
Lord_of_Life has joined #lisp
hectorhonn has joined #lisp
<hectorhonn>
morning everyone
wglb has quit [Ping timeout: 252 seconds]
dale has joined #lisp
prxq has quit [Ping timeout: 246 seconds]
<hectorhonn>
haskell's reader monad mechanism is basically achieved by common lisp's special variables. yes?
<Bike>
seems like it, from a glance
esrse has joined #lisp
wigust- has quit [Read error: Connection reset by peer]
<hectorhonn>
*thinking*
quazimodo has joined #lisp
wigust has joined #lisp
igemnace has quit [Ping timeout: 244 seconds]
anewuser has joined #lisp
Jack_Rye has quit [Ping timeout: 264 seconds]
space_otter has joined #lisp
<beach>
Good morning everyone!
<aeth>
good morning
wanz has joined #lisp
marvin2 has quit [Ping timeout: 244 seconds]
wusticality has joined #lisp
akoana has left #lisp ["Leaving"]
wusticality has quit [Ping timeout: 268 seconds]
snits has quit [Quit: leaving]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
snits has joined #lisp
snits has quit [Client Quit]
snits has joined #lisp
iAmDecim has joined #lisp
Bike has quit [Quit: Lost terminal]
wusticality has joined #lisp
snits has quit [Quit: leaving]
snits has joined #lisp
torbo has joined #lisp
torbo has quit [Ping timeout: 245 seconds]
snits has quit [Quit: leaving]
snits has joined #lisp
snits has quit [Client Quit]
varjag has joined #lisp
snits has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
ntbre has quit [Quit: ntbre]
hectorhonn has quit [Quit: Page closed]
snits has quit [Quit: leaving]
snits has joined #lisp
snits has quit [Client Quit]
Arcaelyx has quit [Ping timeout: 250 seconds]
snits has joined #lisp
snits has quit [Client Quit]
anewuser has quit [Ping timeout: 250 seconds]
Arcaelyx has joined #lisp
snits has joined #lisp
orivej has joined #lisp
dale has quit [Quit: dale]
iAmDecim has quit [Quit: WeeChat 1.9]
orivej has quit [Ping timeout: 268 seconds]
iAmDecim has joined #lisp
atgreen__ has quit [Ping timeout: 250 seconds]
ealfonso has joined #lisp
space_otter has quit [Remote host closed the connection]
dddddd has quit [Ping timeout: 244 seconds]
igemnace has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
dtornabene has joined #lisp
karlosz has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
gravicappa has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
ealfonso has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
adam4567 has joined #lisp
Kidman1670 has joined #lisp
mange has quit [Remote host closed the connection]
marvin2 has joined #lisp
Kidman1670 has quit [Quit: Goodbye everyone]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
wusticality has quit [Ping timeout: 245 seconds]
Inline has quit [Quit: Leaving]
orivej has joined #lisp
<splittist>
morning
wanz has quit [Quit: wanz]
wanz has joined #lisp
jprajzne has joined #lisp
_whitelogger has joined #lisp
<shka_>
good morning
nckx has quit [Quit: Updating my GNU Guix server — https://guix.info]
nckx has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
<quazimodo>
I just dropped connection, did my qusetion make it to the channel?
sloanr has joined #lisp
<ecraven>
don't think so
<quazimodo>
akh!
<quazimodo>
i asked what the strategy is when streaming an audio file, playing & saving it to disc simultaneously. Does the stream go straight to disk & the player just reads from there, or is the data stream multiplexed, one lot into a buffer for audio player consumption and the other lot into a buffer for the disk writer
<quazimodo>
and if it's the 2nd approach, at what point do you swap from memory buffer from the stream to the disk?
igemnace has quit [Ping timeout: 245 seconds]
Jesin has quit [Ping timeout: 250 seconds]
<lieven>
if you're on a unix, writing to an mmap-ed file might do both at the same time
varjag has joined #lisp
madrik has joined #lisp
robdog_ has joined #lisp
<madrik>
Greetings.
<quazimodo>
lieven: so some sort of coherent 'write this new stuff from this position x', and 'read this other stuff from this position y' on an open file handle?
Zaab1t has joined #lisp
<quazimodo>
and if the network is fast enough, the write's would happen at faster or more of the reads, where you'd check the current write position(x) against the read position(y) to see what can be read, thus putting the actual audio player into a 'pending' state until more info comes in and a read is allowed?
karlosz has quit [Quit: karlosz]
DGASAU has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
jello_pudding has joined #lisp
nowhere_man has joined #lisp
schweers has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
wanz has quit [Quit: wanz]
quazimodo has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
wanz has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
<beach>
Hello madrik. Are you new here? I don't recognize your nick.
<madrik>
beach: I've been lurking for a few years, on and off. Very rarely participated.
<beach>
OK, I see.
iAmDecim has quit [Ping timeout: 268 seconds]
ioa has joined #lisp
<ioa>
good morning
<beach>
Hello ioa.
<madrik>
Would Lisp, Common Lisp in particular, and the Lisp language family in general, is a good language for newbies to programming?
<beach>
I personally think it is.
<LdBeth>
As long as one’s willing to learn
<beach>
In fact, I am writing a book on intro programming that uses Common Lisp.
<shka_>
it is interactive (more then let's say python) comes with very neat debugger
<beach>
madrik: It is not widely agreed upon what languages belong to some "Lisp family" so it is hard to say anything about languages other than Common Lisp. Plus, this channel is dedicated to Common Lisp.
<shka_>
and you are essentially always do programming from the debugger in CL
<shka_>
i would say that this alone makes it nice
<ioa>
madrik i also think so. In fact, I think it's better to start with lisp, especially because of the REPL and the debugger.
<beach>
madrik: The Common Lisp programming model is MUCH simpler than that of languages such as C or C++.
<shka_>
also it has not a lot of bullshit in it which makes it even better
<schweers>
It also gives better error messages (no SEGFAULT nonsense, unless you’re doing something naughty)
adam4567 has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
<schweers>
beach: do you have experience teaching Lisp to people who have never programmed before?
<LdBeth>
I've tought lisp to my self as a newbie :)
<beach>
I can't say I do, no. But I am utterly convinced that it would be much better to start with Lisp than with something like C.
<LdBeth>
(send :lisp self)
<schweers>
I would have guessed the same, but I’ve never taught anyone how to program, and I’ve never taught anyone Lisp. So I don’t have any experience to back this up. Hence my question.
<beach>
I see, yes. I have done a lot of both, and that experience has given me ideas.
<schweers>
As teaching scheme as a first language was widespread practice at a time, this idea may not even be that radical or novel.
<schweers>
igemnace has joined #lisp
<madrik>
Doesn't /Winston and Horn/ presume that the reader is a newbie not simply to Lisp, but also to programming?
<shrdlu68>
I don't know whether exposure to Lisp in Uni does most people any good.
<madrik>
Most of the good Lisp books suppose that the reader is at some level beyond the beginning stage.
* schweers
wouldn’t know, didn’t have any exposure to Lisp/scheme/parens in uni :(
<beach>
madrik: Good question. I only have two older editions. Let me check...
<madrik>
And keeping it in the family, /How to Design Programs/ by Felleisen et al is, I understand, a tour de force in pedagogy.
<madrik>
I think I read somewhere it was a sort of spiritual successor to /The Little Lisper/.
<beach>
madrik: The second edition looks like it assumes very little prior programming knowledge. But the code looks old and not so idiomatic by today's standards.
<beach>
madrik: People here recommend a different book for that purpose:
<beach>
minion: Please tell madrik about gentle.
<minion>
madrik: look at gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
wanz has quit [Quit: wanz]
<madrik>
beach: I just checked the 3rd edition of /W&H/, and it uses Common Lisp as it was around 1989. So, not quite ANSI CL, but good enough.
<beach>
madrik: I found that book tiresome to read, but I wasn't a beginner when I did read it, so I may not be representative.
<beach>
madrik: Yes, I hear the third edition is better.
<madrik>
beach: I thought the design recipe was a gimmick at first, but I learned to appreciate it later on. It proved most useful in two Common Lisp projects of mine.
<beach>
What's the "design recipe"?
<madrik>
beach: Oh, I thought you were referring to /HTDP/.
<madrik>
There's a systematic notion of programming and a method to the design of programs.
krkini is now known as kini
<shrdlu68>
madrik: I can't think of a language whose proponents would say is not good for beginners to learn. Well, maybe Scala.
<beach>
Not even C++?
<madrik>
While on this topic, would you say that a Lisp system ought to have an interpreter along with a compiler, or would a compiler suffice?
<beach>
The latter.
<beach>
You won't notice the difference.
<madrik>
I understand that interpreted code may be better to debug in some cases.
<shrdlu68>
beach: I think they would say "C++ may not be the best for beginners", but they would not go as far as say that it is not good.
<beach>
No, there is no reason to believe that.
<beach>
madrik: No, there is no reason to believe that.
wxie has joined #lisp
<beach>
shrdlu68: I see.
<schweers>
I had the impression that C++ folks think its the end-all and be-all of languages, and that none other need to exist. So, yes, according to some, one should start with C++.
* schweers
did, and it’s no walk in the park
<beach>
madrik: There are no intrinsic reasons why an interpreter would have better debugging support. But it depends on how much energy the developers put into the debugging support.
<madrik>
beach: Well, I made a small survey a while ago of implementations for Linux.
<madrik>
SBCL has a compiler, Clozure CL has a compiler, CMU CL has both, Allegro CL has both, and LispWorks has both.
<loke>
madrik: ECL also has both.
<beach>
OK. I think SBCL does have some kind of interpreter as well.
<loke>
And SBCL does have an interpreter, although it isn't used much.
stardiviner has joined #lisp
<loke>
ABCL also has a compiler.
<jackdaniel>
ECL always at least "minimally compiles" to bytecode
<beach>
madrik: As an implementer of Common Lisp, I would not include both. It would be a waste of my time and it would result in an increased maintenance burden. I would much rather spend my time making the compiler emit excellent debugging support.
scymtym has joined #lisp
<madrik>
loke: But doesn't the SBCL manual say, "SBCL is essentially a compiler-only implementation of Common Lisp"?
<beach>
madrik: Yes, essentially.
<jackdaniel>
madrik: "essentially" is the keyword here
<jackdaniel>
superficially it may interpret something but it shouldn't concern the developer
<loke>
There is a global variable you can set to force interpretation. It's a bad idea to use it :-)
<scymtym>
the interpreter can be useful in very specific situations like changing the compiler in a running image or parallel compilation
<jackdaniel>
it may be also useful in case of limited platforms like ios (where you can't compile in your application)
<schweers>
one cannot?
<jackdaniel>
or to be more precise, you can, but your application won't be accepted to their repositories
Necktwi has quit [Quit: leaving]
<schweers>
do they ban anything JIT like?
<LdBeth>
^ well as for as i know some JS developer use eval to do that
<madrik>
I was reminded of this old discussion in comp.lang.lisp regarding the relative advantages of interpreters and compilers:
<madrik>
Hmm. Then it must be the versions supplied by my OS vendor that doesn't have it.
<loke>
no-defun-allowed: it's bound to both C-c C-w C-c and C-c C-w c
<LdBeth>
Both SBCL and CCL has built in who-calls
<no-defun-allowed>
i see
<loke>
the former is fater to type, at least for me.
<no-defun-allowed>
madrik: you often get a much newer SLIME from MELPA or Quicklisp
<loke>
madrik: You might not get it unless you compile SBCL with --fancy?
<no-defun-allowed>
true, you don't have to take your finger off C-
<loke>
madrik: Don't ever use the Lisps shipped by the distribution packager
<no-defun-allowed>
ubuntu and arch both ship fancy (or at least who-calls-able) SBCLs
<LdBeth>
except Gentoo's
<loke>
Does anyone actually use gento?
<LdBeth>
me
<no-defun-allowed>
there's probably a cflag
<loke>
Well wouldn't you be able to set some magic flags to compile the latest and greatest?
<no-defun-allowed>
no, just pax_kernel which isn't relevant
<madrik>
I use Debian myself as I'd like security support for all packages in the archives. I understand that Ubuntu has no such complete coverage.
<loke>
Compiling SBCL yourself is a much better way to keep thinigs updated
wxie has quit [Ping timeout: 245 seconds]
<LdBeth>
in Gentoo 9999 is the latest and greatest
<LdBeth>
But I trend to be conservative.
<madrik>
Coming back to texts on Common Lisp, wasn't Kent Pitman working on a Lisp book?
<Jachy>
I use gentoo too
<LdBeth>
madrik: I believe u're talking about CLtL2
<madrik>
LdBeth: While perusing the archives (late 1990s-early 2000s) of the newsgroup, I recall he had plans for an intermediate to advanced book on Common Lisp.
jello_pudding has quit [Quit: Leaving, Quit]
<madrik>
I've read some of his prose works, and I thought to ask whether he had published anything new.
<madrik>
schweers: You joked earlier that C++ people thought of C++ as the alpha and omega of languages, and that one could (should?) begin with C++.
<madrik>
At least one person, Steve Heller, wrote a book for teaching C++ from scratch.
<madrik>
"Steve Heller teaches C++ from scratch, through a one-on-one conversation with an intelligent beginner who asks the questions you'd ask. Heller's unique dialog format is brilliantly designed to clarify the concepts you might otherwise find confusing, so you can quickly learn today's most powerful and valuable C++ development techniques."
<no-defun-allowed>
this is just The Little Schemer
<no-defun-allowed>
that's not unique
wanz has joined #lisp
<beach>
madrik: I firmly believe that the feature that I describe as "uniform reference semantics", i.e. that Common Lisp behaves AS IF every object is manipulated through a reference to it, makes the programming model way easier to understand than that of languages such as C and C++.
<schweers>
madrik: I wasn’t joking, some people really do think so.
<madrik>
beach: Indeed. I now think of C, at least, as a language left for more advanced stages of learning.
<schweers>
I still don’t have a satisfying answer on what to do on embedded devices (apart from simply not going there). Lisp still seems to need too much memory. Maybe forth?
<madrik>
schweers: Write your own, maybe?
<madrik>
Something specialized.
<schweers>
then again, as LISP was invented, the machines were tiny too
<madrik>
If by embedded you mean something smaller than phones.
<no-defun-allowed>
uLisp exists, but it's not suitable for doing any processing given it interprets
<no-defun-allowed>
(there's no way to compile on an Arduino, that said, the program and volatile memories are in separate address spaces)
<no-defun-allowed>
ask for better embedded machines?
<madrik>
Is there a better way to write this?
<madrik>
(loop until (< (read-sequence buffer stream) buffer-size)
<madrik>
do (use-read-sequence)
<madrik>
finally (use-read-sequence))
<loke>
madrik: Yes.
<madrik>
loke: Okay. Could I get a hint?
* shrdlu68
is yet another Gentoo user
<loke>
madrik: (loop for n = (read-sequence ...) while (plusp n) do (something-with-sequence))
<loke>
shrdlu68: You shoul dbe an ITS user.
zymurgy has joined #lisp
notzmv has quit [Ping timeout: 245 seconds]
wusticality has quit [Ping timeout: 244 seconds]
<jackdaniel>
maybe my eye is not very used to loop, but one looks pretty the same as another one (i.e I don't see any adventage of one over another)
<jackdaniel>
that said, judging if something is a good approach based on a snippet without a context may be hard
<madrik>
loke: Interesting. Thanks.
wanz has quit [Quit: wanz]
<loke>
madrik: That version gives you access to N, the return value, which you probably need when processing the result.
dtornabene has quit [Remote host closed the connection]
myrkraverk has joined #lisp
m00natic has joined #lisp
loke has quit [Read error: Connection reset by peer]
loke has joined #lisp
kajo has joined #lisp
wanz has joined #lisp
dddddd has joined #lisp
amerlyq has joined #lisp
<pjb>
beach: it's clear that uniform reference model simplifies things a lot. This is the "everything's an object' of Smalltalk. And unfortunately, Java distinguishes C-line int from OO Integer. Objective-C Cocoa Frameworks too have a NSNumber class and must inherit C integers since Objective-C is a strict superset of C.
atgreen__ has joined #lisp
r13l has joined #lisp
<pjb>
beach: like in Objective-C, we can in C use a programming style where uniform references are used most systematically. There's some boilerplate, some repeative code to be written, because of the C type system, but this can be wrapped in cpp macros…
<pjb>
Poor C (and C-like programming languages) programmers!
<beach>
Yes, when I still programmed in C, I would use pointers for basically everything (except integers, etc.)
<beach>
But it requires a GC, so I used Boehm/Weiser.
<pjb>
Yes.
<r13l>
morning all! is there a supported way to handle signals in SBCL? i’ve been googling & reading docs, but to no avail. found trivial-signals, which appears to be broken, and sb-unix has some stuff vaguely related, but it states that it’s not intended for end users (also, is UTF-8 okay on #lisp?)
<pjb>
r13l: utf-8 is the encoding used here, yes.
<r13l>
erm, _POSIX_ signals, not Lisp conditions, to be clear
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
robdog_ has quit [Remote host closed the connection]
<jackdaniel>
r13l: long story short: (sb-sys:enable-interrupt sb-unix:signame (lambda (signal code scp) (sb-sys:with-interrupts (bla-bla))))
<r13l>
thx! i’ll give that a shot
shrdlu68 has quit [Ping timeout: 240 seconds]
amerlyq has quit [Quit: amerlyq]
Zaab1t has quit [Ping timeout: 272 seconds]
iovec has quit [Quit: Connection closed for inactivity]
wanz has quit [Quit: wanz]
Arcaelyx has quit [Ping timeout: 250 seconds]
q3d has joined #lisp
Zaab1t has joined #lisp
wusticality has joined #lisp
<madrik>
Are implementations supposed to notify or otherwise enter the debugger when they read a DEFCONSTANT from in a file on successive loads?
<madrik>
s/from/form/
<TMA>
madrik: it is perfectly fine if the two values are EQL to each other
<shka_>
"A constant defined by defconstant can be redefined with defconstant. However, the consequences are undefined if an attempt is made to assign a value to the symbol using another operator, or to assign it to a different value using a subsequent defconstant. "
<shka_>
also what TMA said
<TMA>
madrik: that's why I used defparameter instead
wusticality has quit [Ping timeout: 246 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
<madrik>
So, if I have a string housing a file name that is supposed to be unchanging, should I not use DEFCONSTANT?
<loke>
madrik: You can't.
<loke>
madrik: Because “unchanged” means they have to be EQL
<loke>
and two strings with the same content are not nescessarily EQL
<loke>
WHat you can do, is something like this:
<madrik>
Okay, I checked the glossary in the HyperSpec, and indeed, two objects are _same_ if they are EQL.
<loke>
madrik: I was going to write the code for it, but it's a few lines... But you can use ALEXANDRIA:DEFINE-CONSTANT which wraps the defconstant in a check that ensures that you're not trying to redefine the value with an incompatible value. That way you can define string constants without getting compiler errors.
<TMA>
madrik: you can use interned symbol instead of the string: (defconstant +filename+ '|file.name|) ; it does not feel right though
<pjb>
madrik: the purpose of defconstant is to allow some compiler optimization. Namely; defconstant tells the compiler that it can use immediate addressing for the micro-instructions using the value.
<pjb>
madrik: for a symbol, the compiler can generate an absolute addressing mode, that will be filled by the linker when the image is loaded. This works, because symbols are interned and have identity.
<madrik>
pjb: In case of a string, then, it would be best to wrap a macro around DEFCONSTANT, as loke explains?
<madrik>
Should I just use DEFVAR for this?
<pjb>
Definitely.
<shka_>
alexandria:define-constant
<shka_>
exists
<shka_>
ok, loke already pointed this out
<pjb>
So defvar doesn't assign the variable if it is already bound. It's good for program parameters, where you would set the variable before loading the program. The defvar form would give a default value, in case it's not already bound.
<pjb>
On the other hand, defparameter always assign the variable. So it's better for global variables of the program.
<pjb>
Notice of defvar is good for program parameters, and defparameter is good for program values.
<pjb>
Historical reasons.
<pjb>
In short: use defparameter, unless you don't want the variable to be reset when you reload the program.
gxt has quit [Ping timeout: 250 seconds]
<madrik>
pjb: Your last point is precisely my case.
<pjb>
There's a programming saying: "variables won't, constants aren't. Which means that variable won't vary, (because you should be writing functional code, so you won't modify the value of your variabels). And that constant are not constant, because you will want to change their value when the environment or the platform changes.
<pjb>
It's better to leave everything dynamic.
<madrik>
It is good to know of DEFINE-CONSTANT, too. Thanks to shka_ and loke.
<pjb>
And don't use global variable.
<pjb>
The only case you may use a global variable, is for debugging purposes, when you want to store an internal data there, so you may access it easily when debugging.
<madrik>
pjb: Does not Lisp -- Common Lisp, especially -- sport multiple paradigms besides the functional? Should one not use the others -- imperative and OO, etc. -- as fits the design?
<pjb>
Of course :-)
<pjb>
This is why while you should not use global variables, there's the possibility to define them and to use them if you know better than me.
<pjb>
It's useful for quick-and-dirty small programs.
<pjb>
Or other circumstances.
<pjb>
Also, defvar and defparameter define special variables, ie. dynamic variables, which may be what you want for some purpose (eg. the *print-…* and *read-…* variables).
wanz has joined #lisp
<madrik>
pjb: I'm curious. A lot of functional programming seems to emphasize recursion and mapping rather than iteration. Don't you fear you'll blow the stack? Or do you only use Lisps that make a point of handling tail-call recursion well?
<pjb>
Indeed. You can use recursion up to a limit (the maximum stack size). There are optimization such as tail-call optimization, but it cannot always be implemented (and is not always implemented in CL). In CL, unwind-protect (which hides in a lot of macros) and dynamic binding may prevent TCO.
<schweers>
I don’t know where this myth comes from that Lisps are functional languages. Even scheme is not particularly suited for functional programming.
<pjb>
Notice that the processors, and the universe, is not functional. There are a lot of objects that can only be mutated.
<pjb>
schweers: it comes from the fact that it was the first programming language where you could write recursive functions.
<schweers>
I guess, but that time is long gone
lavaflow_ has quit [Read error: No route to host]
esrse has quit [Ping timeout: 246 seconds]
<pjb>
Well, you know why the shuttle rockets have that diameter, right?
<schweers>
C has recursive functions too, and doesn’t get accused of being a functional programming language
sloanr has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<pjb>
Also, lisp was the first language having a garbage collector, where you could therefore write (f (g (h))) without leaking the memory allocated and returned by h and g.
<pjb>
You can write pf=f(pg=g(ph=h()))); free(ph); free(pg); return pf; in C. Doesn't look quite functional.
<madrik>
Myth: Lisp is hard to read and debug because of all the parentheses.
<madrik>
Myth: Lisp is hard to learn.
<schweers>
Well, Lisp gives us great power, so there is more to learn. Macros for instance. Or multimethods. But I’d argue it is easier to learn how it is done in Lisp than to badly reinvent it and be a human compiler for some lesser language.
X-Scale has quit [Read error: Connection reset by peer]
<madrik>
On the point of expensive computers, in 1989 they wrote, "... even the fastest LISP systems running on LISP-oriented workstations cost well under a hundred thousand dollars."
<schweers>
Anyway, I’m a bit grumpy about this again, so I’d better stop here
<madrik>
I wish W&H had spent some time on the full LOOP macro.
X-Scale has joined #lisp
<beach>
PCL has a good chapter on LOOP as I recall.
<schweers>
beach is right. I often look into it when using LOOP.
smokeink has quit [Ping timeout: 245 seconds]
<madrik>
I'll make a note of it. I've mostly learned some portion of its full capabilities from the HyperSpec and the documentation for it in the CL package in Emacs.
<schweers>
Why do most languages (Lisp included) not have any facilities to automatically release any non-memory resource? I know that this can be tricky, as a GC does not guarantee when an object will be released. But honestly, I often don’t care for when it will be released, only that it will be in the not-too-far future.
<lieven>
a lot of implementations have finalizers
<madrik>
This talk of books calls to my mind another question: when you read a good book, like /Introduction to Algorithms/ by Cormen et al, or any other book whose examples are in a different language, do you try to translate into Lisp, or do you go with the flow of the book?
<pjb>
schweers: lisp has unwind-protect. C++ has destructors and IIRA.
<lieven>
they're not that useful since the not-too-far future isn't guaranteed to be bounded
<schweers>
I know, but that really is not that flexible. It’s fine when one can create an object at the same dynamic context in which it will be released, but this is not always the case or convienient.
<pjb>
schweers: and other languages with a garbage collector have finalizers, and some CL implementation have them too.
<schweers>
hmm, does java have them? Anyway, not every CL implementation seems to have them, so I guess I can’t really use them.
<schweers>
<pjb>
schweers: but the problem of course, is WHEN you release non-memory resources. This is the difference between memory and non-memory resources: it doesn't matter when you release the memory.
<pjb>
But when you release the resource matters a lot in general.
<pjb>
This is why it has to be done explicitely.
<schweers>
I know. Maybe I’m just not imaginative enough to see where this would bite me.
<schweers>
Anyway, not pretty
<pjb>
So if you use finalizer to release external resources, you may be unhappy, because the memory doesn't fill fast enough so the garbage collector is not called.
<schweers>
But hey, at least we only have to do that for non-memory resources.
<pjb>
and therefore the finalizers are never called.
<lieven>
it's become worse with generational gc. the resources might be held in an old layer
<pjb>
There's also another problem, when you take several resources: you may have rules on the order of relasing them. Finalizers can be called in any order.
<schweers>
I know, but this is not really an issue for me (at least I think so). While I do have resources which must be released in a certain order, those can always be put together into a struct or class
stardiviner has quit [Ping timeout: 268 seconds]
kajo has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
<madrik>
To do stuff on each line in a text file, is some other code preferred to this?
<madrik>
(loop for line = (read-line <file> nil nil)
<madrik>
while line
<madrik>
do
<madrik>
(stuff))
DGASAU has quit [Ping timeout: 250 seconds]
slyrus has quit [Read error: Connection reset by peer]
amerlyq has joined #lisp
Xach has quit [Ping timeout: 250 seconds]
Xach has joined #lisp
slyrus has joined #lisp
<shka_>
madrik: i usually do this exactly this way
<beach>
madrik: It is almost fine. You are violating a rule that it cited on page 13 of the LUV slides.
<beach>
madrik: In your code, READ-LINE does not return a Boolean value.
<shka_>
but it is a good idea to be more specific for types
<beach>
madrik: It returns a string, and a default value of NIL if no string is available.
<shka_>
so instead of while line that would be until (null line)
<beach>
Right.
<shka_>
but in this context i think it is more or less acceptable anyway
<shka_>
some would suggest returning :end instead of nil
<shka_>
you would not be tempted to while
<beach>
I often do (loop with eof = (list nil) ... until (eq line eof)), but only when the thing being read can be NIL, like when I use READ rather than READ-LINE.
gxt has joined #lisp
<madrik>
In these situations, if an end-of-file value besides nil is used, would that value be freshly made on each loop iteration? Or is it reused, once made?
<beach>
madrik: the form in the WITH clause is evaluated once.
<beach>
Otherwise my code would not work.
<shka_>
madrik: eq checks if the instance is the same
<madrik>
beach: Ah, I see. Macroexpanding the code shows that eof is let-bound before the loop proper. Okay.
<madrik>
shka_: Whether the values of the eof are EQ?
<beach>
madrik: Whether the value of the variable EOF is EQ to what the READ call returns.
<shka_>
wheter the value returned from the read-line function is the same is the same instance as the one constructed in with clause
anewuser has joined #lisp
<madrik>
Oh, okay.
<madrik>
Sorry. It was right there in the macroexpansion, too.
JetJej has joined #lisp
wanz has quit [Quit: wanz]
wanz has joined #lisp
Bike has joined #lisp
ebrasca has joined #lisp
wanz has quit [Quit: wanz]
wanz has joined #lisp
wusticality has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
<pjb>
Some would say that (loop for line = (read-line stream nil nil) while line) is idiomatic. Personally, I don't have problem eliding the explicit test for NIL in lisp. However, in C I started to test explicitely for NULL when testing pointers, because 0 as a symbol representing the null pointer is true only in some context. Notably, and horribly, when as argument to a function, 0 is not interpreted as the null pointer, but as an in
<pjb>
when sizeof(void*) > sizeof(int), this breaks big time.
wusticality has quit [Ping timeout: 268 seconds]
<pjb>
For example, CL:AND and CL:OR are very explicitely defined to return the first or last values of the argument expressions. So using (or var :default) or (and (predicatep foo) foo) are perfectly readable, just as: (loop while line) is.
<beach>
pjb: That's one leap you just made. Essentially, you are saying that anything that is semantically well defined by the language is readable to the maintainer.
<pjb>
Well, perhaps not everything but in those case, it is.
<beach>
That's a matter of opinion, and I was stating the opinion of Norvig and Pitman.
<TMA>
I even use '\0' in comparisons because of the intent is more apparent (and while '\0' is equivalent to 0 in C, it is not in C++); the same goes in lisp: make the intent apparent, preferably without needless reference to something external
thinkpad has quit [Ping timeout: 268 seconds]
wanz has quit [Quit: wanz]
thinkpad has joined #lisp
LiamH has joined #lisp
ntbre has joined #lisp
wanz has joined #lisp
Lord_of_Life_ has joined #lisp
Arcaelyx has joined #lisp
Lord_of_Life has quit [Ping timeout: 244 seconds]
Lord_of_Life_ is now known as Lord_of_Life
FreeBirdLjj has joined #lisp
thinkpad has quit [Ping timeout: 245 seconds]
wanz has quit [Ping timeout: 246 seconds]
thinkpad has joined #lisp
PuercoPop has joined #lisp
rippa has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
thinkpad has quit [Ping timeout: 268 seconds]
thinkpad has joined #lisp
ntbre has quit [Quit: ntbre]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Tristam has quit [Excess Flood]
Tristam has joined #lisp
<schweers>
TMA: '\0' is not 0 in C++?
<pjb>
well, '\0' == (char)0
atgreen__ is now known as atgreen
dale_ has joined #lisp
dale_ is now known as dale
igemnace has quit [Quit: WeeChat 2.3]
anewuser has quit [Quit: anewuser]
warweasle has joined #lisp
markoong has joined #lisp
devon has joined #lisp
sjl_ has joined #lisp
ebrasca has quit [Read error: Connection reset by peer]
<madrik>
What do you make of loops like while (*s++ == *p++) ...?
<beach>
Looks like a language other than Common Lisp.
<beach>
My guess is that the first C compiler was not terribly smart, so you had to write code like that to get the best performance. That changed with GCC.
<madrik>
beach: Isn't the internal representation of code in gcc something Lisp-like?
<beach>
I think that's true. Also the machine description is Lisp-like.
<beach>
Not surprising, given the background of rms.
jkordani has joined #lisp
<madrik>
beach: Indeed.
<madrik>
Maybe it's just looking to the past, but I get a kick out of thinking that there used to be implementations of other languages besides Lisp on the Lisp machines.
<dlowe>
You just make some binary blobs that are executed like any lambda function.
<beach>
Is that what they did, though?
<dlowe>
I've wondered if it'd be possible to do FFI in sbcl by providing a libc implementation that used underlying sbcl code, so that allocated memory would be gc'd as usual
<madrik>
dlowe: Nice.
<madrik>
Perhaps one of the commercial vendors has done something like that?
<dlowe>
as far as I know, all the CL implementations keep non-CL code in its own little space
peterhil has joined #lisp
<schweers>
pjb: so it is still zero, but a char instead of an int?
makomo has quit [Ping timeout: 245 seconds]
Arcaelyx has quit [Ping timeout: 252 seconds]
<pjb>
schweers: well, since char are upgraded to int when passed as parameter and in other places it's essentially the same.
<pjb>
The difference would be '\0'+'\1' = (char)1 instead of 0+'\1' = (int)1, but againm since (char)1 would be upgraded, I don't remember any circumstance where it would make a difference. (but there may still be one obscur case).
<schweers>
It’s C++, of course there is an obscure edge case XD
<schweers>
Anyway, i guess we should return to Lisp ;)
kajo has joined #lisp
zigpaw has quit [Remote host closed the connection]
<pjb>
(let ((s #(1 2 3 4)) (d #(1 2 3 0)) (i 0) (j 0)) (loop :while (= (prog1 (aref s i) (incf i)) (prog1 (aref d j) (incf j)))) (list i j)) #| --> (4 4) |#
FreeBirdLjj has quit [Remote host closed the connection]
Kaisyu has quit [Quit: Connection closed for inactivity]
devon has joined #lisp
FreeBirdLjj has joined #lisp
notzmv has joined #lisp
madrik has left #lisp ["Sleep"]
FreeBirdLjj has quit [Ping timeout: 268 seconds]
varjag has joined #lisp
Lycurgus has joined #lisp
Arcaelyx has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
Jesin has joined #lisp
FreeBirdLjj has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
cgay has quit [Quit: Lost terminal]
Josh_2 has joined #lisp
Mr-Potter has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
iAmDecim has joined #lisp
ntbre has joined #lisp
akoana has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
sjl_ has quit [Client Quit]
sjl_ has joined #lisp
DGASAU has joined #lisp
m00natic has quit [Remote host closed the connection]
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
anamorphic has quit [Quit: anamorphic]
Lelilianth has quit [Quit: No Ping reply in 180 seconds.]
pierpal has quit [Ping timeout: 268 seconds]
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
Aritheanie has joined #lisp
Essadon has joined #lisp
notzmv has quit [Ping timeout: 244 seconds]
Essadon has quit [Max SendQ exceeded]
ntbre has quit [Quit: ntbre]
atgreen has quit [Ping timeout: 268 seconds]
sjl_ has quit [Client Quit]
sjl_ has joined #lisp
anamorphic has joined #lisp
ntbre has joined #lisp
gxt has quit [Ping timeout: 250 seconds]
iAmDecim has quit [Remote host closed the connection]
iAmDecim has joined #lisp
ebrasca has joined #lisp
iAmDecim has quit [Ping timeout: 245 seconds]
devon has quit [Ping timeout: 250 seconds]
jprajzne has quit [Remote host closed the connection]
atgreen has joined #lisp
gxt has joined #lisp
scymtym has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
gravicappa has quit [Ping timeout: 244 seconds]
edgar-rft has joined #lisp
<phoe>
I have two trees of CLOS instances that form a cyclic graph. How can I compare them for equality? For slot values that are not standard instances, I'd like to use EQUAL; for slot values that are standard instances, I want to recurse while marking the instances I have already visited to avoid loops.
<phoe>
These instances are of different types; I also want to ensure that the respective instances are of the same type.
<pjb>
trees are acyclic.
<pjb>
So you don't have anything.
iAmDecim has joined #lisp
<phoe>
s/trees/graphs/
<pjb>
So (constantly t) will do.
<phoe>
Right, thanks.
<phoe>
(incf pjb)
<phoe>
Sigh.
<phoe>
I have two cyclic graphs of CLOS instances. (...)
<pjb>
If you have associations that have a multiplicity more than 1, then there could be an abiguity, and you might need backtracking.
<pjb>
Otherwise, you will need a walk of the two graphs. You can keep the nodes that are already walked in a hash-table.
<phoe>
Multiplicity? What do you mean?
<pjb>
car -> 4 wheels
<phoe>
Yep, I have such associations.
<phoe>
All instances have some sort of ID however, so I can sort them by that ID in each list and then assume that the order is the same.
<phoe>
Or, whenever I traverse one graph, I get the ID of the current instance, find the matching instance in the other graph, and use that instance for comparing the slot values.
<pjb>
Then you will have to backtrack. If you have a->nb and A->nB and a=A, then you will have to try n*(n-1) b=B.
<phoe>
Will I have to, if they are ordered? I can treat these collections as ordered, meaning that 1st element of one collection must be equal to 1st element of the other collection.
ntbre has quit [Quit: ntbre]
<phoe>
If it's equal to 2nd, we fail the test.
<phoe>
s/2nd/2nd instead/
iAmDecim has quit [Ping timeout: 240 seconds]
<pjb>
phoe: well, that depends if the two graph share the same nodes, or only nodes that are equal?
<phoe>
They don't have the same nodes - they have nodes that are distinct but have equal IDs
JetJej has quit [Quit: [Quit]]
<pjb>
Ok. Then yes, you can have a subalgorithm to match the list of nodes in the same association.
<phoe>
I wonder if that library has already been written somewhere.
<pjb>
I'm not sure about CL. We may have 1 or 2 libraries to process graphs.
<pjb>
There were a couple of math libraries developed in Japan. Perhaps they had something about graph, I'm not sure.
DGASAU has quit [Ping timeout: 250 seconds]
sauvin has quit [Ping timeout: 250 seconds]
DGASAU has joined #lisp
<phoe>
Hm. I might want to approach my testing differently, then.
<phoe>
Maybe via testing individual objects as opposed to whole graphs of them.
cgay has joined #lisp
<pjb>
phoe: why? We've got a good algorithm.
xkapastel has joined #lisp
<phoe>
pjb: writing it down is above my capabilities right now.
ravenous_ has joined #lisp
Lycurgus has quit [Quit: Exeunt]
iAmDecim has joined #lisp
robdog_ has joined #lisp
quazimodo has joined #lisp
<Josh_2>
why does (asdf:load-system) look for my files in /tmp?
<Josh_2>
I'm guessing because my asd was compiled in /tmp?
<Xach>
Josh_2: did you save an image?
<Josh_2>
O rip I got it
amerlyq has quit [Quit: amerlyq]
<Josh_2>
Xach: nope, I was c-c c-c the .asd file so it was compiling it in /tmp I suppose
robdog_ has quit [Remote host closed the connection]
<Josh_2>
when I loaded the file with (load .. ) it worked fine
<Josh_2>
bit annoying
<Xach>
oh.
anamorphic has quit [Quit: anamorphic]
<phoe>
ASD files are save-only
<Xach>
it isn't reliable to load it, either. but it often works.
<Xach>
load with cl:load, that is.
<Josh_2>
I'll remember that :) phoe
<Josh_2>
Xach: how should it be done?
<Xach>
Josh_2: (asdf:load-asd "/path/to/file") I think. Although I note that I just tried that on a bogus pathname and it returned something, so I don't know what to expect any more.
ntbre has joined #lisp
<Josh_2>
Seemed to work for me
anamorphic has joined #lisp
<Josh_2>
Yep worked just fine thanks Xach
ebrasca has quit [Read error: Connection reset by peer]
<dim>
for people who want a graph lib in CL, maybe that's a good candidate
Denommus has joined #lisp
quazimodo has quit [Remote host closed the connection]
<pjb>
phoe: actually if you have a graph that knows its list of nodes, we don't need to walk the graph, just process the list of nodes (and we have to). On the other hand, if the graph is connected, and we only have one "root" node, then we need to walk it.
Denommus has quit [Remote host closed the connection]
quazimodo has joined #lisp
ravenous_ is now known as ravenousmoose
smokeink has joined #lisp
kajo has quit [Ping timeout: 268 seconds]
<phoe>
pjb: sure, I can easily compute a list of all nodes in the graph.
MightyJoe has quit [Ping timeout: 250 seconds]
cyraxjoe has joined #lisp
iAmDecim has quit [Ping timeout: 246 seconds]
vertigo has quit [Ping timeout: 246 seconds]
vertigo has joined #lisp
ravenousmoose has quit [Quit: Taking a quick nap...ZZzzz]
kajo has joined #lisp
atgreen has quit [Ping timeout: 240 seconds]
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
anamorphic has quit [Client Quit]
<fiddlerwoaroof>
I've had pretty good luck C-c C-k ing an asd then quickloading the sytem
<fiddlerwoaroof>
I'm not quite sure if this is leveraging undefined behavior, though
anamorphic has joined #lisp
iAmDecim has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<Josh_2>
usocket tcp streams are read with read-bytes? or no :O
iAmDecim has quit [Ping timeout: 244 seconds]
<fiddlerwoaroof>
read-sequence would probably work, if they're actually streams
ravenousmoose has joined #lisp
<fiddlerwoaroof>
Or, you might be able to wrap them with a flex-stream and get strings out
<Josh_2>
well they are usocket-stream
<fiddlerwoaroof>
You should be able to do something like (let ((buf (make-string 10))) (read-sequence buf socket-stream) buf)
<fiddlerwoaroof>
But if you need to think about encodings, it might be a bit more work