<resttime>
Bike: Asked in #sbcl about my add-vop and your answer seemed to be it. (move r x) (inst add r y) in the generator works as expected
<resttime>
r being the result register
ebrasca has quit [Remote host closed the connection]
NotThatRPG is now known as NotThatRPG_away
pmwals09_ has joined #commonlisp
HM0880 has quit [Remote host closed the connection]
<Bike>
ah, well there you go then. a little surprising it doesn't move them itself, it looks like the parent vop has stuff for indicating that
[deleted] has joined #commonlisp
HM0880 has joined #commonlisp
HM0880 has quit [Client Quit]
livoreno has quit [Ping timeout: 268 seconds]
anticomputer_ has joined #commonlisp
anticomputer has quit [Quit: quit]
<akoana>
hmm, what's happening here: https://termbin.com/71e4, with (let ((prod 1))...) I'm getting a big number, with (let ((prod 1.0))...) it works as expected, strange
<akoana>
(SBCL 2.2.4)
<akoana>
same with clisp
<hayley>
I wouldn't be surprised if you got a ratio with very large components, but the actual value is quite small.
<Bike>
yeah, that's a ratio
<Bike>
the / is hidden in the three lines of digits
<Bike>
approximately 8d118/2.6d118
<akoana>
sorry the 2n stuff is a remnant of previous experiments, here a cleaned up version + results: https://termbin.com/b9a4
<Bike>
same problem. it's a ratio. you can see the / in your output
<Bike>
...168/257...
<akoana>
ah, thanks missed the "/" lol
anticomputer_ has quit [Ping timeout: 268 seconds]
<akoana>
I did the tests with 100000 iterations in emacs before, so I gave up looking at the result :)
<Bike>
yeah, i bet
anticomputer has joined #commonlisp
<Bike>
you could try (float *) tho
<akoana>
Bike, hayley: Thank you very much - I was about losing my confidence in lisp - you have saved my soul
<Bike>
no problem
azimut_ has joined #commonlisp
azimut has quit [Ping timeout: 268 seconds]
lambdart has quit [Remote host closed the connection]
anticomputer_ has joined #commonlisp
anticomputer has quit [Ping timeout: 268 seconds]
anticomputer has joined #commonlisp
anticomputer_ has quit [Ping timeout: 268 seconds]
[deleted] has quit [Read error: Connection reset by peer]
<resttime>
Is there a reason why add-doubles seems use many(?) more lines of assembly than add-floats?
<resttime>
My thoughts were that a double-float operation would be at least as single-float, only that the instruction used for addition would be different
<hayley>
ADD-DOUBLEs has to allocate an object to store the double-float in a "boxed" form.
<hayley>
This can be avoided when the ADD-... functions are declared INLINE, and when the functions are used in another function. (Though the effect will only be visible when disassembling that other function, and not in disassembly for any ADD-... function.)
<White_Flame>
and add-floats is longer than add-fixnums because it has to tag the single-float
<White_Flame>
but can still keep it in a machine word
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
<resttime>
Ohhhhh, I'm seeing the unbox/box of doubles because of how SBCL uses pointer tagging instead of NaN boxing
<resttime>
hayley: If I understood this correctly does that mean the box/unbox is still necessary in this outer function, but only happens at the entrypoint and endpoint of the function once?
<hayley>
Right.
<resttime>
Neat alright, my intuition is getting stronger. Thanks all
<White_Flame>
you don't see the unboxing, because sbcl hides some of the arg-handling prologue
<White_Flame>
but it's just 1 instruction each, following a pointer
<White_Flame>
movsd xmm1, [rdx-7]
<White_Flame>
if you use sb-disassem:disassemble-code-component, you'll see more
<resttime>
Interesting, somewhat related is there an SBCL function for printing the real memory representation of an object? I wanna see how a double is represented in memory
<White_Flame>
(format t "~16,'0x" (sb-kernel:get-lisp-obj-address 2.0)) → 4000000000000019
<White_Flame>
of course, that's just a single (in the upper 32 bits), and will work for immediate values. It doesn't display the heap representation word layout, though
<hayley>
(sb-vm:hexdump 2.0d0)
igemnace has joined #commonlisp
<White_Flame>
neat
parjanya has quit [Remote host closed the connection]
parjanya- has quit [Remote host closed the connection]
<resttime>
Hmmm, in the case of a simple-array of double-float's, are these doubles layed out in contiguously in memory boxed or unboxed?
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
<resttime>
Oh nice and I see that (upgraded-array-element-type 'bignum) ; => T which makes sense since to me since bignum would be considered more abstraction
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
rainthree has joined #commonlisp
MajorBiscuit has joined #commonlisp
pve has joined #commonlisp
aartaka has quit [Ping timeout: 245 seconds]
aartaka has joined #commonlisp
_cymew_ has joined #commonlisp
Josh_2 has quit [Ping timeout: 268 seconds]
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
karlosz has joined #commonlisp
pranavats has joined #commonlisp
aartaka has quit [Ping timeout: 252 seconds]
aartaka has joined #commonlisp
_cymew_ has quit [Ping timeout: 245 seconds]
thuna` has joined #commonlisp
_cymew_ has joined #commonlisp
anticomputer has quit [Ping timeout: 268 seconds]
anticomputer has joined #commonlisp
shka has joined #commonlisp
karlosz has quit [Ping timeout: 252 seconds]
aartaka has quit [Ping timeout: 240 seconds]
<aeth>
in SBCL, the rule of thumb is to either inline or to box your own floats with double-float arrays (which can be 0D, 1D, 2D, ...) or structs with double-float typed slots, but you have to be careful about implicit return values because those will still cons if they leave function scope
<aeth>
Not every implementation will do the struct part. Afaik, only CLISP doesn't do (upgraded-array-element-type 'double-float) => double-float
<aeth>
By implicit return value I mean e.g. (incf (aref your-double-float-array 0)) ; returns a double-float, will still cons if that part is implicitly returned from your function
<aeth>
You can get around the function boundary issue by returning nothing (i.e. only mutate these double-float data structures), by inlining (only good for small functions like add-doubles), or by coercing to a single-float (you lose precision but maybe you only need it in the intermediate steps and not the final result)
<aeth>
(Or, you know, tolerating exactly one boxing, for the final result, because it's still much better than having lots of boxing for every operation)
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 245 seconds]
azimut has joined #commonlisp
random-nick has joined #commonlisp
aartaka has joined #commonlisp
<jcowan>
Or, of course, you could stop boxing floats at all and take the Big Leap.
<aeth>
I almost mentioned it
<jcowan>
Eradicate 32-bit thought!
<jcowan>
Embrace bit rotation!
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
irfan has quit [Quit: leaving]
pillton has quit [Remote host closed the connection]
cage has joined #commonlisp
ebrasca has joined #commonlisp
jeosol has quit [Quit: Client closed]
frgo has joined #commonlisp
<drakonis>
revised common lisp spec when?
<jackdaniel>
now
<drakonis>
wonderful
<jackdaniel>
we'll call it "jackdaniel's common lisp 2022"
<jackdaniel>
or, even better, "Cloiure"
<drakonis>
that sounds like the title of a sports game franchise
<Duuqnd>
jackdaniel: Closhure
<jackdaniel>
yes, closhure sounds better, thanks!
<jackdaniel>
we'll add cryptocurrency, http server and "fortune" program as core features
<drakonis>
ha
<drakonis>
joke aside, it would probably be nice to have a revision after so long
<drakonis>
maybe?
<jackdaniel>
standardizing networking, threads and metaobject protocol would be nice, but it is not that it would change much - we already have portability layers for these
<jackdaniel>
as of the rest - do you have anything important in mind that is left out (standard-wise)?
<drakonis>
improve generics maybe?
<jackdaniel>
improve? how?
<drakonis>
oh
<drakonis>
i mean
<drakonis>
oh, i know something left out, environments
<drakonis>
there's a number of things that were in cltl2 that didnt make into the standard
<jackdaniel>
perhaps it didn't make it there because that would make choices for implementing common lisp more limited
<drakonis>
at this point in time, i suppose it doesn't quite matter as much anymore
<jackdaniel>
either way, I wouldn't personally consider this part important enough to mandate the standard revision
<drakonis>
sure
<drakonis>
though something i find worth calling a revision for is to clean up the deprecated functions and have things be a bit more consistent
<jackdaniel>
would you deliberely break code that works for decades without a hitch? even C standard revisions aim at being backward-compatible
<drakonis>
have that live in a separate package
<drakonis>
the backwards compat changes
<drakonis>
it would only be sane to do so
<drakonis>
you have to opt into the breaking changes
<jackdaniel>
but you can do that without a new standard- just create a library that leaves the package CL as is and put your own versions in the package CL22
<drakonis>
i imagine that even if the revised spec existed, it wouldn't be a default ever
pmwals09 has joined #commonlisp
<drakonis>
that would be fine, sure.
<drakonis>
but there are no guarantees that it would be supported across implementations
<jackdaniel>
if you write it in portably common lisp, then why not?
<jackdaniel>
revising a standard (putting aside the cost; people often brought that argument), takes time and effort, so there should be a tangible reason to do so. if you may resolve some issue by creating a library using the existing standard, then why to propose a new standard?
<drakonis>
to be fair, i find the notion that having to spend money on revising the existing ansi standard to be silly
<drakonis>
the cost is dedicating people to such an endeavor
pmwals09 has quit [Ping timeout: 268 seconds]
<drakonis>
and i'm working off the assumption that the revision would inevitably bring about some changes to the language internals
<drakonis>
since it could mandate things that werent part of the original spec like tail call optimizations and lexical scoping
<jackdaniel>
it is easier to gather a group of people who know what they are doing if you allow them to secure their wellbeing (i.e in a form of a salary), that is orthogonal to dedication; and dedication alone is not a guarantee of quality
<drakonis>
ah, that too.
<drakonis>
right.
<drakonis>
money is a strong motivator.
<drakonis>
hard to be dedicated if you have to busy yourself with unrelated work
<jackdaniel>
lexical scoping is not part of the common lisp standard? what do you mean?
<kakuhen>
^
<drakonis>
it doesn't apply to everything
<drakonis>
and there are functions that do not respect that
<jackdaniel>
monsters ought to feeds on something ya know?
<drakonis>
jackdaniel: sure you can invoke letf everywhere, but you can't define functions inside the scope of another and call them without it
<drakonis>
you have to perpetually daisy chain lets for it
<jackdaniel>
I still don't understand (but I'm trying to!)
<drakonis>
i'm talking about it from the perspective of using scheme
<drakonis>
i miss that when writing CL
ebrasca has quit [Ping timeout: 245 seconds]
<jackdaniel>
I thought that we are discussing lexical scoping in common lisp; but still I don't understand what do you mean by cl not having a lexical scope under certain circumstances?
<drakonis>
i am discussing that
pmwals094 has joined #commonlisp
<drakonis>
if i invoke defun inside another function, it will create the function inside the package's namespace instead of being local to it
<jackdaniel>
well, you have flet and labels to introduce a local function binding
dlowe has quit [Remote host closed the connection]
<drakonis>
yes, but define is lexically scoped and can be invoked inside functions
<jackdaniel>
I see; well, in common lisp you have flet and labels that are lexically scoped
<drakonis>
yes.
<drakonis>
i'm aware of those
<jackdaniel>
so you do agree that common lisp has lexical scoping? I'm kind of lost here
<hayley>
"Lexical scoping isn't in Common Lisp, if you ignore the lexical scoping forms"
<drakonis>
i'm not saying it doesn't have it, i'm saying that it doesn't apply to everything
<drakonis>
basically
pmwals094 has quit [Ping timeout: 245 seconds]
<drakonis>
there are forms that work with dynamic scoping
<_death>
it's also unclear what deprecated functions drakonis is referring to, and what should be done with them
<drakonis>
set is dynamically scoped iirc
<drakonis>
its deprecated
<kakuhen>
_death: remove-if-not and friends i assume
<jackdaniel>
I have a strong impression that you know little of you are talking about, so I will detach myself from the discussion
<drakonis>
fair enough
<_death>
SET sets the value cell of the symbol
<_death>
DEFUN defines a function whose name is in the global environment.. neither have anything directly to do with "dynamic scoping"
<drakonis>
jackdaniel: i apologize for that, i still need a lot of CL experience
<drakonis>
i'll get back to work
igemnace has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 240 seconds]
<beach>
drakonis: When you say that you find the notion that having to spend money on revising the existing ansi standard to be silly, how would you go about revising it then?
<drakonis>
i had assumed it had to do with spending money to get it through the ansi approval process as opposed to spending money on people
<drakonis>
the right approach is to pay people to work on it, because they gotta live
<drakonis>
base research doesnt get done if nobody gets paid
<drakonis>
anyways, i said dumb things
<beach>
Oh, I see. You were specifically referring to ANSI. I strongly suspect that ANSI took a very small amount of money, and that the main cost was was for people to travel and eat.
<beach>
But sure, any independent standards organization would be fine.
<drakonis>
the assumption comes from whenever the topic is brought up, someone talks about the money spent on the ansi standard
<drakonis>
that it doesnt happen because there's no money for that
<beach>
I think ANSI makes money by selling copies of standards, not by creating them.
<_death>
you need to pay people (or the organizations they represent) to work on it.. standardization involves both users and implementors
<beach>
Exactly.
<beach>
And I don't think the standards organization is involved in that process at all. Neither the organization nor the cost.
<_death>
in CL's case, ARPA had the interest and the money to back it up
<_death>
maybe check out the link I gave.. too bad there's no transcript
<beach>
But perhaps the role of standards organizations is no longer needed, now that we have Digital Object Identifiers.
<Bike>
"there's no money for that" can also be a proxy for "there's insufficient interest compared to the effort required"
<pjb>
Perhaps a startup could give an official stamp on "standard" documents. With some quality criteria…
<random-nick>
personally I prefer how DEFUN works to how scheme's define works
<Bike>
yeah, i don't get why scheme's define is like that
<Bike>
it's syntactic sugar for let, but you could just write let
<Bike>
it's possible i'm just bad at it, but whenever i've set out to write a standardsy proposal for WSCL, it takes me like, half an hour minimum, usually more
<Bike>
and they've all been extremely minor things like "this description uses the wrong variable names"
lanu has quit []
<jackdaniel>
imo some of that could be alleviated with better tools; making a pull request on github is quite a hore
<jackdaniel>
chore*
<jackdaniel>
(not as much as sending patches, but still)
<drakonis>
there are tools for doing that on the cli
shka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
<jackdaniel>
I'm thinking more about collaborative editing and such, where the road from the input editor to the repository is negligible
_cymew_ has quit [Ping timeout: 245 seconds]
<drakonis>
oh, i see.
jmd_ has quit [Ping timeout: 268 seconds]
gateway2000 has quit [Quit: Leaving]
<beach>
drakonis: So I think you would need to gather representatives from the commercial Lisp vendors, from the maintainers of FLOSS Common Lisp implementations, from major users like Google, SISCOG, Ravenpack, etc., and to either convince them to spend a lot of their time for free, or find the money to pay them (or their employers) for their effort.
<beach>
If the revision is just in the spirit of WSCL, the effort might not be that great, but if you want to add new functionality, like environments, this is going to take much more time.
gateway2000 has joined #commonlisp
<Shinmera>
you not only need to pay them money, you need to do something much harder: convince them it's a good idea :)
<beach>
Absolutely.
<jackdaniel>
I'm sure some of them will be already convinced that giving them money is a good idea ,)
<Shinmera>
Of that I am personally also convinced :)
rainthree has quit [Ping timeout: 240 seconds]
rainthree has joined #commonlisp
<drakonis>
ha, yeah.
morganw has joined #commonlisp
Fade has joined #commonlisp
<Shinmera>
In other news, I've been working on a system that can generate quicklisp dists. As part of that, it also allows parsing out the information in quicklisp-projects, and thus recreating your own copy of the official quicklisp dist.
<Shinmera>
One issue is that a number of project source links have since died and are no longer accessible :(
<hexology>
lisp programmers really seem to love their omnibus "misc" packages
<drakonis>
they most certainly do
<hexology>
i guess the folk wisdom about lisp programmers working alone is rooted in truth
<hexology>
i greatly appreciate that people *publish* their omnibus packages though
* Shinmera
sweats
<Shinmera>
should I have one?
<jackdaniel>
trialloy
<drakonis>
should you?
<Shinmera>
Well, I *am* a lisp programmer
<aeth>
hexology: speaking of which, in case anyone didn't hear the news, Gitlab was planning on getting rid of free-tier repositories that were "inactive" for over a year, which almost seems maliciously targeted at Lispers given how many of them just throw together a random misc package that's more or less complete
<aeth>
Still making me reconsider gitlab.com hosting. Only one of my current repositories is "active" under Gitlab's criteria even though that one in particular depends on several others.
<hexology>
Shinmera: i've been impressed at how many "complete" packages you seem to have floating around
<hexology>
aeth: indeed, it's a shame because lisp programmers seem to have embraced gitlab as the go-to "not github" option. i guess gitlab-the-company is finding that free tier is not winning them the kinds of customers and revenue streams that they need.
<aeth>
(And, no, I won't use Github. I don't like "social coding" (i.e. issue tracker drama over nonsense; the barrier to entry is a feature, not a bug) and my hatred for Microsoft software knows no limits.)
<hexology>
personally i pay for sourcehut but not everyone wants to or is able to pay for git hosting for their little projects
<hexology>
who runs common-lisp.net? i'd be happy to put down some money every month to support community git hosting under common-lisp.net/dev
<_death>
there is a Contribute link at the top
<hexology>
i don't have the same ire for github as you aeth but monoculture always makes me nervous. again, i think this is something that lisp programmers appreciate more than others.
<aeth>
Isn't common-lisp.net self-hosted gitlab? It should experience similar issues to gitlab.com, i.e. "our stock is being punished so we need to stop being nice and start maximizing profit"
<aeth>
although maybe someone will maintain a fork of the massive spaghetti mess that is the open source gitlab distribution
<aeth>
(if gitlab messes with it)
<hexology>
i think gitlab would be suicidal to break their open source model
<hexology>
maybe they could relicense a la mongodb but actually obstructing self-hosting seems like brand suicide for sure
<hexology>
_death: thanks, i didn't see that before
<aeth>
they're a VC-funded, now IPOed, company that just switched from the "give away everything for free to maximize users and mindshare" mode to the "ruthlessly extract profit" mode, as they all do eventually (if they don't just outright shutdown after an acqui-hire)
<aeth>
which is unfortunately making me have to think about alternatives to code hosting instead of coding
<hexology>
vc funding ruins everything eh
<hexology>
there *are* alternatives like gitea, gogs, or even sourcehut
<drakonis>
vc funding ruins everything, yes.
<hexology>
fwiw i never actually liked gitlab, i thought it was a clunky and slow imitation of github, like the worst of github and bitbucket with the main advantage being "it's not github"
luna-is-here has joined #commonlisp
<drakonis>
an especially egregious example is patreon, which has an inherently sustainable business model
<drakonis>
yet it still took vc money
<aeth>
plus, if Gitlab does ruin itself, Github absolutely will ruin itself too, because "I'm going to switch to Gitlab" is pretty much the only thing keeping Github in check when it makes bad decisions
<hexology>
right, vc money turns sustainable businesses and turns them into unsustainable rent-extraction devices
<hexology>
aeth: i doubt it, github at this point i think is doing what all MS products do and becoming an enterprise staple
<drakonis>
they added tiers to patreon creators
<drakonis>
so you can give patreon more money for more creator features
<drakonis>
and made new accounts have to spend more to get those features
<aeth>
hexology: I mean, just look at what happened to Internet Explorer after Netscape failed, or, rather, what didn't happen to Internet Explorer after Netscape failed (Microsoft let it stagnate on IE6 because they could)
<hexology>
yeah but IE wasn't a business product
<Shinmera>
Can we get back to Lisp, thank you
<hexology>
sorry :) i actually think it's important to be somewhat forward-looking about community sustainability and avoiding a massive wave of link rot
<aeth>
It is a bit of a crisis that the #2 hoster just said "if you don't use a language where you constantly have to patch finished libraries every year to keep those libraries running, your project is 'inactive'"
<Shinmera>
Anyway, the Redist system is here in case anyone wants to start hosting their own dist or something. https://github.com/Shirakumo/redist
<Shinmera>
I'm still working out some minor kinks and need to update some docstrings, but it's pretty much done.
<Shinmera>
Sure. I'd like to do more in the testing department, that bit's undercooked. The idea is that hopefully it'll allow someone else to take over the main quicklisp dist with minimal pains, in case anything ever happens to Xach.
<Shinmera>
And in the interim, of course allow people to create their own custom dists for whatever purposes.
<Shinmera>
(Like I do, for libraries that aren't cooked enough for QL)
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
NotThatRPG_away is now known as NotThatRPG
rainthree3 has joined #commonlisp
rainthree has quit [Read error: Connection reset by peer]
luna-is-here has quit [Quit: luna-is-here]
jeosol has quit [Quit: Client closed]
luna-is-here has joined #commonlisp
<NotThatRPG>
hexology: You should be able to host your projects on cl.net's GitLab -- I forget the actual means to do this, but it's on (or near) their home page
<Shinmera>
I should mirror my projects to my own gitea sometime but I'm very lazy.
livoreno has quit [Ping timeout: 240 seconds]
<morganw>
If the cost was legitimately a problem I think sourcehut are open to giving financial help: https://sourcehut.org/pricing/
luna-is-here has quit [Quit: luna-is-here]
<NotThatRPG>
Shinmera: Looking at redist, I'm wondering why you scan the ASDF files instead of loading them. You might miss some dependencies that way. Hm.... The obvious technique would be to load up an ASDF system definition in a subsidiary Lisp, but CL invoking a new image is really hard because CL doesn't have any equivalent to `sys.executable` in python
<Shinmera>
Because they can conflict and load arbitrary code and do whatever other wahoo.
<Shinmera>
some of them require gcc or other toolchains
euandreh has joined #commonlisp
<Shinmera>
I haven't verified, but I'd be surprised if I missed any dependencies this way.
jealousmonk has joined #commonlisp
<NotThatRPG>
Shinmera: There are some things that `defsystem-depends-on` still does not handle. As I said, the best thing would be to fire up a new lisp process, load the system in there, and interrogate that lisp process. But that's not possible in portable CL. :-(
molson_ has joined #commonlisp
<NotThatRPG>
Do any lisp implementations give access to the path of the executing lisp?
<Shinmera>
sure. argv0 exists.
<NotThatRPG>
I guess that's non-trivial, because you would also need to know what, if any, core is loaded
_cymew_ has quit [Ping timeout: 268 seconds]
<Shinmera>
Anyway, not sure what you mean by "things that defsystem-depends-on does not handle".
molson has quit [Ping timeout: 268 seconds]
<NotThatRPG>
Some ASDF extensions have issues because by the time they are loaded, ASDF can fail to parse the defsystem containing them (because that defsystem contains extensions that must be loaded prior to parsing)
<Shinmera>
Ok
<NotThatRPG>
I will have to recheck that, though.
luna-is-here has joined #commonlisp
<NotThatRPG>
Anyway, it would be great if CL offered a way to open up a new lisp process with the same characteristics as the invoking process.
<Shinmera>
forking exists
<NotThatRPG>
Even arg0 can't be found portably!
<NotThatRPG>
oh, yes, we can fork, but you can't do the trivial python thing of using `sys.executable` to find what to fork.
<NotThatRPG>
Fare tried to do this in a library for testing, but it's quite cumbersome, and it relies on populating a lot of environment variables. I wonder if we could enhance UIOP/launch-process to make this easier...?
<White_Flame>
UIOP gives you a portable argv0
<NotThatRPG>
White_Flame: Yes, that's why UIOP would be a good place for this. UIOP could probably also give a portable "loaded core," but that might be a little unpleasant to manage. Just a lot of drudgery to cover all of the implementations.
<NotThatRPG>
Does windows have an argv0?
<Shinmera>
yeah.
<NotThatRPG>
OK then.... I should add a GL issue for this. But first I need to get on my bicycle and head downtown...
NotThatRPG is now known as NotThatRPG_away
NotThatRPG_away has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
molson_ has quit [Ping timeout: 252 seconds]
luna-is-here has quit [Ping timeout: 255 seconds]
<Shinmera>
But also, I actually *can't* simply load the ASD in another process and read out the deps. That would *miss* dependencies that are feature-test-excluded.
jeosol has joined #commonlisp
molson has joined #commonlisp
luna-is-here has joined #commonlisp
molson has quit [Read error: Connection reset by peer]
Fare has joined #commonlisp
luna-is-here has quit [Ping timeout: 268 seconds]
pmwals09 has joined #commonlisp
pmwals09 has quit [Ping timeout: 268 seconds]
livoreno has joined #commonlisp
trocado has joined #commonlisp
orestarod has joined #commonlisp
<Shinmera>
Comparing with the quicklisp systems.txt that lists dependencies the differences seem to be down to: quicklisp including asdf as a dependency on a lot of systems? even if that system does not list the dependency explicitly. quicklisp including dependencies that seem transitive, but only on some systems and not others. and quicklisp missing a bunch of dependencies that are under feature flags.
<Shinmera>
The diff is a pain in the ass to look at as a consequence, but so far I have not spotted an occurrence where my system misses a dependency.
luna-is-here has joined #commonlisp
NotThatRPG has joined #commonlisp
<Shinmera>
Okey, did find some now with a custom differ.
[deleted] has joined #commonlisp
<jcowan>
Customs do differ, it is true.
luna-is-here has quit [Quit: luna-is-here]
livoreno has quit [Ping timeout: 268 seconds]
triffid has quit [Remote host closed the connection]
luna-is-here has joined #commonlisp
luna-is-here has quit [Client Quit]
<Shinmera>
Okey, I now also deal correctly with folks that do asdf:load-system (or any variant thereof) in their .asds.
<Shinmera>
On the note of those folks: boo
luna-is-here has joined #commonlisp
waleee has joined #commonlisp
luna-is-here has quit [Ping timeout: 268 seconds]
luna-is-here has joined #commonlisp
luna-is-here has quit [Client Quit]
luna-is-here has joined #commonlisp
jeosol has quit [Quit: Client closed]
luna-is-here has quit [Ping timeout: 268 seconds]
luna-is-here has joined #commonlisp
waleee has quit [Ping timeout: 244 seconds]
gateway2000 has quit [Remote host closed the connection]
azimut has quit [Remote host closed the connection]
waleee has joined #commonlisp
trocado has quit [Ping timeout: 252 seconds]
azimut has joined #commonlisp
karlosz has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 252 seconds]
Lord_of_Life has joined #commonlisp
Dynom_ has joined #commonlisp
Dynom_ is now known as Guest7377
rainthree3 has quit [Ping timeout: 268 seconds]
azimut has quit [Remote host closed the connection]
<NotThatRPG>
Shinmera: I haven't had time to check, but I do think there are still places where defsystem-depends-on does not work.
azimut has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 252 seconds]
<NotThatRPG>
I don't think it's necessarily a "boo" to the people still hand-loading dependencies.