are we being for real right now
The unix philisophy is when your program does 1 thing and does it well. For example Make does not do spaces well you should use a separate program for that or something
" "
the XY problem is that i'm taking a makefile "list" and turning it into a javac classpath string, which requires separating different elements of the classpath with : (but with ; on Windows, just to spice up your life), and it has its own not-very-intuitive wildcard rules, and blah blah. i think the oils guy would call this a "mini language". java guys cooked up a little domain-specific language for "setting the classpath" because they want a list but the shell speaks text, not lists

make made the decision to represent lists as space-separated strings, & apart from the obvious problems with that wrt. spaces in filenames, you run into friction interfacing with programs which decided to represent lists in a different way

but ohhh oh shell, it's just text, it's the universal language

@quat i am responsible for spack's use of the alarm bell which is a much more reasonable delimiter

@hipsterelectron @quat ascii already has a field delimiter. #30 decimal, 0x1E in UTF-8. It's a solved problem, and nobody uses the solution.

I guess it's not that different from how not many people type in Dvorak, but if all the weird layouts from linotype machines were still in use on different brands of computer because of reasons

@clayote @quat i only learned of this afterward after calling the problematic unicode author a fuckboy in nicer words
@clayote @quat think symbols used to represent text are very different than individual choice of keyboard layout which is invisible to people communicating with you and does not present compatibility issues
@clayote @quat with make and the shell the issue is i think a little deeper than that too because programming languages attempt to be convenient which is highly subjective as opposed to unambiguous like encodings (where i was wrong to use the alarm bell)
@clayote @quat nobody ever thinks maybe this would be useful to make configurable because everyone decided macros are evil and end user configuration is evil and fascist uniformity controlled by a central dictator is the only sane thing left in this world

@hipsterelectron @quat I mean uh

m4

if you really want to

@clayote @quat i have been fucking with the cpython configure script and learning that
(1) [obviously] m4 can't type check your generated shell scripts because it is a string replacer
(2) m4 can't even type check your m4 code

has me incredibly bummed out after i spent several hours thinking oh this is almost a better version of shell

@clayote @quat so i agree at least with whomever said that a macro language should be part of the language (maybe nobody said this)
@hipsterelectron Only every Lisper who encountered another language. 😅

@clayote @quat
@clayote @hipsterelectron i feel like this kinda kicks the can down the road tho... like it'll work right up until you need a list of lists, then you need a "field delimiter delimiter" or a new escape sequence and we're back to the start
@quat @clayote i think you could avoid infinite recursion with just two of these and then using a sequence of them to encode nested field endings as a binary number
@quat @clayote just made that up but it sounds right
@hipsterelectron @clayote de bruijn escaping
@quat @hipsterelectron @clayote This may be of some interest. The convention from back when those characters actually were used was to just use 1C-1F (File, Group, Record, Unit Separators) alongside (01-03 Heading, Start Text, End Text) for text content. You can do a lot with that, and alternating Group and Record delimiters basically gives you the ability to describe any tree, and of course any arbitrary graph can be flattened to a retrieval tree. I've seen this kind of thing in action on Pick mainframes and when I was a kid on take your child to work day I just assumed these conventions were a forever thing. I was pretty shocked that everyone forgot it was all fully figured out and standardized and they still have all those characters and just ignore them. Of course just glancing through the tables you see that it was also thought through how data link serialization and transmission control was to be handled. It's insane to me how we just keep unsolving our problems basically just to be pretentious
@somebody @quat @clayote i think being pretentious is not a complete explanation for not knowing that these characters exist. part of it is that parsing is considered housework
@quat @hipsterelectron ASCII defines four. The field delimiter is actually the second, the first being for units, because even Latinate languages can't agree on what separator to use between thousandses
@clayote @quat this is why i fucking hate utf-8 btw. i'm gonna actually make the zstd string library now that lets you train on a corpus
@quat linear path traversal is a really fucked up design pattern in its own right that makes the assumption
(1) you want to specify general search locations alone and nothing more specific
(2) you do not require nor expect the ability to audit where an individual resource was loaded from
(3) you want a global priority ordering for every possible named resource, with no way to enforce uniqueness or avoid the priority ordering other than prepending yet another entry
(4) searching locations for resources and consuming the resource from the location should be the same operation
(5) the language runtime best knows how to link up filesystem paths to resources
@hipsterelectron i was thinking abt why javascript can sorta pull off the "multiple versions of a dependency in the same project" trick but java cannot do that by default & it's because every class has to be given a unique identifier...? like in node everything is just relative imports
@quat i was thinking of doing this in python
@quat this is another reason i fucking hate es6 imports and think they should die in a fire. they were created by google to destroy the opposition
@quat java supports shading because jvm bytecode is one of the Good Formats
@quat @hipsterelectron I mean, java technically can do that, they just need to be loaded in isolated class loaders (afaik)
@quat if you have a named resource that comes from the filesystem then you have an internal data structure mapping the name to the location and it is much more efficient as well as auditable to have a distinct step to generate that map in a serializable form and build systems won't hate you and i won't break down your door and fork your compiler
@quat isnt there a whole category of filesystem problem called like the makefile problem
@quat make is weird because it tracks dependencies which is stateless but it's also a shell which is stateful. you don't have to be the pants task engine to track dependencies without relying on the only database without transactions i.e. our good friend the filesystem
@quat @zwol says filesystems should have transactions and it's easily one of the more reasonable things i want from a filesystem now
@quat I'm surprised we don't have a program for printing each ASCII character, Unix people need to Unix harder
@quat why not just... space=" "?
@quat why is it like this

@quat

Make ignores (i.e., treats as normal characters like any other) both single- and double-quote characters in virtually every situation, and all make functions work in simple whitespace delimiters without regard to quote characters.????? WHY