pranavats has left #commonlisp [Error from remote client]
genpaku has joined #commonlisp
ebrasca has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 276 seconds]
<mfiano>
I don't know what I'm doing wrong. (let ((*package* (find-package :foo))) (load "/some/file.lisp)) where the file has toplevel macro calls of macros defined in package :foo, but these forms are trying to evaluate their arguments like a function. What am I doing wrong?
szkl has joined #commonlisp
Lord_of_Life has joined #commonlisp
<mfiano>
The standard says LOAD should preserve the current package.
<mfiano>
Ignore me. Dumb mistake during a refactor.
Oladon has quit [Quit: Leaving.]
prokhor_ has quit [Ping timeout: 248 seconds]
akoana has joined #commonlisp
pranavats has joined #commonlisp
akoana has quit [Quit: leaving]
hayblender has joined #commonlisp
santiagopim has quit [Ping timeout: 276 seconds]
bilegeek_ has joined #commonlisp
bilegeek has quit [Ping timeout: 255 seconds]
bilegeek_ has quit [Remote host closed the connection]
bilegeek_ has joined #commonlisp
Bike has quit [Quit: Lost terminal]
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
<mason>
Hah, so, this is funny. Looking to see what I thought of LoL in the past, and I find a journal entry from 2012: 'I'm not linking to "Land of Lisp" on my home page any more. I've decided that the guy is teaching bad coding hygeine. I can't support that.' I think I was bothered by his intentionally coding what amounted to a memory leak.
<mason>
Teaching it as a technique.
<Guest74>
memory leak?
<mason>
I'll have to find the example. He updates some state by adding new things to a list. There's never any use of the older values, so they just sit in memory forever.
<mason>
Someone on IRC chastised me for holding that opinion, but I can't find that now.
anticomputer has quit [Ping timeout: 240 seconds]
<mason>
I'm coming around to the idea that maybe there needs to be a guideline and set of teaching materials for teaching programming to kids that isn't tied to one of the existing books.
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #commonlisp
<beach>
Good morning everyone!
<mason>
o/
<mason>
beach: So, we've turned 90° to the left and we're going with How to Design Programs, second edition. (Or maybe it's 90° to the right given the author's politics? But anyway.)
<beach>
Who is the author?
<mason>
Felleisen.
<beach>
Ah, OK.
<mason>
Group effort, but he's listed first and I assume that's by quantity.
waleee has quit [Ping timeout: 255 seconds]
<mason>
I'd actually given the book a test run with my wife as the guinea pig before it went to press, and she liked it, so I might be able to loop her back in too.
<beach>
Sounds great!
<mason>
Hrm. And now I notice that the authors happen to be listed alphabetically by last name. :P Ah well. Anyway. I'll report back. One of the things I want to do (mentioned above) is come up with something that can have details of book and language plugged in that motivated parents can use to teach their kids in a classroom format.
<beach>
Looking forward to your report.
<mason>
It might come in the form of a request for review. Anything I make will end up being CC0 or similar.
<beach>
minion: What does CC0 stand for?
<minion>
a man, a plan, a canal - panama
<mason>
hah
<mason>
Creative Commons Zero. It's essentially consignment to the public domain where the concept exists, and an effort to relinquish as many rights as possible where it does not.
<mason>
(It's as much a political statement as anything, in part a reaction to the Linux folks consciously attacking the ZFS folks by frequently marking interfaces as "GPL only" and maliciously breaking ZFS. I like copyleft and the GPL but not that behaviour or mis-use.)
<mason>
Anyway, bbiab.
bilegeek_ is now known as bilegeek
livoreno has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
szkl has quit [Quit: Connection closed for inactivity]
karlosz has quit [Ping timeout: 244 seconds]
<beach>
mfiano: [answering your recent utterances in #clschool] Yes, it is good that we concluded that condition types must be classes. However, I could really use a lot of help writing up "issues" for WSCL. I currently have more work lined up than my remaining life expectancy permits.
<beach>
This one is a biggie, touching several sections in the standard.
hayblender has quit [Ping timeout: 248 seconds]
hayblender has joined #commonlisp
hayblender has quit [Ping timeout: 272 seconds]
cosimone` has quit [Remote host closed the connection]
cosimone` has joined #commonlisp
shka has joined #commonlisp
Psybur has quit [Ping timeout: 258 seconds]
rainthree has joined #commonlisp
idkwhat has joined #commonlisp
hayblender has joined #commonlisp
cosimone` has quit [Remote host closed the connection]
<jasom>
The update-alist is supposed to be generally correct for an alist in an arbitrary place, and should be equivalent to the update-hash-table just above it in what it accomplishes...
<jasom>
"update" is from clojure and it modifies an associative structure M by setting the value associated with K to (funcall F K) or (funcall F nil) if there is no value associated with K.
ttree has quit [Ping timeout: 248 seconds]
<jasom>
"update" is from clojure and it modifies an associative structure M by setting the value associated with K to (funcall F <old value associated with K>) or (funcall F nil) if there is no value associated with K.
attila_lendvai has joined #commonlisp
Cymew has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
rainthree has quit [Read error: Connection reset by peer]
Posterdati has quit [Read error: Connection reset by peer]
<mfiano>
I wonder if anyone has ever devised a custom method combination that behaves like standard, but switches the order in which before and after methods are invoked. I am also curious if such a thing even makes sense, but I have found I wanted at least standard auxillary after methods to be invoked in reverse order twice. Both times a change in architecture fixed the problem, but still curious if
<mfiano>
it has been done before/makes any sense.
<Josh_2>
beach I know :(
pfd has quit [Quit: Client closed]
<Josh_2>
Idk why I use Ningle
<Josh_2>
I just want the post params :(
scymtym has quit [Remote host closed the connection]
Brucio-61 has quit [Remote host closed the connection]
<Josh_2>
Oh wait this is my fault :sunglasses:
Posterdati has joined #commonlisp
cosimone` has quit [Remote host closed the connection]
cosimone` has joined #commonlisp
karlosz has quit [Quit: karlosz]
eull has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
scymtym has joined #commonlisp
Brucio-61 has joined #commonlisp
Posterdati has quit [Read error: Connection reset by peer]
Posterdati has joined #commonlisp
aartaka has quit [Ping timeout: 258 seconds]
Posterdati has quit [Read error: Connection reset by peer]
<lisp123>
X3J13 voted in March 1989 (ZLOS-CONDITIONS) to integrate the Condition System and the Object System. All condition types are CLOS classes and all condition objects are ordinary CLOS objects.
<lisp123>
On a tangent, people need to be recommending ClTL more. Its by far the best book on CL
<mfiano>
Less subjectivity and more reasoning needed.
<lisp123>
I got a hardcopy but never opened it (too unweildy given the size is ~ 1000 pages)
<rotateq>
I'm near to buy mine finally.
<lisp123>
Nice
<lisp123>
I bought a hardcopy of PCL when it went on sale but it never got delivered to me :(
<AadVersteden[m]1>
Buy it again! It still makes me happy. I even donated some ^_^
<lisp123>
Nice one
simendsjo has joined #commonlisp
notzmv has joined #commonlisp
idkwhat has quit [Quit: Leaving...]
lisp123 has quit [Remote host closed the connection]
MajorBiscuit has quit [Quit: WeeChat 3.5]
MajorBiscuit has joined #commonlisp
lisp123 has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.5]
treflip has joined #commonlisp
MajorBiscuit has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Ping timeout: 272 seconds]
tyson2 has joined #commonlisp
MajorBiscuit has joined #commonlisp
MajorBiscuit has quit [Client Quit]
pve has joined #commonlisp
MajorBiscuit has joined #commonlisp
<jamesmartinez>
lisp123: I just recently bought PCL, I'm on Chapter 6
<jamesmartinez>
\
<beach>
jamesmartinez: Congratulations!
<jamesmartinez>
beach: thanks :)
<jamesmartinez>
beach: was PCL your first CL introduction?
<beach>
Heh, no! It didn't exist then.
<jamesmartinez>
oh
<rotateq>
It's relatively new. :) 2005 iirc
<jamesmartinez>
rotateq: I know what rotatef is but don't know what rotateq is
<rotateq>
jamesmartinez: That is the hommage to it. ^^ Cause there's SETQ and SETF but no such symbol to ROTATEF.
<lisp123>
beach: which book did you use to learn CL?
<lisp123>
or just lecture notes
<jamesmartinez>
ah, I see, I think PCL said that setf is a macro that expands to something that uses setq
<beach>
It might have been the one by Graham.
<rotateq>
And good you know it already, I first wasn't aware some time, then wrote my own simple SWAP macro and a bit later discovered it.
<lisp123>
I see
<rotateq>
Oh, let me see when the Graham books came out.
<jamesmartinez>
beach: On Lisp by Paul Graham?
<rotateq>
It may be not too much to start when you have already experience with another dialect.
<beach>
jamesmartinez: No, the first one. I forget the name, and I can't find my copy.
<rotateq>
jamesmartinez: And be welcome to also drop questions in #clschool anytime.
<jamesmartinez>
rotateq: thanks, will do
<rotateq>
Ah then "ANSI Common Lisp".
<beach>
Ah, yes.
<jamesmartinez>
I have On Lisp but I felt that it was not for Lisp beginners so I have it on the back burner for now
<rotateq>
jamesmartinez: Yes, keep it for later, but contains many interesting things too.
<jamesmartinez>
I also have the Apress Programming Algorithms in Lisp to read
<rotateq>
Oh I bought that from Vsevolod directly by mail contact before it came to Apress. :)
<beach>
ANSI Common Lisp seems to be from 1995.
<jamesmartinez>
rotateq: nice
<rotateq>
Yeah and On Lisp from 1993.
<beach>
Oh, interesting!
<beach>
Before the standard.
cosimone` has quit [Remote host closed the connection]
cosimone` has joined #commonlisp
<lisp123>
On Lisp had some good macros, but I don't rate it as highly as I may have used to
<lisp123>
I haven't seen that many great books on macros, but I haven't read Let over Lambda deeply yet either
<rotateq>
lisp123: be careful with that
<lisp123>
On Lisp did have an _excellent_ chapter on continuations
<rotateq>
Yes I enjoyed it, finally you get a really way deeper idea of something when you can build it yourself, not just use.
cosimone` has quit [Remote host closed the connection]
lisp123 has quit [Quit: Leaving...]
rainthree has quit [Ping timeout: 258 seconds]
rainthree has joined #commonlisp
cosimone` has joined #commonlisp
Bike has joined #commonlisp
ldb has joined #commonlisp
<ldb>
If I use drakma and send a get request every 2 seconds, should I consider reuse the socket?
<Josh_2>
If you use Dex it should do that automatically
<ldb>
Josh_2: cool
<ldb>
does that means I can get every 1 seconds now?
<Josh_2>
Maybe
<Josh_2>
I make a lot of requests using Dex to the same address, way more than 1 a second
<ldb>
I connect to localhost to send commands to a chat application
<Josh_2>
Is it your chat app?
<ldb>
It is a chat app only open to users logined to a public server, and I have consent from the admin
<Josh_2>
Well make requests as often as you want, 10 a second isn't going to do anything to the webserver if you consider even the slowest HTTP servers can process thousands of requests a second
<ldb>
does the :content argument of dex:post needs to be octets if contains non-latin chars?
eull has quit [Quit: eull]
<ldb>
Josh_2: thanks for the advise, I have never programmed http before so I don't know if I would overload the server
<Josh_2>
No problem
wmblathe_ has joined #commonlisp
<pjb>
ldb: the problem is not the periodicity of your request. 0.5 Hz is very low, and you can repeat the DNS request, the connection, the HTTP overhead, sending your request and getting the answer, and the disconnection without any problem.
<pjb>
ldb: the question is what happens if now your program becomes successful, and one million people are doing the same?
<pjb>
ldb: 10,000 to 30,000 transactions per second is achievable easily with current server and network hardware. But not if you keep disconnecting and reconnecting between each transaction!
wmblathers has quit [Ping timeout: 244 seconds]
<pjb>
ldb: in any case, with a million customer, you'll need a hundred or more servers.
<pjb>
(simultaneous customers, so say several billion registered customers!)
<ldb>
I'm pretty sure there only my client would connect to the server
<pjb>
ldb: now, the question is do you expect to grow to billions of users overnight? Or do you plan to have some time to get some VC money and rewrite the product 3 times before reaching that level?
<pjb>
ldb: yes, if you have a single client, and no expected growth, anything will do! Even the most horrible overhead.
<ldb>
pjb: ah, cool
<ldb>
I do discover dex has a much easier to use API though
<pjb>
Exactly. Use the easiest thing. There will be time for optimizations later, if they're ever required!
Dynom has quit [Ping timeout: 255 seconds]
Dynom has joined #commonlisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #commonlisp
treflip has quit [Quit: i slep]
ec_ has joined #commonlisp
rotateq has quit [Remote host closed the connection]
causal has quit [Quit: WeeChat 3.5]
waleee has joined #commonlisp
ldb has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
Th30n has quit [Quit: bye]
jmes has joined #commonlisp
<jmes>
Is it possible to have a generic function with some parameters that are only needed for one of its methods? e.g. I might want (draw object-with-coords) and (draw object-without-coords x y). Does this make any sense?
<jmes>
Let's say I don't want to make a subclass of object-without-coords to hold its coords
<Bike>
if you have the clisp version corresponding to these notes, you do `:bt 1` etc instead
<Glaucon>
right, that's it
<Glaucon>
thanks!
<Bike>
no problem.
kpoeck has quit [Quit: Client closed]
Guest2990 has quit [Quit: Client closed]
<pjb>
Glaucon: the clisp debugger works better on interpreted code than on compiled code.
<pjb>
Glaucon: try to load the sources instead of fas files. Use asdf:load-source-op instead of asdf:load-op.
tyson2 has quit [Remote host closed the connection]
rainthree has quit [Ping timeout: 246 seconds]
Brucio-61 has joined #commonlisp
masinter__ is now known as masinter
Fare has quit [Ping timeout: 272 seconds]
anticomputer has quit [Ping timeout: 240 seconds]
<Glaucon>
pjb: i'm not using asdf, just bare clisp + 'require s and "load"ing code into the clisp REPL. i have to code a software renderer on a very short term and don't have time to set up and learn how to use a build system
anticomputer has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
Guest99 has joined #commonlisp
jolby has quit [Quit: Client closed]
jolby has joined #commonlisp
mon_aaraj has joined #commonlisp
Guest99 has quit [Quit: Connection closed]
pranavats has joined #commonlisp
kpoeck has joined #commonlisp
makomo has quit [Ping timeout: 258 seconds]
waleee has quit [Ping timeout: 248 seconds]
waleee has joined #commonlisp
<pjb>
Glaucon: REQUIRE requires the use of the second paramters. Give "foo.lisp" instead of "foo" or "foo.fas" !
<pjb>
Glaucon: but REQUIRE doesn't reload a module, so I still advise using LOAD instead to ensure the "foo.lisp" file is loaded even if you already loaded or required it
<Glaucon>
sure
_paul0 has quit [Ping timeout: 258 seconds]
<Glaucon>
suppose there is a utils.lisp that defines a package, two files that depend on utils.lisp and a fourth file that need to "#include" the two files
<Glaucon>
the fourth file being the main program
<Glaucon>
how to import the utils.lisp file in the two files that depend on it without loading utils.lisp twice?
ec has joined #commonlisp
<Glaucon>
(when the fourth main file is loaded)
orestarod has joined #commonlisp
<Glaucon>
using require to load utils.lisp in the two intermediate files doesn't prevent utils.lisp from being loaded twice
<Glaucon>
when the main file is loaded
<Bike>
you're kind of asking for a build system.
<Bike>
generally speaking, what you do is set up some other build description that loads all the files appropriately. if you don't have time to learn a build system, that probably means moving any file loads/requires out of your sources and into a build file that just loads everything else.
wmblathe_ is now known as wmblathers
<Glaucon>
right
paul0 has joined #commonlisp
<Glaucon>
that's like a tree with a root and many leaves, whereas i was building a tree with the nodes interlinked in a more complex way
<Glaucon>
a tree of dependencies
<Bike>
if you want a complex tree structure you should use an actual build system. but what you're talking about is pretty simple. (load "utils.lisp") (load "file1.lisp") (load "file2.lisp"), bam, done. file2 isn't dependent on file1 but you don't need to worry about that in the simple case.
<Glaucon>
that's right
Dynom has quit [Quit: WeeChat 3.5]
Fare has joined #commonlisp
<Glaucon>
also if the dependency graph is a tree, you can lay it out linearly so that the parents are always above the children
<Glaucon>
and therefore dependencies are loaded before the files that depend on them
rodicm has joined #commonlisp
rodicm has quit [Quit: Leaving]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
akoana has joined #commonlisp
ec has quit [Ping timeout: 240 seconds]
hashfuncae8 has joined #commonlisp
Fare has quit [Quit: Leaving]
Brucio-61 has quit [Remote host closed the connection]
Brucio-61 has joined #commonlisp
scymtym has quit [Remote host closed the connection]
scymtym has joined #commonlisp
Brucio-61 has quit [Ping timeout: 258 seconds]
Glaucon has quit [Quit: WeeChat 3.5]
scymtym has quit [Ping timeout: 272 seconds]
tyson2 has joined #commonlisp
rotateq has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
hashfuncae8 has quit [Remote host closed the connection]
waleee has quit [Ping timeout: 260 seconds]
Brucio-61 has joined #commonlisp
waleee has joined #commonlisp
karlosz_ has joined #commonlisp
scymtym has joined #commonlisp
karlosz has quit [Ping timeout: 276 seconds]
karlosz_ is now known as karlosz
igemnace has quit [Ping timeout: 246 seconds]
kpoeck has quit [Quit: Client closed]
mon_aaraj has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
cosimone` has quit [Read error: Connection reset by peer]
waleee has quit [Ping timeout: 258 seconds]
shka has quit [Ping timeout: 256 seconds]
waleee has joined #commonlisp
mon_aaraj has quit [Ping timeout: 240 seconds]
mon_aaraj has joined #commonlisp
waleee has quit [Ping timeout: 255 seconds]
karlosz has quit [Ping timeout: 258 seconds]
dra has joined #commonlisp
waleee has joined #commonlisp
mon_aaraj has quit [Ping timeout: 248 seconds]
<mfiano>
Is there anything like SUBSEQ builtin or part of some utility library, that when operated on a list re-uses the identical cons (shares structure) rather than allocate a new sequence. Really, what I want is to use BUTLAST, but that requires traversing the whole list to know the end to offset from, when I actually know in advance how many elements I want the original cons cells of.
karlosz has joined #commonlisp
mon_aaraj has joined #commonlisp
<jasom>
mfiano: butlast doesn't share structure?
<jasom>
mfiano: in general, it's not possible to share structure with subseq on a list without modifying the list; did you mean NBUTLAST?
morganw has quit [Remote host closed the connection]
dra has quit [Quit: Leaving]
karlosz has quit [Ping timeout: 258 seconds]
mon_aaraj has quit [Ping timeout: 258 seconds]
mon_aaraj has joined #commonlisp
saura has quit [Ping timeout: 248 seconds]
mon_aaraj has quit [Ping timeout: 255 seconds]
mon_aaraj has joined #commonlisp
saura has joined #commonlisp
saura has quit [Ping timeout: 248 seconds]
<mfiano>
jasom: Yes I did, but I would like to iterate from the start rather than the whole thing, when I know in advance the number of elements I want to detach from the cons chain.
<mfiano>
Just to clarify, I know how to do this trivially. I was just wondering if there is a utility function already existent.
<Alfr>
So you're free to modify the list?
<jasom>
mfiano: I don't think there is one already
bilegeek has joined #commonlisp
<mfiano>
Ok fair enough. NBUTLAST is acceptable here, as the list isn't that large/not _that_ frequently performed. I was just curious, as it makes a lot of sense to take the head of some list such that you don't need to take the implicit length of the list as with BUTLAST in order to determine where to stop.
<jasom>
A quick look didn't turn up anythin in CL or ALEXANDRIA
saura has joined #commonlisp
<Alfr>
mfiano, you can also just setf the cdr of the nthcdr to nil.
pve has quit [Quit: leaving]
<mfiano>
I wouldn't want to alter the original list, only be able to alter the cars through indirection in the shared structure sub-sequence
<mfiano>
Or something like that.
<mfiano>
My brain is not with it today. Ignore me.
random-nick has quit [Ping timeout: 276 seconds]
<Alfr>
mfiano, ah, okay. Just suggested it, because you mentioned nbutlast above.
<mfiano>
Really what I wanted to do was to take the first N elements of a list, keeping the original list intact, unless I were to alter the cdr's of the smaller list, in which case the original list would change.
<mfiano>
(or the cars I suppose, and in my specific use case I would only be altering the cars)
saura has quit [Ping timeout: 240 seconds]
<mfiano>
So the original list would retain it's length, only it's elements changed.
<mfiano>
Like literally iterate from the first cell until the nthcdr and collect the identities.
<mfiano>
Yes it is.
<mfiano>
I must point out that you expemplified one of beach and I's style pet peeves.
<mfiano>
exemplified*
<Alfr>
I don't think you can have that with lists only, because you can't modify the cdr chain to end the list prematurely w/o modifying the original list.
<Alfr>
mfiano, ^
<mfiano>
The last cons would have to be copied, sure.
<mfiano>
Which sort of ruins my use case, so thanks for pointing that out.
<Alfr>
mfiano, and that pointing to the last cons, repeat until you're at the fist cons.
<mfiano>
I just woke up not too long ago. I clearly wasn't thinking very well. Thanks for the slap.