<pillton>
That is quite a restriction. It also completely ignores the point of generic functions i.e. separating operations from state.
elderK has joined #lisp
rumbler31 has joined #lisp
<fiddlerwoaroof>
pillton: not really, I believe beach, for example, has mentioned similar things.
<fiddlerwoaroof>
In most cases you're either defining a new protocol or you're defining a new implementation of the protocol
<fiddlerwoaroof>
In the former case, since you defined the generic function, you can define methods that specialize it however you want, since you own the protocol
<fiddlerwoaroof>
In the latter case, you should only specify how your new class interacts with the pre-existing protocol, otherwise you might change the contract of the protocol for other classes.
<pillton>
If you want an object to perform an operation then implement it that way.
<elderK>
Hello all
fikka has joined #lisp
sobol has quit [Quit: leaving]
fikka has quit [Ping timeout: 246 seconds]
meepdeew has joined #lisp
<makomo>
hi
<makomo>
_death: interesting writeup regarding On Lisp, thanks. i'll give it a proper read when i get the time
<makomo>
hm, where's does one draw the line between using designators vs. using actual objects (that the designators designate)?
<makomo>
for example, in the case of ASDF, most of the time you can pass designators such as :hello or "hello" instead of the actual system object representing the system hello
<makomo>
but then comes asdf:component-version which takes a system object instead of a designator
<makomo>
(as in jmercouris' case above)
fikka has joined #lisp
<makomo>
when designing a library, where draw the line between accepting designators and not doing so?
<pillton>
When you have two or more representations which do not share a common class.
libre-man has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 250 seconds]
<makomo>
pillton: hm, i don't understand. by "representations" do you mean designators? if so, why?
<pillton>
A pathname designator has the type '(or string stream pathname).
<makomo>
right
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gxt has joined #lisp
<makomo>
i still don't understand what you meant though
<pillton>
The string "/tmp/hello-world.txt" is an equivalent representation of (make-pathname :name "hello-world" :type "txt" :directory '(:absolute "tmp")).
<pillton>
One is significantly shorter and platform specific though.
fikka has joined #lisp
lmy9900 has joined #lisp
<pillton>
(Most) users would prefer to type the string rather than instantiate a pathname.
<makomo>
oh, i think i see the point of your guideline now, which was in favor of designators in that case
<makomo>
what if you have 2+ representations and they do share a common class, but that class is not a common class for the object they designate?
<makomo>
you still have a designator but it is essentially only the common class of the 2+ designators
<makomo>
however, that wasn't really my question. i'm more wondering about API design, i.e. *when* to actually accept such designators and when not to
<Bike>
when it's convenient
<Bike>
i try to keep it at the very usermost end
<makomo>
i.e. whether to constantly worry within your API that a designator might be passed in, or to cut it off at one point and say "i want an object of type X now, no more designators"
fikka has quit [Ping timeout: 268 seconds]
<Bike>
yeah cut it off asap
<makomo>
Bike: i see, so basically a "layered" approach? the highest-levels parts accept them and then lower (library) levels don't?
<Bike>
yeah
<pillton>
Like Bike said, it is typically for the users.
libre-man has joined #lisp
<makomo>
Bike: do you say ASAP because it hurts efficiency or just because it's tiresome?
<Bike>
both, but mostly the latter
jandelic has joined #lisp
fikka has joined #lisp
<makomo>
mhm
robdog has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 250 seconds]
jandelic has left #lisp [#lisp]
eminhi has quit [Quit: leaving]
iAmDecim has joined #lisp
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog has joined #lisp
robotoad has joined #lisp
shifty has joined #lisp
robotoad_ has joined #lisp
fikka has joined #lisp
robotoad has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 246 seconds]
steiner has quit [Remote host closed the connection]
steiner has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
<fiddlerwoaroof>
It's like input validation in a web app: you want to validate and sanitize the user-submitted data asap so you don't have to worry about all the nonsense a user will throw at you.
robdog has joined #lisp
esrse has joined #lisp
makomo has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
skidd0 has joined #lisp
<skidd0>
hello
<skidd0>
when creating an asdf system, how can I set up some special variables on system load?
<skidd0>
or, should I instead create a init-system function to be run "manually"
<skidd0>
or..?
fikka has joined #lisp
Necktwi has quit [Quit: leaving]
<fiddlerwoaroof>
It depends on what exactly you want to do, but I think the write thing is an :around method on perform that is specialized one your current system and some operation such as load-op
<fiddlerwoaroof>
Hmm, that probably won't do what you want, actually.
fikka has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
You want to make sure some variables are set when your program starts?
<skidd0>
yes
<fiddlerwoaroof>
Yeah, I'd have your program's entrypoint call a function to set them up
<skidd0>
though in this instance i want to set a *special* for a hashing function
<skidd0>
only once so i'm not resetting the same special each time i call get-hash
<fiddlerwoaroof>
I think that should work out fine, something like (defun main () (initialize-hash-lib) (do-stuff))
<skidd0>
so i'm thinking now that an :around on the get-hash could set it up once
<fiddlerwoaroof>
You could do that too, if that makes sense
<skidd0>
tho checking if *special* is set is probably just as time consuming as resetting the *special* anyway
Necktwi has quit [Quit: leaving]
Necktwi has joined #lisp
marusich has joined #lisp
robotoad_ has quit [Quit: robotoad_]
igemnace has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
nirved has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 250 seconds]
SaganMan has joined #lisp
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kyby64 has quit [Quit: Leaving]
robdog has joined #lisp
Lycurgus has joined #lisp
fikka has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
lmy9900 has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
anewuser has quit [Ping timeout: 268 seconds]
CrazyEddy has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
robotoad has joined #lisp
fikka has joined #lisp
slyrus1 has quit [Quit: slyrus1]
Bike has quit [Quit: Lost terminal]
fikka has quit [Ping timeout: 250 seconds]
slyrus1 has joined #lisp
marusich has quit [Ping timeout: 268 seconds]
sonologico has quit [Ping timeout: 268 seconds]
robdog has quit [Read error: Connection timed out]
elfmacs has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
arescorpio has joined #lisp
robdog has joined #lisp
<elderK>
Guys, is there any reason why I cannot access an inherited slot via slot-value?
<pillton>
Are you in a different package?
<elderK>
Ah, I see.
<elderK>
Yes.
<elderK>
I just figured that out, I need to use the symbol used by the originating package.
<elderK>
so, foo::bar say
<no-defun-allowed>
yep
fikka has quit [Ping timeout: 250 seconds]
<elderK>
I'll use the accessors :)
<elderK>
make-load-form is handy :)
<elderK>
Have been working on my structure-thing. God damn I have a lot of helper functions for it :P
<elderK>
Still, if (when?) it works, evne if it's ugly, it's going to be a real thrill :)
<elderK>
Is it safe to use slot-value to access a structure's slots?
<fortitude>
elderK: technically, no; a structure can have several representations including a plist or other non-class value
<fortitude>
if you're willing to require that the struct be class-based, then I think then slot-value is safe to use (not 100% sure though)
<LdBeth>
Although there’s potential suffer performance loss
<beach>
Good morning everyone!
<LdBeth>
Morning, beach
robdog has quit [Ping timeout: 252 seconds]
<beach>
elderK: I recommend you not use SLOT-VALUE at all. Not even for standard objects.
slyrus1 has quit [Quit: slyrus1]
<elderK>
beach: Thanks :) I've bene feeling that slot-value is kind of nasty.
<elderK>
I tend to use accessors, or with-accessors
<beach>
Yes, much better.
<elderK>
I read a long time ago that that is better, because you know, people can hook them
<elderK>
This complicates my macro though, as I now need to generate accessor names :P
<elderK>
Ah well :)
<beach>
The existence or not of a particular slot is an implementation detail. A protocol is defined by functions and initargs.
<elderK>
Yup
fikka has joined #lisp
robdog has joined #lisp
space_otter has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
jasmith has joined #lisp
marusich has joined #lisp
fikka has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 250 seconds]
marusich has quit [Ping timeout: 268 seconds]
<elderK>
beach: What uses are there for make-load-form? Like, where is it best applied? :)
<elderK>
From what I understand, it allows us to provide a form that can reconstruct some literal at load-time.
<beach>
It's rare that you need it. Only when you need to save application objects in a FASL so that you can create a similar object when the FASL is loaded.
fikka has joined #lisp
<elderK>
beach: I've seen it used in a way that suggests it can be used to somehow store data that the compiler is using when generating a macro expansion, into the expansion.
<elderK>
Like, binary-types creates a bunch of record objects - then patches them into the expansion as literals.
<elderK>
It specializes make-laod-form for those record objects.
<beach>
Yes, I can see that. Any time you compile something that contains literal objects that the system does not know how to represent in a FASL, you need this kind of mechanism.
<elderK>
Okay, neat :)
<elderK>
Thank you
<beach>
Sure.
fikka has quit [Ping timeout: 250 seconds]
* beach
wonders whether FASLs are still useful.
SaganMan has quit [Ping timeout: 268 seconds]
arescorpio has quit [Remote host closed the connection]
lmy9900_ has joined #lisp
neosloth has quit [Quit: issued !quit command]
lmy9900__ has joined #lisp
fikka has joined #lisp
lmy9900_ has quit [Ping timeout: 250 seconds]
beach has quit [Disconnected by services]
beach has joined #lisp
lmy9900 has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
lmy9900__ has quit [Ping timeout: 246 seconds]
lmy9900 has quit [Ping timeout: 250 seconds]
dddddd has quit [Remote host closed the connection]
orivej has joined #lisp
lmy990___ has joined #lisp
lmy990___ has quit [Ping timeout: 246 seconds]
lmy9900__ has joined #lisp
shka_ has joined #lisp
fikka has joined #lisp
pflanze has quit [Ping timeout: 252 seconds]
lmy990___ has joined #lisp
lmy9900__ has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 246 seconds]
cpape has quit [Ping timeout: 252 seconds]
lmy9900 has joined #lisp
h11 has joined #lisp
lmy990___ has quit [Ping timeout: 268 seconds]
<beach>
Actually, that's an interesting topic. Talk to me about the usefulness of FASLs now that computers are so fast that you can compile the code when it is LOADed without any significant performance impact!
lmy9900_ has joined #lisp
<no-defun-allowed>
okay, i'll play devil's advocate for something i don't entirely understand
fikka has joined #lisp
<no-defun-allowed>
here's one: macros can do anything normal functions can so what if a macro does a lot of processing on its arguments?
<beach>
So your argument is still about performance?
q-u-a-n has joined #lisp
<p_l>
beach: FWIW, on my pretty recent hw I see considerable real time difference between loading code from FASL and compiling
lmy9900 has quit [Ping timeout: 246 seconds]
<beach>
p_l: Oh, sure. But my point is that you don't do that very often.
<p_l>
beach: I do it often enough to make a difference in *interactive* use
<no-defun-allowed>
otoh, asdf or quicklisp loads fasls when your system definition is absolutely broken or something like that and it's annoying
<no-defun-allowed>
eg: you move your toplevel stuff to src/ and the files are no longer there cause you neglected foo.asd and it loads from the fasls
<shka_>
beach: modern systems have constantly increasing number of dependencies and compilation time adds
<beach>
p_l: Can you describe to me the kind of use you have that makes you do that often?
Inline has quit [Quit: Leaving]
fikka has quit [Ping timeout: 250 seconds]
<beach>
shka_: Again, you are talking one execution at the beginning of a session that should typically last months, unless your computer crashes the way mine does.
<no-defun-allowed>
):
<shka_>
and what about, you know, restarting?
<beach>
shka_: I restart my Common Lisp system only because my computer crashes.
<shka_>
i don't keep my computer running for months
<beach>
You should.
skidd0 has quit [Quit: WeeChat 2.2]
lmy9900 has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<shka_>
does not seems to be energy efficient ;-)
<beach>
This is getting interesting.
<p_l>
Energy efficiency can be handled by suspend
<beach>
shka_: Come on, when it is not used, it doesn't consume much.
<no-defun-allowed>
i don't either, mine has obnoxious blue lights in the case
<beach>
If you are worried about that, use hibernation.
<shka_>
also, sometimes i need to upgrade some stuff in system
<p_l>
But without an editable image history, FASL see for me
<beach>
Oh, every day or so?
<shka_>
arch linux ;-)
<shka_>
so kinda
<beach>
This is getting VERY interesting.
<shka_>
but i don't restart always
lmy9900_ has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
btw i use arch
<no-defun-allowed>
wait no i don't but i probably should cause at least it's easier to install alternate drivers which might not crash on it
<beach>
p_l: I don't understand. If you work on some system, you would typically edit a single file at a time, then C-c C-c or run ASDF which would then only compile and load one single file. No?
<no-defun-allowed>
i'd consider leaving a lisp "running" if s-l-a-d somehow kept the slime connection
<beach>
p_l: Do you seriously quit your Common Lisp system every time you edit a file?
lmy9900_ has joined #lisp
<beach>
no-defun-allowed: remind me what s-l-a-d is.
<no-defun-allowed>
well, i do when i move to something else for a while
<shka_>
also, emacs packages are also the thing
<no-defun-allowed>
sb-ext:save-lisp-and-die (or an equivalent in your lisp)
<beach>
Oh.
<beach>
no-defun-allowed: I still don't get it...
<shka_>
and (popular) spacemacs handles upgrade by restarting
h11 has quit [Quit: Ping timeout (120 seconds)]
<beach>
no-defun-allowed: Why don't you just leave your SLIME running.
<no-defun-allowed>
or of course, yeah, full machine hibernation would also work
h11 has joined #lisp
<no-defun-allowed>
cause i don't leave emacs running all the time cause i'm still stuck in a "workspaces don't exist" mindset sometimes
<beach>
WOW, this is getting EXTREMELY interesting.
lmy9900 has quit [Ping timeout: 246 seconds]
<shka_>
beach: reality is so often stranger then fiction ;-)
<no-defun-allowed>
cause i was brought up on winxp where the closest thing was a hack which "grouped" programs and windows and would let you minimize and reshow groups
<beach>
Let me summarize: p_l is quitting the Common Lisp system for no reason. shka_ upgrades several times a day, and no-defun-allowed has not considered leaving the Common Lisp system running. :)
<beach>
VERY INTERESTING INDEED.
<no-defun-allowed>
also sometimes i need to purge out old code since i'm pretty bad at leaving a system half broken and the saved code's fine
<shka_>
actually the most frequent reason for restarting lisp for me is lost invariant of GC :P
<beach>
shka_: Aha, so we need FASLs because your Common Lisp system is buggy.
<no-defun-allowed>
on that note, is there a way to replace a :BEFORE or :AFTER method with slime like you would with a defun?
<shka_>
beach: nah, that's beside the point
<no-defun-allowed>
from experience it just tacks another one on, but i do understand figuring out which to replace may not be trivial
<beach>
shka_: OK, so we need FASLs because you break your Common Lisp systems by using FFI?
<shka_>
beach: but there is one legitimate case
<shka_>
beach: i don't use FFI
<beach>
So why do you lose GC invariants?
<pjb>
in the meantime: cl-user> (uptime) / uptime: 11 days, 15 hours, 6 minutes, 24 seconds. / 1004784
<shka_>
i wish i would know
<no-defun-allowed>
admittedly "macros could be slow" is my only reason to keep fasls
<beach>
shka_: So your Common Lisp system is buggy.
<shka_>
that's what i suspect
<shka_>
anyway,
<shka_>
there is one more case
<shka_>
testing
<beach>
Anyway, I would like to thank everyone for this VERY INTERESTING discussion. I now have a very good picture of why people need FASLs.
<shka_>
i don't run tests in the same image as developing
<no-defun-allowed>
i've heard ccl on arm has had problems with threads and gc, but i don't know much about that other than my research on cl on pi
<beach>
shka_: Are you saying your Common Lisp system does not have first-class global environments?
<shka_>
and Xach even suggested restarting computer before running tests
<no-defun-allowed>
yep ):
<shka_>
beach: it does not
<shka_>
^^
<pjb>
beach: there are a few systems in quicklisp that are actually slow to compile.
yvy has joined #lisp
<beach>
pjb: And how often do you need to compile them?
<no-defun-allowed>
same thing here with tests, i often spin up a second lisp in a terminal to load tests.lisp and see if it loses or not
<pjb>
eg. "nineveh" "cl-sat.minisat"
<pjb>
"how often do we need to load them?" you mean.
<shka_>
cl-ml is very slow to build
<pjb>
fasl are justified for them.
<no-defun-allowed>
after hacking around with aeth to get gitlab ci working on cl, i get a bit too pissed off when ci fails
<beach>
pjb: Yes, that's probably what I mean.
lmy9900 has joined #lisp
<no-defun-allowed>
also testing the tests is important since i did a lot of prototyping of my admittedly very simple fuzzer
<beach>
Again, thanks to everyone for this very enlightening discussion. I am a bit wiser than I was 15 minutes ago.
<beach>
And I have a plan of action for SICL as a result.
<beach>
Time for a break. Back in 30 minutes or so.
<no-defun-allowed>
no problem :p
<shka_>
somehow i feel that we failed ;-)
fikka has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
<no-defun-allowed>
come to think of it after a recent slowdown in my programming ci has very destructive psychological effects
<no-defun-allowed>
you end up just doing the bare minimum required to pass the tests sometimes
<fiddlerwoaroof>
beach: I generally have one lisp session that I use for most of my projects and then one or more that I use for things I don't want to accidentally kill
<fiddlerwoaroof>
e.g. stumpwm/etc.
<fiddlerwoaroof>
However, I have a tendency to hit the heap size limit at the worst possible times
steiner has left #lisp ["ERC (IRC client for Emacs 26.1)"]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 245 seconds]
<fiddlerwoaroof>
As far as stale-code goes, I've found that (delete-package :foo) or (rename-package *package* (format nil "~a.OLD" (package-name *package*))) solves most of those issues
fikka has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
As far as quicklisp is concerned, I think ironclad takes about a minute to compile, as does mcclim if I'm compiling it fresh
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 250 seconds]
lmy990___ has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
steiner has joined #lisp
lmy9900__ has joined #lisp
lmy9900_ has quit [Ping timeout: 250 seconds]
lmy990___ has quit [Ping timeout: 268 seconds]
hiroaki has joined #lisp
orivej has joined #lisp
<beach>
fiddlerwoaroof: Thanks.
fikka has joined #lisp
Lycurgus has quit [Quit: Exeunt]
frodef has joined #lisp
<beach>
fiddlerwoaroof: Yes, that's my impression as well. And I don't load McCLIM that often. It is typically already loaded in my current session.
orivej has quit [Ping timeout: 244 seconds]
Bike has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 244 seconds]
lmy9900__ has joined #lisp
drewc has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
sauvin has joined #lisp
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900__ has quit [Ping timeout: 246 seconds]
makomo has joined #lisp
lmy9900_ has joined #lisp
elfmacs has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
<p_l>
beach: actually, what happens often for me is the need for a clean environment
<beach>
Yes, I understand.
<beach>
Your Common Lisp system doesn't have first-class global environments.
<p_l>
beach: which is something I referred to earlier as something that would help immensely ;-)
<beach>
Indeed.
<p_l>
Or rather I mentioned a feature that would be implementable with them
<beach>
I am getting a pretty good picture of the situation.
lmy9900_ has quit [Ping timeout: 268 seconds]
<p_l>
beach: also, sometimes I want to ship fasl because I get to control compile time environment
lmy9900_ has joined #lisp
<fiddlerwoaroof>
I find that I can deal with the lack of first-class global environments in most cases by strategically renaming packages before recompiling and loading the files I'm interested in
<p_l>
beach: but that's something less of "fast load" and more "image fragment"
yvy has quit [Read error: Connection reset by peer]
<beach>
p_l: My current plan for SICL is to use the AST as a FASL, which would have the same characteristics.
<fiddlerwoaroof>
But, I tend to write my code to avoid compile-time side effects as much as possible
<p_l>
beach: pre or post macroexpansion?
<beach>
Post, of course.
lmy9900 has quit [Ping timeout: 246 seconds]
<beach>
ASTs are independent of the environment.
<p_l>
Except they aren't fully if you always depend on target env code gen
fikka has joined #lisp
<fiddlerwoaroof>
That would mean that, in theory, you could use the same FASLs on different architectures, though
<beach>
Sort of.
<fiddlerwoaroof>
A bit like the way iSeries boxes work
<beach>
Macros might look different on different architectures.
<p_l>
My dream feature would be an "image fragment" where code could be located both in three different forms at least - source, AST, machine code, all possibly linked so I could edit the source that came with binary
<fiddlerwoaroof>
Yeah, I guess reader conditionals could cause issues too
<beach>
p_l: The AST format fulfills the requirement that the Common Lisp HyperSpec has on file compilation.
<fiddlerwoaroof>
p_l: I really want a common lisp that's more like a smalltalk
<fiddlerwoaroof>
in the way it uses the image
<beach>
fiddlerwoaroof: Working on it.
<fiddlerwoaroof>
Yeah, I've been hoping to find time to do some of the programmer conveniences
<beach>
fiddlerwoaroof: CLOSOS wold be such a system.
<fiddlerwoaroof>
e.g. version control without files
<p_l>
fiddlerwoaroof: that's what my "image fragment" would do
<fiddlerwoaroof>
yeah
<p_l>
In a sense, the idea is that a) source code is just an object in the image b) you can export portions of the image and import them in different environments
<p_l>
This would also tie in with beach ideas for CLOSOS and single-level store
<fiddlerwoaroof>
I've recently been experimenting with using logical pathnames inside the defsystem's :pathname to see if I can get better source-finding capabilities without too much work
<fiddlerwoaroof>
p_l: yeah, that sounds a lot like what I'm thinking of
fikka has quit [Ping timeout: 246 seconds]
lmy9900__ has joined #lisp
<fiddlerwoaroof>
one thing that occurs to me is that SQLite has a mode where it can append a database to any random file and so, since most executables ignore random junk at the end, I've thought it would be interesting to have an attached sqlite database for holding things like source code and other instance metadata
<fiddlerwoaroof>
obviously, the end goal would be something that didn't depend on a non-lisp library, but I thought this might be an easy way to get a proof of concept working
<p_l>
fiddlerwoaroof: you could add a new segment type to SBCL for example
lmy9900_ has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
The issue I have with something like that is that then the thing I'm talking about is implementation specific
<p_l>
Unfortunately most unix systems don't support resource forks so certain things I'd like to see for keeping such db write-able require splitting file on write
<fiddlerwoaroof>
Yeah, my inclination would be something like the program would check if the executable is writable on start up and, if not, it would dump itself somewhere writable and restart itself
<p_l>
beach: BTW, have you used recent Smalltalk, specifically Pharo?
<beach>
Nope, sorry.
<p_l>
They have some nice Quality-of-Life stuff for supporting living with images, specifically the Pharo Launcher
<fiddlerwoaroof>
And then, the next time you run it, it would find the writable version and delegate to that.
<beach>
p_l: I see.
<fiddlerwoaroof>
yeah, the Pharo environment is really compelling
<p_l>
It handles managing images and associated VM runtime
<fiddlerwoaroof>
I was just demonstrating (badly) some of the features to a co-worker
fikka has joined #lisp
<p_l>
Then there's of course their integration with otherwise textual version control systems
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 246 seconds]
<fiddlerwoaroof>
I get the impression that, as a rule, Pharo uses Monticello and Metacello for vcs
<p_l>
fiddlerwoaroof: it does, but these days they integrate with Git
lmy9900__ has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
lmy9900_ has quit [Ping timeout: 250 seconds]
JohnMS_WORK has joined #lisp
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9900 has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
Is there any way to compile a string using exactly the same logic that would apply as if you wrote the string to a file and compiled the file?
lmy9900 has joined #lisp
shrdlu68 has joined #lisp
<p_l>
fiddlerwoaroof: (CL:COMPILE (CL:EVAL (CL:READ-FROM-STRING ...))) ; something like that?
lmy9900_ has joined #lisp
<fiddlerwoaroof>
In theory, but I don't think that handles EVAL-WHEN correctly
<fiddlerwoaroof>
The _other_ idea I had would be to check a git repository out into memory and then change ASDF to know how to load a system from something like a hash-table of filename -> contents
<fiddlerwoaroof>
But, the standard specifies file compilation to have specific behavior for toplevel forms that, afaict, COMPILE doesn't enforce
lmy9900 has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
robdog has joined #lisp
<pillton>
p_l: Have you seen ipfs.io?
lmy9900_ has quit [Ping timeout: 246 seconds]
<p_l>
Only in passing
fikka has joined #lisp
space_otter has quit [Remote host closed the connection]
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
edgar-rft has joined #lisp
varjag has joined #lisp
lmy9900_ has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 268 seconds]
robdog has quit [Ping timeout: 252 seconds]
elfmacs has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
lmy9900__ has joined #lisp
fikka has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
lmy9900_ has quit [Ping timeout: 250 seconds]
shka_ has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
<flip214>
ITERATE's FINDING doesn't seem to return multiple values... or am I doing something wrong?
<flip214>
(FINDING (VALUES a b c) SUCH-THAT (< x y))
<p_l>
I wonder if a single-level-store lisp would be sensible PhD research...
fikka has joined #lisp
elfmacs has joined #lisp
<beach>
It depends on the university system you are in.
<beach>
Here, it would not be possible.
lmy9900 has quit [Ping timeout: 244 seconds]
<beach>
Graduates with a masters degree don't know much about programming language implementation. Plus, our system imposes a 3-year limit for a PhD. There would not be enough time for the student to learn enough about Lisp, programming language implementation, compilation, etc. in 3 years, let alone to write the journal papers that would be required for that student to get a job afterwards.
<beach>
... which is why I quit taking on PhD students more than a decade ago.
orivej has joined #lisp
lmy9900__ has joined #lisp
varjag has quit [Ping timeout: 272 seconds]
<p_l>
Well, I'm thinking of doing PhD while otherwise continuing my job
<beach>
That might work where you are.
<beach>
If so, yes, I think it's a great idea.
vlatkoB has joined #lisp
<p_l>
And I have some time since my masters O:-)
<beach>
I see, yes. :)
<p_l>
beach: unfortunately, not in Poland
fikka has quit [Ping timeout: 268 seconds]
lmy9900_ has quit [Ping timeout: 268 seconds]
<beach>
Sorry to hear that.
<p_l>
UK's Open University would have been the best from places I so far checked, but Brexit
angavrilov has joined #lisp
<beach>
Ouch, yes.
<beach>
Try Scandinavia maybe.
lmy9900_ has joined #lisp
<p_l>
My criteria were the ability to do the PhD without joining on-site as normal full time student, and freedom in choice of topics
<beach>
That might be hard to accomplish.
lmy9900__ has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
troydm has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
lmy9900__ has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
dacoda has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy9900_ has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<p_l>
beach: in Poland, it's theoretically doable but you have to get through administrative opposition and essentially have a promotor willing to tackle it
lmy9900_ has quit [Ping timeout: 246 seconds]
lmy9900_ has joined #lisp
lmy9900 has joined #lisp
robdog has joined #lisp
lmy9900__ has joined #lisp
lmy9900_ has quit [Ping timeout: 250 seconds]
lmy9900 has quit [Ping timeout: 245 seconds]
slac-in-the-box has joined #lisp
lmy9900 has joined #lisp
shrdlu68 has quit [Ping timeout: 268 seconds]
lmy9900__ has quit [Ping timeout: 246 seconds]
lmy9900_ has joined #lisp
<beach>
Yes, I see.
nirved has joined #lisp
lmy9900 has quit [Ping timeout: 240 seconds]
<beach>
p_l: What is your reason for wanting a PhD? Better career opportunities?
robdog has quit [Ping timeout: 252 seconds]
<p_l>
some of it is personal ambition and growth. Frankly speaking what I do for a living tends to have people without degrees often
robdog has joined #lisp
<beach>
Yes, I imagine. Hence my question.
lmy9900__ has joined #lisp
jochens has joined #lisp
<p_l>
beach: PhD does, however, enable a tiny bit easier emergency migration freedom
<p_l>
though thanks to "West" tending towards BSc instead of Master's as first degree I already have quite a bit of advantage there
<jackdaniel>
nb: sbcl implements this cleanup proposal
lmy9900_ has joined #lisp
<loke`>
jackdaniel: Interesting
<loke`>
jackdaniel: In Maxima, maxima symbols are mapped to Lisp symbols by prefixing them with $ and using “invert” readtable-case
knicklux has quit [Read error: Connection reset by peer]
<jackdaniel>
heh, I need to take my time some day to study maxima (at least from the user perspective)
<loke`>
In Climaxima, to be able to display Maxima symbols properly, I simply install a readtable with readtable-case set to :INVERT. That fixes everything, but if I read your summary properly, that's just because I'm using SBCL, and different behaviour could be seen on other CL's?
lmy9900__ has quit [Ping timeout: 268 seconds]
<jackdaniel>
only interaction I had with it was fixing bugs discovered by maxima developers (they are very helpful and provide detailed test results before each release!)
nopf has joined #lisp
<jackdaniel>
loke`: this issue is about printing, not about reading
<loke`>
jackdaniel: Right, but when I have the readtable installed, it also affects printing. At least on SBCL.
<jackdaniel>
reader produces the same (conforming) results on both implementations
<jackdaniel>
yes, *print-case* is underspecified with this regard
<jackdaniel>
so conforming program can't depend on that
ebrasca has quit [Read error: Connection reset by peer]
<loke`>
jackdaniel: OK. So is there any way I can ensure better compatibility with all CL's? What if I set *print-case* to :INVERT as well, will that fix it?
troydm has joined #lisp
lmy9900__ has joined #lisp
<jackdaniel>
loke`: no, because *print-case* is specified as if only :upcase was a current readtable-case
<loke`>
To me it's more than a curiousity. I seem toi have actually found myself in this territory. :-)
<jackdaniel>
from another practical perspective: print-case as it is specified doesn't play nice if programmer wants to work with so-called "modern" syntax (name taken from allegro and adopted in named-readtables), that is with preserved case
<jackdaniel>
it just gets in a way with all these vertical bars (but it doesn't sting *that* much)
lmy9900__ has quit [Ping timeout: 268 seconds]
kajo has quit [Ping timeout: 252 seconds]
dmiles has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
<jackdaniel>
either way: someone eager to help with ECL may take this issue and implement the cleanup issue :-)
<jackdaniel>
s/cleanup issue/cleanup proposal/
lmy9900_ has quit [Ping timeout: 246 seconds]
lmy9900_ has joined #lisp
lmy9900 has quit [Ping timeout: 250 seconds]
lmy990___ has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
Necktwi has quit [Quit: leaving]
heisig has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
lmy990___ has quit [Ping timeout: 250 seconds]
lmy9900__ has joined #lisp
Elephant454 has quit [Quit: ERC (IRC client for Emacs 26.1)]
<beach>
flip214: It is iffy to alter the specification since it was written by other people.
<beach>
The CLIM specification I mean.
<beach>
I guess editorial changes like fixing typos would be OK.
lmy9900 has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
lmy9900_ has joined #lisp
lmy9900__ has quit [Ping timeout: 268 seconds]
lmy990___ has joined #lisp
dmiles has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
anewuser has joined #lisp
Necktwi has joined #lisp
lmy9900 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
lmy990___ has quit [Ping timeout: 250 seconds]
<shka__>
beach: if you are only implementation you can create new speficifaction
<shka__>
based on the old
<shka__>
if license permits this
<shka__>
obviously
<beach>
Well, there is no license, so technically, we can't do anything with it.
jcowan has quit [Quit: Connection closed for inactivity]
<beach>
We just have the oral promise by Scott McKay that it's OK to use it.
lmy9900_ has joined #lisp
<beach>
Independently of that, it is illegal to claim that the authors mentioned on the specification wrote something that was actually written by someone else (i.e. flip214, me, etc).
<jackdaniel>
afair he said, that we may do what we want with it, adding appropriate annotation would address potential authorship dillemas
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 246 seconds]
<beach>
That would be the minimum requirement, yes.
robdog has joined #lisp
<jackdaniel>
while I don't have any plans to modify clim spec now I don't think we should treat it as set in stone for our project purposes. we would need to: provide information who created it and how to access original document and not claim it being CLIM II (we could call it CLIM 2.42 ;-)
varjag has joined #lisp
hhdave has joined #lisp
<beach>
That's a good plan.
lmy9900_ has quit [Ping timeout: 268 seconds]
<jackdaniel>
do you mean, that a good plan is "not having any plans to modify clim spec", or the other part? ;-)
hhdave_ has joined #lisp
lmy9900 has joined #lisp
<beach>
I think we ultimately need some document describing what McCLIM does and that would have to be independent of the current specification, though it would naturally include much of the original material.
hhdave has quit [Ping timeout: 246 seconds]
hhdave_ is now known as hhdave
robotoad has quit [Quit: robotoad]
fikka has quit [Ping timeout: 246 seconds]
lmy9900__ has quit [Ping timeout: 250 seconds]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
cpape has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
yvy has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
lmy9900 has quit [Ping timeout: 250 seconds]
dacoda has quit [Ping timeout: 268 seconds]
<jackdaniel>
or to preserve roman notation, we could call it CLIM II ⁙ Э ; where ⁙ Э is qvincvnx & scripvlvm meaning 0.42 ;-)
fikka has joined #lisp
shifty has quit [Ping timeout: 268 seconds]
Necktwi has quit [Quit: leaving]
Necktwi has joined #lisp
robdog has joined #lisp
lmy9900 has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<shka__>
SPQRCLIM
lmy9900 has quit [Ping timeout: 244 seconds]
lmy9900 has joined #lisp
fikka has joined #lisp
lmy99____ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
meepdeew has quit [Remote host closed the connection]
lmy9900 has quit [Ping timeout: 250 seconds]
<elderK>
Can anyone recommend a project to look at that has unit tests using fiveam?
<jackdaniel>
elderK: bordeaux-threads
fikka has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
<jackdaniel>
around 300 linies of tests afair, that should be easy to look at
<scymtym>
eclector's tests are probably not super easy to digest, but they demonstrate advanced facilities such as fiveam's random testing
lmy9900_ has quit [Ping timeout: 268 seconds]
lmy9900__ has joined #lisp
lmy9900 has quit [Ping timeout: 250 seconds]
<jackdaniel>
I find fixture abstraction in fiveam appaling (with usage of &body and all that)
fikka has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
lmy9900__ has quit [Ping timeout: 246 seconds]
galdor has quit [Quit: WeeChat 2.2]
lmy9900_ has joined #lisp
fikka has joined #lisp
zch has joined #lisp
iAmDecim has quit [Ping timeout: 252 seconds]
galdor has joined #lisp
lmy9900 has joined #lisp
zch has quit [Client Quit]
zch has joined #lisp
dddddd has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
Necktwi has quit [Quit: leaving]
lmy9900 has quit [Ping timeout: 268 seconds]
Necktwi has joined #lisp
lmy9900 has joined #lisp
lmy9900_ has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
lmy9900 has quit [Ping timeout: 268 seconds]
elfmacs has quit [Ping timeout: 252 seconds]
lmy9900_ has joined #lisp
<elderK>
scymtym: Thanks :)
Lycurgus has joined #lisp
lmy9900 has joined #lisp
<loke`>
Anyone with ASDF expertise? I need to figure out a way to evaluate an arbitrary Lisp form when a system is loaded. Is there something I can put in the DEFSYSTEM form to do this?
lmy9900_ has quit [Ping timeout: 250 seconds]
<flip214>
beach: sorry. I didn't want to step on your toes; I just propose a few small changes, mostly typos.
<beach>
I think we can handle those.
<beach>
I am just saying we should be careful since we are not in control of that document.
lmy9900_ has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<flip214>
oh, so it's more of a licensing issue rather than a politeness issue? ack, I was afraid that jumping in with changes might be considered rude.
<beach>
Not at all.
<varjag>
jackdaniel: it's practical at least
<varjag>
just changed a few tests to fixtures
lmy9900 has quit [Ping timeout: 250 seconds]
<beach>
flip214: The fact is that there is no license. Absent a license, we have the right to do absolutely nothing to the document. All we have is an oral statement by one of the authors that "we can do what we want with it". Now that author also claims to be essentially the only author, so he probably speaks with some authority.
lmy9900__ has joined #lisp
robdog has joined #lisp
<jackdaniel>
varjag: I'm not using fixtures (it is cleaner and easier to understand for me to create with- macros and wrap test body in it)
lmy9900_ has quit [Ping timeout: 244 seconds]
<varjag>
don't see much practical difference
<varjag>
or aesthetic for that matter
lmy9900_ has joined #lisp
<beach>
flip214: But some of the authors I believe used to work for Symbolics, and we know that Symbolics has not been very willing to release their work in the past.
lmy990___ has joined #lisp
<beach>
flip214: Also, I don't know who Scott McKay worked for when he wrote that document. Perhaps his employer can claim that he can not give away a document that belongs to them.
<jackdaniel>
beach: if that were the case we should remove the document instead of distributing it
Lycurgus has quit [Quit: Exeunt]
scymtym has quit [Ping timeout: 245 seconds]
<beach>
I don't think we take any risk in keeping the document in the distribution.
<beach>
In the worst case, they will ask us to remove it.
<beach>
Modifying it is a different thing altogether.
lmy9900__ has quit [Ping timeout: 246 seconds]
<jackdaniel>
if we do have copyrights we are not allowed to copy the document (and distribute it); if we do have such rights (i.e by verbal agreement), then we are fine with copying it (and modifying it with clear annotation)
<elderK>
ogamita: Is there a way for me to redirect this?
Necktwi has joined #lisp
<elderK>
Also, another question, one that isn't really necessary but I'd find useful: How do you "forward declare" functions? Similarly to say, writing prototypes in C?
* elderK
looks in CLHS
<jackdaniel>
check out declaim and proclaim
<elderK>
Thank you
makomo has joined #lisp
gypsydave5 has quit [Ping timeout: 250 seconds]
steiner has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
kajo has quit [Ping timeout: 246 seconds]
robdog has quit [Remote host closed the connection]
robdog has joined #lisp
kajo has joined #lisp
frodef has joined #lisp
kajo has quit [Ping timeout: 268 seconds]
thinkpad has quit [Ping timeout: 246 seconds]
thinkpad has joined #lisp
fikka has joined #lisp
dddddd has quit [Quit: Hasta otra..]
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
fikka has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
phlm has joined #lisp
jmercouris has joined #lisp
jochens has joined #lisp
phlm has quit [Remote host closed the connection]
Lycurgus has joined #lisp
lmy9900 has joined #lisp
ebrasca has joined #lisp
jcowan has joined #lisp
nikos has joined #lisp
nikos is now known as Guest46771
nikal has quit [Ping timeout: 250 seconds]
<ogamita>
elderK: this asdf:output-file is a function. It returns a result: the pathname! You don't redirect it, you use it!
<ogamita>
elderK: for example, you can rename the file, or copy it, etc.
<jmercouris>
how to send a kill -9 to a program running on a bt thread?
<jmercouris>
I've done something like this (bt:make-thread (lambda () (uiop:run-program path)))
<jmercouris>
and I want to kill the program running by uiop:run-program, but it is a synchronous call, it doesn't return me a PID or anything
<shka__>
jmercouris: and what if you kill thread?
<jmercouris>
if I kill the thread, it keeps running somehow
<shka__>
ok
<Xach>
sbcl's run-program provides a lot more good info about subprocesses.
<shka__>
jmercouris: what about using launch-program instead?
<jmercouris>
shka__: what's the difference between the two?
<shka__>
launch-program is supposed to be async
<shka__>
and returns object that can be used to pull out pid
<jmercouris>
I see and it returns a process info object
<ogamita>
m
<jmercouris>
great
<jmercouris>
perfect!
<shka__>
not sure how portable it is
<jmercouris>
yes, I think I will play around with that
<jmercouris>
well, it is part of uiop... so
<shka__>
uiop can have some nasty surprises ;-)
Guest46771 has quit [Ping timeout: 268 seconds]
<ogamita>
Now, once you fork a program, you should know the PID. The problem is that you call uiop:run-program in synchronous mode. Just call it with :wait nil and wait on it after having stored the pid somewhere.
nikos_ has joined #lisp
<jmercouris>
ogamita: I don't see :wait as a keyword arg for run-program
<jackdaniel>
sb-ext:run-program has wait, uiop's run-program doesn't. uiop:launch-program is meant for that, but uiop's stuff is a mess
<jmercouris>
maybe we have different versions of uiop
<jackdaniel>
use whatever implementation provides you or use external-program
nikal has quit [Ping timeout: 240 seconds]
<ogamita>
jmercouris: it's hidden.
<ogamita>
and you can use uiop:wait-process once you got the pid.
<jmercouris>
ogamita: and why might I do that over just using launch-program?
<ogamita>
because there's also ext:run-program, sb-ext:run-program, etc, with basically the same API, while launch-program is specific to uiop.
<ogamita>
Is launch-program a public API of uiop?
<jmercouris>
ogamita: seems so
<jackdaniel>
ogamita: yes it is
<jmercouris>
no double ::
ebrasca has quit [Read error: Connection reset by peer]
<jackdaniel>
and uiop:run-program/uiop:launch-program has an abstraction-creep between call and the implementation run-program, so I can't say it is good or well mapped
ebrasca has joined #lisp
<luis>
flip214: do you have time to clean up that swank-presentation-streams fix?
<jmercouris>
so I have an object
<jmercouris>
is there a way I can get it to print its accessors?
<jackdaniel>
inspect this object
<jmercouris>
right, how can I do that?
<jmercouris>
oh I see
<jmercouris>
INSPECT
thinkpad has quit [Ping timeout: 268 seconds]
<jmercouris>
man, I wish I had known that many months ago, thank you jackdaniel
<jmercouris>
how can I exist INSPECT mode in slime?
<jackdaniel>
exit? press q
<jmercouris>
okay, so great, I can get the PID
<jmercouris>
which is awesome
<jmercouris>
so now I need to send it a friendly kill signal
<jmercouris>
I just can't remember what number that is
<jcowan>
beach: Unless you have a *really* comprehensive undo facility, or never mutate anything, or never make misteaks, you are going to need to refresh to a known-good state some of the time.
<jcowan>
fiddlerwoaroof: That was an interesting post. One way around the problem that I see (since she is designing gfs for Racket from scratch) is to have add-method return a new gf object which can then be exported with the module. No modifying global state, no problem.
<jackdaniel>
we have already estabilished that this is a remote session
<jackdaniel>
so "v" shortcut won't work
<jackdaniel>
he asks about how to determine line number in a file of said error
meepdeew has quit [Ping timeout: 272 seconds]
<shka__>
yeah it won't be details show line number
<akr>
so there's no way to find out? :/
<jackdaniel>
give me a few minutes
<akr>
sure thing
<shka__>
akr: hm, i was wrong, it will not display file number
<flip214>
akr: slimv is an integration of swank to vim8/neovim
<akr>
flip214: yeah, that makes sense now. I was confused for a bit there
<loke`>
spacemacs is a bit of a mess. I'd recommend starting with plain Emacs and add customisations yourself once you feel comfortable with it.
robdog has joined #lisp
<akr>
loke`: I've been using it for about 2 years now and I can't complain too much. It is a bit rough around the edges in some places, but overall it's quite usable
lumm has joined #lisp
fikka has joined #lisp
<akr>
it doesn't play nice with some modes like , yeah. for example slime
<akr>
as vim keybindings don't work there
<jackdaniel>
akr: there is somewhat inconvenient way to do that
<sjl_>
slimv isn't the one that requires vim8/neovim -- that's vlime. slimv works with older versions (unless he changed it recently)
<jackdaniel>
go with cursor over the frame
dddddd has joined #lisp
<jackdaniel>
or even don't
<jackdaniel>
press ":"
<jackdaniel>
and type (swank:frame-source-location 0) ; 0 is a frame number
<jackdaniel>
it should tell you the file position (in characters)
robdog has quit [Ping timeout: 268 seconds]
<jackdaniel>
I'm afraid you will have to count lines by yourself or simply go at the position
<jackdaniel>
well, that was interesting grok (will be useful to me as well)
<jackdaniel>
akr: you may consider setting tramp pathname translations (slime works with that just fine)
<akr>
jackdaniel: hmm, it seems to point me to where sb-int:simple-eval-in-lexenv is implemented
<akr>
no where the error was
<akr>
the error is somewhere in a 500 line function
<jackdaniel>
you have various frames
<akr>
ah okay, frame is not what I thought it was
heisig has quit [Quit: Leaving]
<akr>
no wait, it is, I just didn't expand the backtrace
jkordani_ has quit [Quit: Leaving]
<jackdaniel>
so is that useful to you or you are still confused?
Zaab1t has joined #lisp
<akr>
hmm, maybe I'm going about this the wrong way somehow, I'll describe in more detail
younder has joined #lisp
<akr>
the error is somewhere in (dbu::generate-payment-log-invoice pl) ;; the 500 line function
<akr>
but it does DB modification which I don't want to do in production
<akr>
so I execute this in the repl: (pomo:with-transaction (tr) (handler-case (dbu::generate-payment-log-invoice pl) (error (x) (pomo:abort-transaction tr) (error x))))
<jackdaniel>
I suspect (I'm almost sure of it) bug is in your macro with-transaction
<jackdaniel>
that it calls (id foo) where foo's values is NIL
<jackdaniel>
since it is a macro which got expanded in your repl, there is no function in the source you could navigate to
<jackdaniel>
I have a nice name for this technique: "Chinese whispers debugging" ;-)
<akr>
hmm, I know for sure though that the inner form given as argument to with-transaction starts to execute and fails halfway through
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<akr>
plus the macro is from a fairly used (I think?) library
<akr>
the library being postmodern
<jackdaniel>
it may be caused by bad arguments passed to a macro
anamorphic has joined #lisp
<akr>
oh and I once called the offending function without the wrapping macro
<akr>
it made a mess in the DB and crashed :)
<pfdietz>
Read the 'm' in that package name as 'rn'. Keming!
Inline has quit [Read error: Connection reset by peer]
<jackdaniel>
akr: look at your invocation again
<akr>
is it because I'm rethrowing the error?
<jackdaniel>
yes, you lose the frame when you do
<jackdaniel>
you should handle that with handler-bind
Inline has joined #lisp
<jackdaniel>
which doesn't resume execution
pierpal has quit [Quit: Poof]
fikka has joined #lisp
pierpal has joined #lisp
<jackdaniel>
(then there is no need to rethrow the error)
Inline has quit [Read error: Connection reset by peer]
<akr>
okay I see, let me try
Inline has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
Inline has quit [Read error: Connection reset by peer]
quazimodo has quit [Ping timeout: 246 seconds]
frgo has quit [Remote host closed the connection]
Inline has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
frgo has joined #lisp
quazimodo has joined #lisp
Inline has quit [Read error: Connection reset by peer]
robdog has joined #lisp
shifty has joined #lisp
Inline has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<akr>
okay I got the form index, I think
<akr>
well
<akr>
is there something I can use to show me where in a file is form number 17039? :D
<jackdaniel>
form number? do you mean position?
<akr>
yeah, that
<akr>
sorry
<jackdaniel>
C-u POSITION C-f
<jackdaniel>
from the file beginning
<jackdaniel>
that should move POSITION characters forward
robotoad has joined #lisp
<akr>
hmm, it got emacs deadlocked it seems :D
<jackdaniel>
maybe there are other ways
<jackdaniel>
that's what came to my mind though
<ogamita>
M-x goto-char works from anywhere.
<jackdaniel>
and going this many positions forward took me less than a second
<jackdaniel>
o, thank you
robdog has quit [Ping timeout: 264 seconds]
<ogamita>
C-h w goto-char RET to see the bindings.
<akr>
oh, it just goes to the definition of the function
<akr>
not where the error occured
<akr>
hmm
<akr>
I must've grabbed the wrong frame
<akr>
ogamita: thanks though
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has joined #lisp
nika has joined #lisp
<akr>
so here is my current invocation: (pomo:with-transaction (tr) (handler-bind ((error #'lambda (x) (pomo:abort-transaction tr))) (dbu::generate-payment-log-invoice pl)))
<akr>
unfortunately I still get no information, like in my last screenshot
<beach>
#'lambda looks wrong.
nikos_ has quit [Ping timeout: 246 seconds]
<akr>
oh yes, my bad
robdog has joined #lisp
Inline has quit [Read error: Connection reset by peer]
gilez has joined #lisp
<akr>
hmm, none of the frames are helpful anyway, though
<akr>
2 points to the definition of the crashing function, not where the error takes place
Inline has quit [Read error: Connection reset by peer]
<fortitude>
akr: v will take you to a specific line, but generally only if the function was compiled with debug info
FreeBirdLjj has joined #lisp
nikal has joined #lisp
<fortitude>
akr: which is C-u C-c C-c in slime, if I'm translating muscle memory right
<akr>
hmm okay so frame 2 should point me to the specific line?
<pfdietz>
BTW, this is one reason why you don't want to write 500 line functions.
<akr>
yeah :(
<akr>
to be fair, I didn't
<sjl_>
any time I write a >15 line function (not counting flet/labels) in CL I get twitchy
<pfdietz>
Why "one" doesn't want to write. ;)
nika has quit [Ping timeout: 240 seconds]
<pfdietz>
Another reason is tracing.
robdog has quit [Ping timeout: 268 seconds]
elderK has quit [Ping timeout: 268 seconds]
<fortitude>
akr: it should, frame 2 looks like your function, so if generate-payment-log-invoice was compiled with debug info it should take you to the line in question
<fortitude>
unfortunately that's the line as it was when the function was compiled, so if you change source a lot it can be wrong
<akr>
sorry, emacs question: how can I invoke the compilation through M-x with debug info?
nikal has quit [Ping timeout: 240 seconds]
<Xach>
akr: there are a few ways.
<Xach>
akr: for individual functions, you can use C-u C-c C-c. for files, C-u C-c C-k
<Xach>
akr: in various popups and other modes you can use C-u C-c C-c also. like in the debugger on individual frames.
<Xach>
and also in xref i believe.
vlatkoB has quit [Remote host closed the connection]
rozenglass has joined #lisp
<akr>
Xach: I get that, but C-u doesn't work in evil
<akr>
so I was wondering how to input the prefix to the invocation M-x slime-compile-defu
vlatkoB has joined #lisp
<akr>
(which is what I can do… sigh)
<Xach>
Oh. Hmm.
<Xach>
I don't know, sorry.
<akr>
ah okay I got it
<akr>
C-u is SPC u in spacemacs
<akr>
ah, got it!
slyrus1 has joined #lisp
<akr>
jackdaniel, ogamita, fortitude, Xach: thank you everyone :)
fikka has quit [Ping timeout: 246 seconds]
<akr>
hmm so even though I'm connected to a remote slime instance, once a function is compiled with debug info, `v` points to the local file
<akr>
that makes sense and it's also nice
<akr>
and I also see all the local bindings in the function with `t`, that's great
quazimodo has quit [Ping timeout: 240 seconds]
<akr>
perhaps I shall become friends with this arcane language after all
<luis>
flip214: left a comment on the commit. I say go for a pull request and mention issue #213
cage_ has joined #lisp
quazimodo has joined #lisp
<luis>
flip214: a slight (but separate) improvement to the whole thing would be to have the contrib warn about being loaded in non-dedicated stream mode
cage_ has quit [Client Quit]
<jasom>
C-u should work in evil-input-mode; not sure if it works in evil-normal-mode by default (I've bound a few useful-for-lisp keys in normal mode like M-. in my own settings)
buffergn0me has quit [Remote host closed the connection]
lumm has joined #lisp
[X-Scale] has joined #lisp
Inline has joined #lisp
marvin2 has quit [Ping timeout: 268 seconds]
buffergn0me has joined #lisp
X-Scale has quit [Ping timeout: 246 seconds]
nikal has joined #lisp
[X-Scale] is now known as X-Scale
robdog has joined #lisp
lumm has quit [Client Quit]
fikka has quit [Ping timeout: 250 seconds]
lumm has joined #lisp
fikka has joined #lisp
Inline has quit [Read error: Connection reset by peer]
mindCrime has joined #lisp
Inline has joined #lisp
cage_ has joined #lisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
nikal has quit [Quit: Konversation terminated!]
fikka has quit [Ping timeout: 250 seconds]
nika has joined #lisp
fikka has joined #lisp
capisce has left #lisp [#lisp]
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
frodef has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
shka_ has joined #lisp
anewuser has quit [Read error: Connection reset by peer]
nikka has joined #lisp
varjag has joined #lisp
nika has quit [Ping timeout: 250 seconds]
Bike has joined #lisp
nikka has quit [Ping timeout: 250 seconds]
nikka has joined #lisp
Jesin has joined #lisp
fikka has joined #lisp
buffergn0me has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 250 seconds]
anamorphic has quit [Quit: anamorphic]
wusticality has joined #lisp
PutYourLegOnDesk has joined #lisp
<PutYourLegOnDesk>
Which book would you suggest for learning CL as an experienced programmer? I tried reading Land of Lisp but it got too dry and I couldn't get past page 90
<beach>
minion: Please tell PutYourLegOnDesk about PCL.
<minion>
PutYourLegOnDesk: please see 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).
<PutYourLegOnDesk>
beach: Is it the best one around?
<beach>
This is the one most people recommend for experienced programmers.
<beach>
You could also try PAIP.
<beach>
minion: Please tell PutYourLegOnDesk about PAIP.
<minion>
PutYourLegOnDesk: PAIP: Paradigms of Artificial Intelligence Programming
hhdave has quit [Ping timeout: 250 seconds]
<PutYourLegOnDesk>
It's just that Apress had some bad QA in some of their books
<beach>
Contrary to what the title suggests, it is not about AI.
<PutYourLegOnDesk>
I'll start with the PCL, thanks
<beach>
Good luck.
<pjb>
PutYourLegOnDesk: PAIP, yes.
<beach>
Both those books are now available as PDFs online, I think.
<jackdaniel>
it also has prebuilt versions (pdf, epub etc)
<PutYourLegOnDesk>
Thanks
<jackdaniel>
who should I bother to update minion information for PAIP?
<beach>
jackdaniel: You do it yourself.
<jackdaniel>
minion: who is your master?
<minion>
chandler is my master
<beach>
minion: help
<minion>
There are multiple help modules. Try ``/msg minion help kind'', where kind is one of: "lookups", "helping others", "adding terms", "aliasing terms", "forgetting", "memos", "avoiding memos", "nicknames", "goodies", "eliza", "advice", "apropos", "acronyms".
<beach>
minion: help adding terms
<minion>
To add a term, say something like ``minion: add "term" as: the definition''. I will remember the definition.
<PutYourLegOnDesk>
Is Graham's ANSI Common Lisp any good or up-to-date?
graphene has quit [Remote host closed the connection]
<beach>
PutYourLegOnDesk: It's OK, but his style is a bit off.
<beach>
PCL is more up to date.
<jackdaniel>
minion: add "PAIP" as: PAIP: Paradigms of Artificial Intelligence Programming. More Common Lisp than AI. Now freely available at https://github.com/norvig/paip-lisp.
<minion>
OK, done.
<jackdaniel>
beach: thank you
<beach>
Anytime.
danielxvu has quit [Read error: Connection reset by peer]
robdog has quit [Remote host closed the connection]
jkordani_ has joined #lisp
graphene has joined #lisp
<jackdaniel>
PutYourLegOnDesk: ANSI CL by Paul Graham has very good excercises and explanations
<jackdaniel>
minion: tell jackdaniel about PAIP.
<minion>
jackdaniel: PAIP: PAIP: Paradigms of Artificial Intelligence Programming. More Common Lisp than AI. Now freely available at https://github.com/norvig/paip-lisp
<jackdaniel>
minion: add "PAIP" as: Paradigms of Artificial Intelligence Programming. More Common Lisp than AI. Now freely available at https://github.com/norvig/paip-lisp.
<minion>
OK, done.
nanoz has joined #lisp
anamorphic has joined #lisp
jkordani has quit [Ping timeout: 268 seconds]
groovy2shoes has quit [Quit: moritura te salutat]
fikka has quit [Ping timeout: 246 seconds]
nika has joined #lisp
PutYourLegOnDesk has quit [Read error: Connection reset by peer]
nikka has quit [Ping timeout: 250 seconds]
<pfdietz>
I need to pull my lisp books together.
<jackdaniel>
minion: add "PAIP" as: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp.
<minion>
OK, done.
kyby64 has joined #lisp
fikka has joined #lisp
marvin2 has joined #lisp
nikka has joined #lisp
nika has quit [Ping timeout: 246 seconds]
milanj has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
nikka has quit [Ping timeout: 246 seconds]
nanoz has quit [Ping timeout: 245 seconds]
igemnace has joined #lisp
gypsydave5 has quit [Ping timeout: 246 seconds]
Essadon has joined #lisp
robdog has joined #lisp
warweasle has quit [Quit: stupid meeting...but the day will go faster.]
makomo has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
robdog has quit [Ping timeout: 252 seconds]
slac-in-the-box has joined #lisp
fikka has joined #lisp
wusticality has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 250 seconds]
jkordani has joined #lisp
<sjl_>
jackdaniel: maybe don't include the period at the end there, otherwise it might get included as part of a link by some clients.
shifty has quit [Ping timeout: 250 seconds]
jkordani_ has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 246 seconds]
Jesin has quit [Quit: Leaving]
Kaisyu has quit [Quit: Connection closed for inactivity]
Lycurgus has quit [Quit: Exeunt]
Jesin has joined #lisp
fikka has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
jochens has quit [Remote host closed the connection]
anamorphic has quit [Quit: anamorphic]
fikka has quit [Ping timeout: 246 seconds]
jochens has joined #lisp
fikka has joined #lisp
nullheroes has joined #lisp
rozenglass has quit [Remote host closed the connection]
jochens has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
slac-in-the-box has quit [Ping timeout: 250 seconds]
<ebrasca>
minion: add "PAIP" as: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp .
<minion>
OK, done.
nikka has joined #lisp
dacoda has joined #lisp
vlatkoB has quit [Remote host closed the connection]
CrazyEddy has quit [Remote host closed the connection]
anamorphic has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
kajo has quit [Ping timeout: 252 seconds]
razzy has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
buffergn0me has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
CrazyEddy has joined #lisp
anamorphic has quit [Quit: anamorphic]
terpri has quit [Ping timeout: 264 seconds]
meepdeew has joined #lisp
angavrilov has quit [Remote host closed the connection]
kajo has joined #lisp
grumblefumb has quit [Remote host closed the connection]
anamorphic has joined #lisp
mejja has joined #lisp
Mr-Potter has joined #lisp
buffergn0me has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
jkordani_ has joined #lisp
akr has left #lisp ["WeeChat 2.2"]
robdog has quit [Remote host closed the connection]
jkordani has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
nicksmaddog has quit [Ping timeout: 268 seconds]
slac-in-the-box has joined #lisp
slac-in-the-box has quit [Client Quit]
wglb has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
cage_ has quit [Remote host closed the connection]
Zaab1t has quit [Quit: bye bye friends]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
skeuomorf has joined #lisp
nika has joined #lisp
<wglb>
I am using dexador https://github.com/fukamachi/dexador to read web pages from many different sites in the same session. If it runs long enough (accessing many different sites) the process dies with "too many open files". This is verified by running lsof against the process as it progresses. dex:get returns, among other things, a stream associated with the socket. I issue a close on that socket when it returns, but this does not
<wglb>
appear to actually close the socket and assocaited fd. Any words of experience here would be appreciated.
milanj has joined #lisp
<jkordani_>
I know this isn't ideal, but you could try upping the ulimit for open files
nikka has quit [Ping timeout: 268 seconds]
<pjb>
It would be a good idea to forget it too, so it can be garbage collected.
<jkordani_>
you'd still prefer for releasing the os resources to happen when or shortly after you ask it to happen as opposed to the next time the gc runs
<wglb>
No, would like this to be constantly running.
<fortitude>
wglb: what state does lsof show the sockets in?
<wglb>
Well, if calling close doesn't actually close it, I don't think it will get garbage collected.
<jkordani_>
wgbl: you may still find that raising the ulimit for open files will be necessary, even once you get file closing to happen successfully
robdog has quit [Ping timeout: 252 seconds]
<wglb>
fortitude: Shows ESTABLISHED
<wglb>
jkordani_: why would that be?
<jkordani_>
wgl: do you issue a close on the socket, or the stream? oh, because the "burst rate" of open file handles for whatever it is your doing may still be higher than the ulmit imposed default, even after you are confident that you are closing file handles properly
<dlowe>
wglb: use :use-connection-pool nil in your dex:get call
<jkordani_>
its a suggestion, only you know your program's characteristics
<dlowe>
wglb: and/or :keep-alive nil
<wglb>
dlowe: Makes sense--will try that. Both default to t
<jkordani_>
this is naive of me, but wouldn't you want a connection pool?
<dlowe>
only if you're hitting the same sites
<jkordani_>
hmm I guess I don't understand what that is used for
<dlowe>
hm. there's two interpretations of connection pool, I guess. But you can make multiple requests on a single http connection, so if you're hitting the same site multiple times, it makes sense to keep the line open
<dlowe>
it could also mean that it just keeps the connection data structures around to avoid reallocation
confusedwanderer has quit [Quit: confusedwanderer]
quazimodo has quit [Ping timeout: 244 seconds]
<wglb>
jkordani_: Hitting different sites with each query, and not likely to come back to the same one.
buffergn0me has joined #lisp
Jesin has quit [Quit: Leaving]
zch has quit [Quit: Leaving]
robdog has joined #lisp
myrkraverk has quit [Ping timeout: 252 seconds]
skeuomorf has left #lisp ["Killed buffer"]
Mr-Potter_ has joined #lisp
Mr-Potter has quit [Ping timeout: 250 seconds]
rozenglass has joined #lisp
myrkraverk has joined #lisp
wusticality has joined #lisp
hiroaki has quit [Ping timeout: 246 seconds]
anamorphic has quit [Quit: anamorphic]
sz0 has joined #lisp
anamorphic has joined #lisp
scottj has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
wusticality has quit [Ping timeout: 268 seconds]
graphene has quit [Remote host closed the connection]
myrkraverk has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
frodef has joined #lisp
nikka has joined #lisp
wusticality has joined #lisp
iAmDecim has joined #lisp
nika has quit [Ping timeout: 246 seconds]
wusticality has quit [Ping timeout: 252 seconds]
zch has joined #lisp
shka_ has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 268 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
dacoda has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
robdog has quit [Ping timeout: 252 seconds]
wusticality has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
Roy_Fokker has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
jkordani has joined #lisp
anamorphic has quit [Quit: anamorphic]
debsan has quit [Ping timeout: 268 seconds]
jkordani_ has quit [Ping timeout: 246 seconds]
anamorphic has joined #lisp
debsan has joined #lisp
nikka has quit [Quit: Konversation terminated!]
bexx has quit [Remote host closed the connection]
shifty has joined #lisp
robdog has joined #lisp
fikka has joined #lisp
Bike has quit []
fikka has quit [Ping timeout: 244 seconds]
LiamH has quit [Quit: Leaving.]
jmercouris has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<jmercouris>
beach: do you have the link to the style guide you reccommended me some time ago?
<jmercouris>
it was some PDF of sorts by some author, the only thing I can remember about the author is that they had a female name
kyby64 has quit [Ping timeout: 245 seconds]
<sjl_>
jmercouris: maybe it was the book "Lisp Style & Design" by Molly Miller and Eric Benson?
<jmercouris>
sjl_: I found it, I think, I think maybe I was mistaken about the female author, it's a Norvig conference paper: http://norvig.com/luv-slides.ps
<jmercouris>
basically I had been using if with a single conditional, and he pointed out to use when instead and linked to some article
<sjl_>
Ah, yeah that's a common one that gets linked.
<jmercouris>
it was such a long time ago I cannot recall
elderK has joined #lisp
<elderK>
Hey all
<jmercouris>
elderK: good evening
<elderK>
jmercouris: Hey! :D
<wglb>
dlowe: Thanks for pointer. seems to be working quite nicely now.
<elderK>
jmercouris: I wanted to thank you for the other day, btw. You were super helpful.
<jmercouris>
no problem!
sjl_ has quit [Ping timeout: 250 seconds]
<elderK>
Guys, is it possible to have one suite depend on another suite with fiveam?
<elderK>
I see that you can have tests relying on other tests.
anewuser has joined #lisp
lumm has quit [Quit: lumm]
<younder>
Where is beach?
<no-defun-allowed>
probably went to bed
<jmercouris>
he sleeps rather early IIRC
<jmercouris>
he is also as a consequence awake super early like 5am or something sometimes
<no-defun-allowed>
it's 00:17 in france
<jmercouris>
Yes it is
<no-defun-allowed>
also yeah he gets up 5 to 6am usually
anamorphic has quit [Quit: anamorphic]
buffergn0me has quit [Ping timeout: 260 seconds]
buffergn0me has joined #lisp
anamorphic has joined #lisp
robdog has joined #lisp
warweasle has joined #lisp
<pillton>
elderK: 5am:def-suite accepts an :in keyword parameter.
Essadon has quit [Quit: Qutting]
<elderK>
pillton: Sure. That allows me to nest a suite inside another.
<elderK>
But that isn't the same as saying "This suite must only run if this other suite passed."
<jmercouris>
elderK: why not just order them serially in the order they must pass?
<elderK>
jmercouris: That's what I'm doing as a workaround :)
<jmercouris>
I see
frodef has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
anamorphic has quit [Quit: anamorphic]
robdog has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
lmy9900 has joined #lisp
jmercouris has quit [Remote host closed the connection]