Hi Faré, and thanks for remaining active on these mailing lists, I'm
getting that you're spread thin these days.
Could you (or anyone who feels competent to explain it) tell us again
what
is a Logical Pathname (LP) and how does it differ from a Pathname
object in
general (as printed and readable by
#P"some-string-representing-a-pathname") ? i have CLtL2 as well as
Franz'
"Common Lisp: The Reference" here on my shelf but, true confessions
time, I
have rarely cracked these books and I find them somewhat intimidating
just
to open and read for no specific reason. If anyone's explanations of
pathnames and logical pathnames can refer to specific sections or
passages
from those books, I might dare crack them to look at those sections.
One question I have is: Are Pathnames evil in general (and we should
be
working with bare strings as "pathname designators")? Or is it
Logical
Pathnames specifically that are evil. Is a logical pathname a thing
with
the VMS-looking path syntax, e.g. `sys:some;logical;path;` as opposed
to a
Pathname object which is something like a struct with 6 slots
(directory,
name, type, host, device, version)? Maybe the concepts are
orthogonal,
i.e. a Pathname object's string #P"<some-string>" can be of "native"
format
or in "logical pathname" format? So we could potentially get things
like
#P"/opt/gendl-ccl/gdl/program/gdl-ccl" or #P"sys:gdl-ccl". And in
the
first case, HOST, DEVICE, VERSION would be unspecified, while in the
second
case the HOST is "sys:" and DEVICE and VERSION are still unspecified,
or
can a given HOST come along with its own default notion of DEVICE and
VERSION just as it comes along with its notion of DIRECTORY, or do
those
other defaults come strictly from *default-pathname-defaults* ? And
is
the Logical Pathname format meant to be able to accomodate all six of
the
slots in the Pathname object -- is that the connection between
Pathnames
and Logical Pathnames?
None of these are burning questions, or blocking my productivity as
far as
I know (I tend to get things working by hook or by crook and leave
them
alone, and knock wood, pathnames per se have not been one of my big
bottlenecks lately). But I am curious to understand the systemic
issues
better i.e. if there are an identifiable finite list of shortcomings
in the
current ANSI spec that we could at least quarantine or create some
kind of
polyfill for it, although if I had understood Faré completely, maybe
I
would have understood that uiop is the closest thing we currently
have to a
"polyfill."
Dave Cooper
---- On Mon, 15 Dec 2025 03:30:49 -0500 *Faré <[email protected]
<[email protected]>>* wrote ---
Of course, the detailed behavior of LP translation is so poorly
constrained by the ANS that using LPs just squeezes the portability
toothpaste from one end of the tube to the other, out through the
nozzle,
and onto your keyboard.
You'd think it's toothpaste, but actually it's radioactive sludge.
Don't touch it. Do go anywhere near it. Keep it away from kids, keep
it away from adults without a hazmat suit.
Making UIOP and ASDF work with "Logical" pathnames was hell. And it
won't actually "work" that well: between limitations that SBCL
enforces but not others implementations, quirks and bugs of many
implementations, atrocious performance (guaranteed O(N)), and
impossibility for non-gurus to configure, much less debug... it's
100%
worse than using a variable and uiop:subpathname and/or
pathname-translations, 100% of the time. Only valid use I've ever
seen
was to have location-independent debug information on CCL, but that
was CCL-only magic.
Oh yeah, did you know that it's impossible to not have a HOST? And on
some implementation, the HOST will determine the syntax and various
limitations, such that you cannot, conceivably, have a portable
representation of pathname in CL, even less so in presence of Logical
Pathnames? Not that any of the standard functions (especially NOT
merge-pathnames, as you might like to believe) is designed to deal
with relative pathnames properly. It took me months to get UIOP to
kind of work correctly on portably most of the time for most of the
cases on most implementations... but absolutely not, never, not
possible using Logical Pathnames—UIOP will do its best, but the
best
isn't very good.
—♯ƒ • François-René ÐVB Rideau
•Reflection&Cybernethics•
http://fare.tunes.org
“There are just two rules of governance in a free society:
Mind your own business. Keep your hands to yourself.” — P. J.
O'Rourke
