<alva>
For my hobby things its so much nicer to just statically link everything and plop a binary onto some server.
<alva>
It doesn't need to have *anything* installed.
<ELLIOTTCABLE>
idk binaries, because I've only rarely worked in an AOT-compiled language; and even then, I've not had occasion to use much or anything in the way of *libraries*
<ELLIOTTCABLE>
I still barely fucking understand what linking is. or how libraries *work* in C, etc.
<ELLIOTTCABLE>
Ruby, Node, Python (a little), Lua (ugh. rocks.), etc
<ELLIOTTCABLE>
the one that's basically mushed the Blockchain, Tor, HTTP, and their own P2P/content-addressed database shit into a big beautiful mess?
<ELLIOTTCABLE>
jfhbrook: what the fuck is that? D:
<ELLIOTTCABLE>
alva: C++ scares me shitless; I won't touch it with a ten-foot pole ._.
<alva>
That sounds awesome, ELLIOTTCABLE. Like you say what you want instead of where you want?
<ELLIOTTCABLE>
someday, maybe, but, I'd rather just write my shit in plain C, until Rust is mature
<ELLIOTTCABLE>
or perhaps put that entire sentence in the past-tense
<ELLIOTTCABLE>
‘I'd rather have written everything in C, until Rust matured’
<ELLIOTTCABLE>
alva: kinda, yeah.
<ELLIOTTCABLE>
alva: you'd really, really like my plans for package-management.
<alva>
I don't think Rust will ever replace C for the things C excels at.
<ELLIOTTCABLE>
basically, I want to bring the unit of dependency down a step of comprehension, from ‘API’ to ‘API endpoint.’
<alva>
Which, IMO, is few very specific things
<ELLIOTTCABLE>
you *publish* a package (as a name), but you *depend on* endpoints of that package
<ELLIOTTCABLE>
you buy-in to a particular namespace by the package's name in the global namespace, just line in most package managers,
<alva>
Interesting
<ELLIOTTCABLE>
but you don't *version* by that; you have to explicitly version every single endpoint you use:
<ELLIOTTCABLE>
i.e. you don't necessarily call `Coolpackage.start()`, you might call `Coolpackage.start@2()`.
yorick has quit [Ping timeout: 244 seconds]
<ELLIOTTCABLE>
if you use both Coolpackage.start@2, and Coolpackage.setup@3, and there is no individual *release* of `coolpackage` that includes both of those … then dependency resolution fails, and you are *forced* to go read the developers' release-notes, and see what breaking changes drove them to update to start@3
<jfhbrook>
ELLIOTTCABLE: devops did a cutover on the NAT and it made Literally Everything stop working
<jfhbrook>
ELLIOTTCABLE: pagerduty made my phone completely blow up
<ELLIOTTCABLE>
and all of the above, theoretically, should be content-addressed: I intend for this to be powered by a flow-analysis / type-inference engine, that can (for the most part) tell what-depends-on-what within a particular package's boundaries
<ELLIOTTCABLE>
jfhbrook: I … do not know what many of these words mean
yorick has joined #elliottcable
<jfhbrook>
ELLIOTTCABLE: NAT = network address translation, it's how you can make one ip address on the "outside" map to n ip addresses on the "inside" of your network
<jfhbrook>
ELLIOTTCABLE: pagerduty is an app that sends you texts and emails you and shit when things break
<jfhbrook>
you integrate it with various metrics like nagios, etc, etc
<ELLIOTTCABLE>
ick
<jfhbrook>
(we don't use nagios but I figure that's lowest common denominator in terms of what people are aware of for this sorta thing)
<ELLIOTTCABLE>
I have no idea what that is either
<ELLIOTTCABLE>
devops: It's All Actually Magic™
<ELLIOTTCABLE>
alva: frankly, I want a git-like (or git-backed) storage system that associates flow-analysis information with each revision; that can be quickly queried (like `git blame`, but for ‘breakingness’: `git broke`?) systematically
<ELLIOTTCABLE>
I have other plans that basically require me to tightly integrate my high-level ‘language’ interface with git *anyway*, so it's pretty likely that I'm going to be baking ‘code revision’-related semantics into the HLL.
<alva>
I'm not even sure what that means but it sounds cool!
<ELLIOTTCABLE>
(sorry, mercurial etc)
<ELLIOTTCABLE>
alva: I mean … which part?
<ELLIOTTCABLE>
(also, sorry, people who don't version their code. also, *really*? in 2016? ಠ_ಠ)
<alva>
ELLIOTTCABLE: "associates flow-analysis info wit each revision"
<alva>
Flow analysis like compilers do?
<alva>
And modern CPUs I guess
<ELLIOTTCABLE>
k my low-level langauge is entirely dynamic: there is no typing (or any other sort of metadata) baked into the mid-level operations AST, to put it another way.
<ELLIOTTCABLE>
(it's a bit like Smalltalk I guess? or something similar, with the purely-dynamic-method-dispatch.)
<ELLIOTTCABLE>
so, to derive information like ‘is <thingie> called?’, you have to compiler-style flow-analysis
<ELLIOTTCABLE>
but think more flowtype.org's usage thereof, not an optimization-related usage. This is for tooling and developer-support, not runtime optimization.
<alva>
Mmm I see
<ELLIOTTCABLE>
in this case, the particular ‘developer support’ in question is, “Is this update going to break my code?”-support, basically.
<ELLIOTTCABLE>
or more importantly, “is this update going to break *other peoples'* code?”.
<ELLIOTTCABLE>
so, a developer can explicitly hint that an endpoint had a breaking change
<ELLIOTTCABLE>
(whether that's an enum-style thingie changing structure, or a public method taking a new API, or using meaningfully-different semantics, or … something else unfathomable. ‘API endpoint’ is intentionally undefined.)
<alva>
I even got LLVM to actually do stuff for me. Then I opened Twitter and learned that I'm worse than Hitler for using C and crawled into bed.
<ELLIOTTCABLE>
LOL
<purr>
LOLNOPE
<ELLIOTTCABLE>
thx purr, nailed it
<ELLIOTTCABLE>
alva: <3 C, dw about the h8rs
<ELLIOTTCABLE>
!g elliottcable sodomizing ISO C @ alva
<ELLIOTTCABLE>
-g elliottcable sodomizing ISO C @ alva
<ELLIOTTCABLE>
a dev could hint that they changed the semantics of ‘foo’. that's a “break.”
<alva>
My GBA game is in C. Should I write that shit in fucking Rust? I don't think so.
<alva>
It'd all be unsafe { everything here }
<ELLIOTTCABLE>
there's no explicit library-author-accessible versioning in this concept, just an integer count of ‘breaks.’
<ELLIOTTCABLE>
`unsafe { everything here }` is my new band name
<alva>
:)))
<ELLIOTTCABLE>
so either in something like a doc-block or a syntactic declaration like `def foo@2` or something, or perhaps even (if I go through with my completely-unresonable tight-versioning-integration plans) in the commit message / as a commit-time flag¹, a library-author says “I've broken a contract, with these changes to `foo`. If you use `foo`, you need to read
<ELLIOTTCABLE>
my instructions and possibly update your code.”
<ELLIOTTCABLE>
meanwhile, a particular user has, say, a function-call to foo: `foo()`. That will continue to call `foo@1()`, until the user explicitly updates it² to `foo@2()`.
<ELLIOTTCABLE>
mind you, `foo`'s *resolution* should be content-addressed: like I said above, you're opting into CoolPackage as 10277E0C-2DE7-4ACD-8EE9-B0AF292B72D2 or something.
<ELLIOTTCABLE>
(2. I've got some syntactic ideas for all of this, but that's a distant concern. I think it was alexgordon's idea to use primes for N≤4? `foo`(), `foo``()`, etc. A bit Haskell-ey.)
<ELLIOTTCABLE>
(also Wikipedia-style, only the first resolution of a given external identifier necessarily needs to be disambiguated / linked, after that it's implied that further uses refer to the aforementioned version.)
<ELLIOTTCABLE>
ugh making me want to work
<ELLIOTTCABLE>
I swore, no programming until I'm out of classes -_-
<alva>
This all sounds pretty rad
<alva>
But I also like explicit contracts in code as documentation, because programmers are terrible at documentation
<alva>
Ideally we'd have both :)
<ELLIOTTCABLE>
ugh
<ELLIOTTCABLE>
alva: yeah, that's a plan here
<ELLIOTTCABLE>
alva: that's the sort of family of things that the @1/``` etc fall into.
<ELLIOTTCABLE>
they're like types, but instead of annotating flow, they annotate *awareness*.
<ELLIOTTCABLE>
another way to look at this is that it's sort of a ‘pure’ namespace: every possible *identifier* (if we treat the `@2` as “part of the disambiguation process”, and thus effectively part of the identifier) can only ever map to one API-design: breaking changes effectively *aren't allowed*.
<ELLIOTTCABLE>
but instead of having to get around that by naming your API endpoints `foo`, `fooAfterIFixedThatOneThing`, `fooButWithAnOptionsArgument`, and then `fooThatTakesACallbackInstead`, you can retain the concise, semantic name, and disambiguate breaking changes via @N.
<ELLIOTTCABLE>
alva: still around?
<eligrey>
i should register
<eligrey>
U+1F424 looks like the twitter logo in segoe
rfrfrfrfrf has joined #elliottcable
<ELLIOTTCABLE>
oh lord hi
<ELLIOTTCABLE>
rfrfrfrfrf: irccloud! <3
<ELLIOTTCABLE>
it can be quiet. One of those bursts-of-frantic-activity sorts of spaces.
<rfrfrfrfrf>
ok, I don't really get how irc works after all this time, due to lack of actually using it.
<ELLIOTTCABLE>
SJWPLTBBQ → SJW/PLT → Social Justice Warriors / Programming-Language Theory → discussing social issues, being kind, and talking about how programming languages should be built, and how we can go about doing so
<ELLIOTTCABLE>
also just social and noise, but ... I'm actively trying to encourage more signal. :P
<eligrey>
ELLIOTTCABLE: it's the eu law that revolts you, right?
<fujisan>
i send
<fujisan>
Andy Weir author of the Martian a message and he replied
<ljharb>
ELLIOTTCABLE: do you really believe that authors have the right to withdraw their name from code they've released, such that unpublishing must be preserved?
<ljharb>
ELLIOTTCABLE: (separately, the instant something is published, it could be depended on by nonpublic code, so there's no way to know - meaning, everything needs to be assumed to be depended on, always)
<ELLIOTTCABLE>
eligrey: … no.
<ELLIOTTCABLE>
eligrey: don't even. plz.
<ELLIOTTCABLE>
fujisan: omg no way
<ELLIOTTCABLE>
ljharb: rephrase
<ELLIOTTCABLE>
ljharb: but be aware I have ~fucked~ myself by staying up this late and not doing any homework today (largely buying suit, but also a huge chunk thinking about and writing all that up, and then a bit side-tracked at the last bit by ipfs.io … ugh.)
<ELLIOTTCABLE>
and now may not have any time to really invest in replying to the damn thing I wrote for the next fewd ays
<ljharb>
ELLIOTTCABLE: i'm referring to your recent comments on that npm github thread
<ELLIOTTCABLE>
I'm looking to be … Very Swamped in the immediate future. o_o
<ELLIOTTCABLE>
ljharb: yah, no, I mean, rephrase your first message
<ELLIOTTCABLE>
I can't parse it English-wise
<ljharb>
ok
<ljharb>
ELLIOTTCABLE: can you elaborate on what you don't like about npm's new unpublish policy?
<ELLIOTTCABLE>
o_o
<ELLIOTTCABLE>
you mean ... beyond the 3,000 words I just wrote?
<ljharb>
i'm asking for a shorter answer, yes
<ljharb>
the 3000 words don't make it clear to me what your core objection is
<ELLIOTTCABLE>
I think developers deserve the ability to pull a _why for their mental-health, to sanitize as much of their name from the *active* development community as possible if they have a continuous problem with stalkers and death threats, and even, frankly to say ‘screw npm and screw npm's users’ if they get in a fight with kik.
<ljharb>
ok so that's 2 separate points
<ELLIOTTCABLE>
and that's all well-and-good, but nobody's ever going to 100% get that … and that's also a philosophical point, not a technical or directly-related-to-npm one,
<ljharb>
to the first: they can withdraw all they want
<ELLIOTTCABLE>
so my *real* point is bolded, in the middle.
<ELLIOTTCABLE>
no
<ELLIOTTCABLE>
they can't.
<ELLIOTTCABLE>
plz don't.
<ljharb>
by simply ceasing participation
<ljharb>
you can't just say "plz don't" as if this is a controversial comment
<ELLIOTTCABLE>
“You can call yourself him all you want, all I'm saying is *I'm* going to call you her, because that's what you were born, and that's what I prefer, and I can do that.”
<ELLIOTTCABLE>
I can because I'm exhausted and just about to leave
<ljharb>
that's utterly different
<ELLIOTTCABLE>
no.
<ELLIOTTCABLE>
ugh.
<ELLIOTTCABLE>
just, don't, have time to reply in detail.
<ELLIOTTCABLE>
sorry if that's making me snappish.
<ljharb>
that's fine, you can reply tomorrow
<ELLIOTTCABLE>
*really* feels obvious, and like, …
<ELLIOTTCABLE>
<words>
<ljharb>
but misgendering/misnaming is nowhere near relevant to this
<ELLIOTTCABLE>
<obtuse? contentious? … not-discussing-in-good-faith?> of you, to act as if it's in-obvious
<ljharb>
if it feels obvious to you and not to me, neither of us can be discussing in good faith by relying on that
<ljharb>
so the explanation is required
<ELLIOTTCABLE>
but trying to take a breath and believe you *seriously* think that them walking away from the Internet is Definitely Good Enough Because You Said So, and that their possible need to erase all of their history, or remove themselves from active circles, or <etc>, is something that they may actually need, regardless of you understanding
<ELLIOTTCABLE>
3 0qfewjguirbehstigraoefa
<ELLIOTTCABLE>
yeah
<ELLIOTTCABLE>
I definitely know
<ELLIOTTCABLE>
I'm sorry.
<ljharb>
in that scenario, why would `npm disown` not suffice?
<ELLIOTTCABLE>
am completely unreasonable right now. walked around Chicago for many hours in dress-shoes to break them in … am helllllishly exhausted and in pain and stressed. I'm gonna ... go, before I make more of an ass of myself.
<ljharb>
ok
<ljharb>
ping me tomorrow when you're rested then :-)
<ELLIOTTCABLE>
I *really* think I answered all of that, but I also realize how rushed my writeup was, and ... apparently, I guess, incoherent. Ugh, that's a horrible realization after spending hours on it.
<ELLIOTTCABLE>
no, definitely will be gone until … saturday? or possibly mid-next-week.
<ljharb>
ok, then, then
<ELLIOTTCABLE>
's why I'm pissed at myself, backed myself into a time-corner.
<ELLIOTTCABLE>
ljharb: <3 )'=
<ELLIOTTCABLE>
oo, simple, maybe, to help:
<ELLIOTTCABLE>
fundamentally about push-vs-pull. Forget npm, forget registries, just talk about a chunk of code for a sec: from where I'm standing, the whole argument devolves to: “If I handed you some code, should *you* have to *check*, of your own voilition, occasionally, if you're a kind person, whether you're hurting me in the way you're using it? Even if that way is
<ELLIOTTCABLE>
allowed by the license?”
<ELLIOTTCABLE>
or do we go the other direction and *push*: “You have to *choose* to be an asshole†, because the default is going to be for everybody to do the thing that hurts me least.”
<ELLIOTTCABLE>
(† where ‘asshole’ is really-abbreviated-description of “someone who, at least hopefully, has good reason to go against the wishes of the person who created this great thing they rely upon.”)
<ELLIOTTCABLE>
all this goes back to the old battle over the wikipedia article on _why
<ELLIOTTCABLE>
like, plenty of people argued plenty of times that changing the title to his real name was *Wikipedia policy* that was in place for a *good reason*, and that it wasn't *actively hurting him* to have it titled accurately ...
<ljharb>
ok but there's a bit of a difference
<ljharb>
an article is *about* the author
<ELLIOTTCABLE>
but in the end, sensible heads (from my perspective, I guess, anyway?) prevailed, and realized: it doesn't *matter* if you don't understand how it hurts him, for his name to be associated with that historical shit, his work, etc. It doesn't *matter* if it's technically difficult for Wikipedia to do this, or if it decreases the quality or reliability of the
<ELLIOTTCABLE>
Wikipedia index, or … etc. What mattered were his wishes, end sentence.
<ljharb>
if your name is on a "foo" lib, how i use the foo lib is unrelated to you
<ELLIOTTCABLE>
or more particularly, his wishes w.r.t. what hurt him.
<ljharb>
that's the part i'm not understanding tho. how can anyone possibly be hurt simply by having their name attached to some piece of software?
<ELLIOTTCABLE>
I agree about that: *the functionality*, if it were completely divested of its history, its culture, its references ... I definitely see that it could be very difficult for that to affect the person after they left.
<ljharb>
i agree completely that when it speaks to the person's *identity*, that their subjective wishes often trump all else
<ljharb>
but my software is not my identity
<ljharb>
it's just some code i wrote
<ELLIOTTCABLE>
but that's just not the case: everything, from the converations around it, to the FIXMEs and the README, to the API naming choices, to the package name itself, to the cultural image of the package not encoded in any particular way into the source of the package ... all of that is bound up with the functionality in a way that I'm convinced is irreconcilable.
<ELLIOTTCABLE>
/=
<ELLIOTTCABLE>
wow
<ELLIOTTCABLE>
then you ... don't write software the way a lot of us do
<ELLIOTTCABLE>
I guess? :x
<ELLIOTTCABLE>
that sounded judgemental: i don't mean it to be. #intentionsnotmagicaltho
<ljharb>
i mean, i def define myself partially in terms of the code i wrote
<ljharb>
i'm not saying it's totally decoupled
<ELLIOTTCABLE>
so like I'm super-priv'd and chances of me needing to get away from software To Be Okay are pretty fookin' low, but, let's assume that happened somehow.
<ljharb>
but the software itself isn't my identity. the act of making it is, but not the code itself
<ljharb>
ok sure
<ELLIOTTCABLE>
actually no I hate using myself as an example; I'd prefer to point out that I'm realistically on the dependants' side of this argument, despite arguing for the authors
<ljharb>
ok use me
<ELLIOTTCABLE>
no like specifically,
<ELLIOTTCABLE>
trying to think of a friend as invested in a particular work of theirs as I am into Paws
Rarik has joined #elliottcable
<ljharb>
hm
<ljharb>
ok
<ELLIOTTCABLE>
or _why was into his works
<ELLIOTTCABLE>
it's ... kinda a different thing. a holistic life approach.
<ljharb>
right but _why's work didn't vanish
<ljharb>
he just took down his own site
<ELLIOTTCABLE>
we're really sidetracked now, heh, but, I can ... understand how you might not get it
<ljharb>
and nobody knows his real life name
* ELLIOTTCABLE
nods
<ljharb>
so he literally vanished his identity, and yet not his work
<ELLIOTTCABLE>
well, plenty do, but there's a *culture* of respecting their wishes, and kinda ... pretending that they don't?
<ljharb>
and even if he'd left up his own site, his amount of vanishing or remaining would be the same today
<ELLIOTTCABLE>
but: important that I'm differentiating _why's *exact situation*, from *the way we treated him*, if that makes sense
<ELLIOTTCABLE>
much better to analogize <arbitrary future npm users' work> to <_why's name>, than to analogize it to <_why's work>
<ljharb>
as i recall, the way he was treated was, "let's not figure out his real name"
<ljharb>
and "let's not allow him to deprive us of his work"
<ELLIOTTCABLE>
to an extent, yes: but that was in the sense of people *taking up those projects*, and *making their own, new things out of them*
<ljharb>
meaning, a balance of respecting his privacy, but also respecting "the entirety of humanity"
<ELLIOTTCABLE>
(his sprit lived on, so to speak)
<ljharb>
wasn't why's guide put back up untouched?
<ELLIOTTCABLE>
yesyesyes but this is key
<ELLIOTTCABLE>
npm *defaulting to, basically, republishing works instantly* is what I am against … not against people, real people, doing stuff like that.
<ELLIOTTCABLE>
there's a level on which *I'd* call that an asshole move; but that's also immaterial
<ljharb>
hm
<ljharb>
why is that effectively different tho?
<ELLIOTTCABLE>
point here is defaults of a giant, inhuman system.
Rorik has quit [Ping timeout: 246 seconds]
<ljharb>
like whether it's a human or automated cause. the *effects* are the same, no?
<ELLIOTTCABLE>
“In fact, here, I think that bears repeating: **The point here, is that I truly believe that the dependants need to each, individually, *actively*, indicate their willful acknowledgement of the package-authors' wishes in unpublishing.**”
<ljharb>
ok - why?
<ELLIOTTCABLE>
npm basically has to *lean* one way or the other: it can't really prevent *either* from happening
<ljharb>
to me, the implicit contract of `npm publish` is, "i no longer get a vote"
<ELLIOTTCABLE>
(author can send legal takedowns … and vice versa, users can exploit license and copy/reproduce/fork/etc)
<ljharb>
if i'm not comfortable with that, i don't publish
<ELLIOTTCABLE>
… yes, according to the current rules.
<ELLIOTTCABLE>
but that's artificial.
<ljharb>
no i mean morally
<ELLIOTTCABLE>
that's An Npm That Exists.
<ELLIOTTCABLE>
but my, and many others', point,
<ljharb>
i'm saying that the instant i release free content to the world, i waive the right, forever, to rescind that content
<ljharb>
and if i don't like that, i shouldn't ever release content
<ELLIOTTCABLE>
is that there is a Better Npm out there, the one we're gradually describing in that Issue; and we think npm should *retract* that policy, and be that Better Npm.
<ELLIOTTCABLE>
again: not rescind content purely
<ELLIOTTCABLE>
flahahhhhhh
<ELLIOTTCABLE>
uhm,
<ljharb>
(note i have no objection to `npm disown`)
<ELLIOTTCABLE>
I keep thinking that typing quickly and sending quickly will get me to sleep quicker. Clearly, it's just introducing conversational barriers and slowing it down.
<ELLIOTTCABLE>
Note to self: stop that. :P
<ELLIOTTCABLE>
we're … like, 99% on the same page.
<ljharb>
lol ok
<purr>
lolololol
<ELLIOTTCABLE>
again, the thing I copy-pasted is what this is all about to me:
<ELLIOTTCABLE>
Yes, we both think an author should be able to broadcast that they have this desire for their creation: that it go away, that it stop. For whatever reason. One of many. Technical, emotional, social ...
<ljharb>
right but why must the much larger group of N users, willfully acknowledge *anything*, just because *one* author decided to bail?
<ELLIOTTCABLE>
... it's not a numbers game.
<ljharb>
ok - why does that one author get to impose that burden on any one other user?
<ELLIOTTCABLE>
You're assuming that the *majority* of those users are above-defined assholes.
<ljharb>
i'm assuming nothing
<ELLIOTTCABLE>
Or, alternatively, you're assuming that that one-user is an above-defined asshole.
<ljharb>
i'm saying why does the author get to impose a burden on *any*one
<ELLIOTTCABLE>
Sure, in a system of malicious actors, the suggestions I proposed would be *horrible*: fifty thousand e-mails sent, spuriously, when each big package author decided to throw a tantrum
<ELLIOTTCABLE>
sorry, I type too slow and conversantly read too slow >,<
<ljharb>
i'm not talking about malicious actors at all
<ljharb>
azer's tantrum is indefensible and irrelevant (except that it triggered this convo)
<ELLIOTTCABLE>
if the author is a good-actor, acting in good faith (let's assume for a moment they are),
<ljharb>
sure
<ljharb>
so why in that scenario does the author get to impose a burden on anyone else?
<ljharb>
and "willfully acking the author's desire to bail" is a burden.
<ELLIOTTCABLE>
then the only person they're inflicting unwanted work on is the person who *wouldn't*, already, decide to fork, or replace, or whatever, the package, when they discovered that author's wishes.
<ELLIOTTCABLE>
I think it's super-relevant and super-defensible. ¯\_(ツ)_/¯
<ELLIOTTCABLE>
but thaaaaat one is way more emotionally charged and ... rhetoric-y, so, mehhhhh to arguing it ¯\_(ツ)_/¯
<ljharb>
if the author acts in good faith, and i have to do *literally any work*, then that's a burden on me
<ljharb>
how is it ok for the author to make me suffer?
<ELLIOTTCABLE>
that's my point:
<ELLIOTTCABLE>
forget npm for a second
<ljharb>
sure, let's say it's a blog post or something
<ELLIOTTCABLE>
let's say the user, out-of-band, sent you an e-mail, because you were the only user of their package, saying:
<ljharb>
ok
<ELLIOTTCABLE>
let's further assume you're the *only* user, for a moment.
<ljharb>
sure
<ELLIOTTCABLE>
… wait, really important distinction
<ELLIOTTCABLE>
s/user/distributor
<ELLIOTTCABLE>
dependent-library-author
<ljharb>
ok that's a totally different scenario
<ELLIOTTCABLE>
“For my mental health, I need to withdraw from the community; <short blurb of reasoning, think blog-post>. Despite my license, I'd appreciate it if you stopped distributing my software with yours; and found other software out there to fulfill the need you're filling with my old work. Thanks. )=”
<ljharb>
but sure, let's say one author, one distributor (me), and N users
<ljharb>
ok
<ELLIOTTCABLE>
Now, sure, you may have reasons (I touched upon a few in my 3,000 freakin' words, lawl), some of them even good, for not wanting to do that:
<ljharb>
(the part i'd be missing is the connection between "need to withdraw from the community" and "i stop distributing")
<ELLIOTTCABLE>
ugh ‘him’
* ELLIOTTCABLE
headdesks
<ljharb>
producing something does not mean you have the right to destroy it
<ljharb>
(necessarily)
<ELLIOTTCABLE>
but, those reasons aside, the Right™ thing to do here, is to do everything you can to work around those reasons: fork their original work, removing references to them, if it's under an open-source license and you *really* need that *specific* work; or more likely, replace their dependency with some other similar package, even if it takes a little work to
<ELLIOTTCABLE>
re-write the contact-surfaces between your library and theirs.
<ljharb>
that's your version of Right
<ljharb>
i do not agree that's the right thing to do
<ELLIOTTCABLE>
the Wrong™ thing to do is think, “that sounds like effort. I don't have the time or money for that.”, and then to continue to distribute that, because the license technically say you can.
<ELLIOTTCABLE>
obviously, you can *do* that
<ljharb>
ok so i agree "i want to be lazy" is the wrong thing
<ELLIOTTCABLE>
and like, nobody will explode and the world will go on and nobody will even likely dislike you: there's even a good chance the person won't care that much. ¯\_(ツ)_/¯
<ljharb>
but "continuing to distribute: imo is not the wrong thing
<ljharb>
if one's mental health requires that a gift you've given be returned, i don't have much compassion for the needs of one's mental health.
<ELLIOTTCABLE>
but … can you see that there *is* a real, moral difference here? even if it's slight, even if there's tons of edge cases, and every situation is going to be different?
<ELLIOTTCABLE>
right there. that.
<ELLIOTTCABLE>
why?
<ELLIOTTCABLE>
like, I would be sad.
<ljharb>
it's a gift
<ELLIOTTCABLE>
I might really like the gift.
<ljharb>
you have *forever lost the right to get it back*
<ljharb>
tough!
<ljharb>
that's what gifting it means
<ljharb>
that if you want it back, you're just sad
<ELLIOTTCABLE>
‘our society has these conventions about this thing called a <gift>’ does. not. trump. their. pain.
<ljharb>
and you have to learn to cope with that
<ELLIOTTCABLE>
even if you don't *understand* it.
<ljharb>
i'm not saying they won't be in pain
<ELLIOTTCABLE>
now, *your pain*, can/might/does.
<ljharb>
i'm saying they have to endure it
<ELLIOTTCABLE>
but just because it's called a gift? that's a Hella Petty Reason to feel pain.
<ELLIOTTCABLE>
do you see how that maps back to packages/code/licenses?
<ljharb>
i think it's hella petty to ask for a gift back because you're in pain
<ljharb>
that's insanely selfish
<ljharb>
your pain does not trump other people's wishes either
<ELLIOTTCABLE>
‘but u saaaaaaid! in this license! right here!’ is a Hella Petty Reason to … basically, not put the almost-always-tiny effort in, in the 0.01% of situations where this happens.
<ljharb>
in this scenario, i am empathetic to the person's pain
<ljharb>
the license tho is just what gives me the legal right to redistribute - it's not the moral part
<ELLIOTTCABLE>
I'm emphasizing to make a point, here: I *agree* that it's all a spectrum.
<ljharb>
the reason i'd keep distributing is "i'm sorry you're in pain, but your pain in no way justifies me inflicting pain on anyone else, on your behalf"
<ELLIOTTCABLE>
back to packages instead of gifts, like, If it's going to cost your business a bunch of man-hours to replace it ...
<ELLIOTTCABLE>
if nobody in the community can be found to take/maintain/replace ...
<ljharb>
if someone's pain requires the suffering of others to be relieved, then someone just has to live with that pain
<ELLIOTTCABLE>
etcetcetc: there's going to be tons of situations where, just, nah.
<ELLIOTTCABLE>
I get that.
<ELLIOTTCABLE>
but *to assume that that's the preponderance* of situations?
<ELLIOTTCABLE>
and to make a completely unfeeling system **default** to **encouraging** that to be the solution? /=
<ELLIOTTCABLE>
“if someone's pain requires the suffering of others to be relieved, then someone just has to live with that pain”
<ljharb>
yes
<ELLIOTTCABLE>
without qualification, that works both ways, and cancels itself out. -_-
<ljharb>
it doens't
<ELLIOTTCABLE>
by that statement, equally-much your pain at having to replace packages is somethng ‘you just have to live with.’
<ljharb>
if A is already in pain, and A needs B to suffer pain for A's pain to be relieved, A loses. always.
<ELLIOTTCABLE>
wat.
<ljharb>
now, perhaps B might willingly choose that
<ljharb>
and in that case that's great
<ljharb>
but the *default* should not be that B endures pain, simply because A wishes it
<ljharb>
that makes authors the ones in control of that power dynamic
<ljharb>
and in the same way as public servants should be held to a higher standard, and their wishes given *less* consideration than those of the masses: i think authors should too
<ljharb>
being a software author is a responsibility. part of that responsibility is that *you matter less than your users, always*
<ELLIOTTCABLE>
that is such an amazingly ... conservative thing to say. like, not necessarily in the American way. I mean that more in the ... rawest, most basic definition. “There's no measurements or ifs or ands or trying-for-the-best. It's all black and white: we only *try*, if we can't *fail*: we only *fix*, if the fixing isn't possibly going to break it more.”
<ljharb>
like you said, it's a spectrum
<ELLIOTTCABLE>
see, I disagree strongly with that
<ljharb>
i think everyone on that github thread that's on your "side" disagrees with that
<ljharb>
and i think that might be the real fundamental disagreement
<ELLIOTTCABLE>
it seems we agree in some weird (to me) specifics, but that the major differences are that 1. you play the numbers game (i.e. think the possibility of there being 5-in-1000 users who Would Rather Inflict, trumps the 1-of-1 author who Would Rather Inflict, i guess to simplify it),
<ljharb>
numbers have nothing to do with it
<ELLIOTTCABLE>
and 2. that you have some ... well, to me, very strange, idea of ‘tiers’ of software-developers
<ljharb>
i'm saying 1 user trumps 1 author.
<ELLIOTTCABLE>
I see it all as a deeply interconnceted web: *none* of us are end-users, we're all using eachothers' software to build software that the other is eventually, themselves, quite likely to use.
<ljharb>
but also, we can't just pretend scale doesn't impact thing
<ljharb>
s
<ELLIOTTCABLE>
so that viewpoint doesn't really ... land with me?
<ljharb>
of course it's tiers. package authors < web devs < users, for example.
<ljharb>
it's all a dependency graph
<eligrey>
ELLIOTTCABLE: did you preorder the model 3?
<ljharb>
and i'm saying that whichever end is more creators, gets less consideration than the end that's more users
<ljharb>
because creators have so much power already
<ELLIOTTCABLE>
web-devs are *application* authors: I already *completely* excluded that group. From my perspective, if they're involved in this discussion *at all*, they're already fundamentally Doing It Wrong (and kinda fucking us over by making us consider them in this discussion, frankly)
<ELLIOTTCABLE>
and that's like something can also be argued ... but elsewhere?
<ELLIOTTCABLE>
so just, maybe when talking to me, assume we're exclusively talking about library-authors consuming other library-authors'/tool-authors' work.
<ljharb>
ok
<ELLIOTTCABLE>
but, that aside:
<ljharb>
but in each transaction there's still a consumer and a producer
<ljharb>
and i'm saying the consumer's needs are paramount
<ELLIOTTCABLE>
even assuming a directional graph, just, ew @ consumers ≥ producers. ew ew ew.
<ELLIOTTCABLE>
I find it ... morally reprehensible, I guess?
<ljharb>
i'm using the terms to describe the relationship, if you have better ones, great
<ELLIOTTCABLE>
but that's hella subjective, and difficult to dive into in-depth, so ...
<ljharb>
i find it morally reprehensible to claim that an author has the right to withdraw something they've created.
<ELLIOTTCABLE>
another viewpoint on it, then:
<ljharb>
like, getify
<ljharb>
he published books
<ljharb>
he can certainly ask people to stop selling his books
<ELLIOTTCABLE>
I think ‘Producers don't matter’ should be an opt-in viewpoint, just as much as you said above that you think that ‘Producers' feelings matter’ should be opt-in.
<ELLIOTTCABLE>
so I think we've just come full-circle:
<ljharb>
but his name will *never* be stricken from the content, nor the content stricken from existence
* ELLIOTTCABLE
nods
<ljharb>
so it doesn't matter if getify ever *wants* to "withdraw" there
<ELLIOTTCABLE>
just going to have to come back to it. god, how is it 3am. ;_;
<ljharb>
he published books. meaning, he NEVER GETS THE CHOICE
<ljharb>
i'm saying that some kinds of releases of content, permanently and irrevocably waive the ability to withdraw in that fashion
<ELLIOTTCABLE>
like I acknowledge that that's how it works in the real world, but we also threw rocks at eachother to steal eachothers' food instead of throwing the rocks at the animals, for millenia? so ‘it's how we do things’ ≠ ‘it's the right way to do things’
<ljharb>
and while it's a shame if that wasn't clear at the time of publishing, them's the brakes
<ljharb>
*breaks
<ELLIOTTCABLE>
so seems irreelvant
<ljharb>
right, i'm saying this is the right way to do things
<ELLIOTTCABLE>
“i'm saying that some kinds of releases of content, permanently and irrevocably waive the ability to withdraw in that fashion”
<ELLIOTTCABLE>
why.
<ELLIOTTCABLE>
which brings us back, full-circle.
<fujisan>
ELLIOTTCABLE: way
<ELLIOTTCABLE>
to the whole point of this discussion: ascertaining *why* the content can't go-away, in this context, with the pre-requesite that we're not gonna just say “because we can't make it go-away *everywhere*”
<fujisan>
I have the screenshot upstairs
<ELLIOTTCABLE>
… which brings us back through the same discussion of producers-and-consumers,
<ELLIOTTCABLE>
gack
<ljharb>
oh no that's not what i'm saying
<ELLIOTTCABLE>
ljharb: yah, I know
<ljharb>
even if all those books could be destroyed
<ljharb>
i'm saying that i think morally they shouldn't be
<ELLIOTTCABLE>
I was just saying that was kinda the ground rule I'm pretty sure we're all (hopefully) agreed on:
<ELLIOTTCABLE>
that making decisions re: npm (or anything, really), shouldn't be on the basis of “well, they can get it out of the Internet Archive *anyway*”
<ljharb>
i agree on that
<fujisan>
ELLIOTTCABLE: he is a programmer as well
<ljharb>
however, i also think that that reality can't be ignored
* ELLIOTTCABLE
nods
<ELLIOTTCABLE>
I think discussions like this should *start* in an ivory tower, reach a reasonable conclusion *morally*, and then be … tainted, I suppose?
<fujisan>
Andy Weir for president
<ljharb>
and i do think that no matter how much you wish for an impossible thing, if it's impossible, why are we wasting time addressing the wish
<ELLIOTTCABLE>
“Find the best truth, and then find the shortest-distance effective truth.”
<fujisan>
ELLIOTTCABLE: are you still a virgin like me?
<ELLIOTTCABLE>
fujisan: wat.
<purr>
beep.
<ELLIOTTCABLE>
-what
<purr>
<prophile> and now when I sit down my poor testes burst like grapes
<ELLIOTTCABLE>
-sleep
<purr>
ELLIOTTCABLE: night everyone!
<ELLIOTTCABLE>
-bed
<fujisan>
Truth or dare
<ELLIOTTCABLE>
-find bed
<purr>
ELLIOTTCABLE: Could not find `bed`.
<ELLIOTTCABLE>
BAH
<fujisan>
ELLIOTTCABLE: im an on purpose virgin nature made me ugly so i would care for nature
<ljharb>
ELLIOTTCABLE: right - i think that my ivory tower position is, "it's released, it's permanent, fuck off", and the tainted part is "it's ok to `npm disown` or similar"
<ljharb>
ELLIOTTCABLE: but i recognize that our ivory tower positions differ
<fujisan>
ljharb: are you real?
<ljharb>
nope, i'm your imagination
<fujisan>
ELLIOTTCABLE: did i tell you about my dream?
<ELLIOTTCABLE>
…
<ELLIOTTCABLE>
no
<ELLIOTTCABLE>
fujisan: in my ungodly-many years of knowing you, have I ever told you that you're very strange? :P
<alva>
i've been wondering what to do about old code under deadname
<alva>
at work i have code under 3 names
<fujisan>
Turns out i was dreaming and then gave myself the commandprompt to wake up to a higher reality it happened tgen i felt like an alien for 10 seconds headahock and dropped back into this safe reality
<fujisan>
I think it was my symbiot
<fujisan>
It was so scary and real
<ljharb>
alva: my opinions would be either a) leave it forever abandoned and untouched, b) transfer it to newname, if the connection is tolerable, c) find others to take it over and transfer to them, d) build up a fictitious history of conversations between newname and deadname and transfer it to newname, thus avoiding the connectin
<fujisan>
I think im the only survivor and created this reality to escape loneliness
<fujisan>
ELLIOTTCABLE: am i crazy?
<ljharb>
you created an entire reality, and ended up in an irc channel to escape loneliness?
<fujisan>
Yeah
<ljharb>
you may want to give your imagination more credit than that
<fujisan>
It was just a bad dream :)
<ljharb>
that's the spirit
<ELLIOTTCABLE>
Solipsism is a thought-process with a rich history of study and opinion, and I'm sure many others feel just like you do, fujisan. ;)
<alva>
ljharb: a is what i've been doing
<fujisan>
But the alien feeling was so real and scary
<ljharb>
alva: that seems easiest, obvi
<fujisan>
ELLIOTTCABLE: yeah been studying like crazy for 3 weeks no tv start new job for the government in early may
<ljharb>
alva: i mean, i guess you could also e) do any needed work under deadname, but that might not be tolerable since transitioning/namechanging can be pretty intense
<fujisan>
They said i was a structured and deep thinker good thing they didnt see the FUjisan chronicles on github :-x
<fujisan>
ELLIOTTCABLE: do you have any study or worklife tips or repositorues i might be able to utilize?
<fujisan>
Repositories*
<fujisan>
Damn ios keyboard
<ELLIOTTCABLE>
g/d my back hurts
<ELLIOTTCABLE>
fujisan: huh?
<ELLIOTTCABLE>
repos?
<fujisan>
Lifehacker sites etcetera
<alva>
ljharb: yeah, it's also just hard to keep separate identities active yet... separate
<fujisan>
Knowledge banks
<alva>
no software accounts for it
<ljharb>
alva: totally fair. maybe multiple OS-level user accounts, one for each?
<fujisan>
ELLIOTTCABLE: i know you are smart you have the qualities of a zenmaster
<ELLIOTTCABLE>
i do o_O
<ljharb>
alva: especially if all the auth was with something like 1password, and each OS-level user account had different password vaults, i think thatd make it tough to mess it up
<ELLIOTTCABLE>
things.app
<ELLIOTTCABLE>
use things.app for eeeeee'rydamnthing
<ELLIOTTCABLE>
i go now tho ugh
<fujisan>
Ty
<ELLIOTTCABLE>
fujisan: ask me this weekend? <3
<fujisan>
Sure ty gnight
<alva>
ljharb i think it'd be too much for me personally just to keep that other person alive
<ljharb>
alva: very understandable
<alva>
i now regret not just using some pseudonym for everything :p
eligrey has quit [Quit: Leaving]
fujisan has quit [Quit: Connection closed for inactivity]
Sgeo__ has quit [Ping timeout: 244 seconds]
Navarr has joined #elliottcable
Rarik has quit [Read error: Connection reset by peer]