preseinger

my comment in no way takes the thread into a flame war, and i'm pretty frustrated that it's being judged that way

it's commonly totally sufficient for IDs to represent a rough sort order

millisecond precision is great for a lot of use cases

the point isn't that issues and PRs exist, it's that the maintainers don't seem to know what they're doing

this is self-evident from a cursory review

link me any 3 non-trivial merged PRs and i'm happy to point out the problem i'm describing

and what does your experience tell you about applications which are not written in PHP, and which need to handle more than 1000 concurrent users?

code generators are programs written in an existing programming language, which produce target language source code as output

macros are programs written in a separate, unique, often turing-complete meta-language, which is implemented entirely in the compile phase of the language which supports them

they're in no way equivalent

usually, code generation is preferable to metaprogramming, mostly because it is easier to understand and maintain

metaprogramming is not a virtue

programming languages do not themselves need to be programmable

and a government warrant bypasses all of that

there was this whole thing with edward snowden a few years ago, maybe you remember?

where does all of that hardware live?

unless it's in your home, it's not trustable

bare metal has high capex and low opex

cloud vms have low capex and high opex

which one is more expensive is a function of many variables

how do you know your network is trusted and/or private?

trick question: you can't

even the network links between hosts in a single rack in a DC can be vulnerable

no, it isn't

it's an unsatisfiable requirement, and unnecessary to substantiate the legal claims

it's dumb to talk about

yes, really

feeding input to a program is pretty clearly categorically different than providing source material to a human being

how could someone "prove" which inputs and outputs of a large ML model leveraged any specific data?

i fully understand and appreciate the distinctions, and equivocations, you're describing here. i also agree with you that the best "stuff" acknowledges and maximizes both left- and right-brained parameters

my point is less about these abstract concepts, and more about the perspectives that human beings have when engaging with this "stuff"

concretely -- when i'm playing a musical instrument, my brain is in a mode that is completely different than, and totally incompatible with, the mode my brain is in when i'm writing a program, or working on a math problem

it's one or the other

why's book reads to me as a "playing an instrument" perspective on a "writing a program" problem, which doesn't work for me, at all -- personally!

other people, it works, i get that

i think my example of "balancing equations" was a poor one. obviously, there is almost never a single objective solution to a programming problem.

probably a better metaphor for programming is as a craft -- not a pure science, like math; not a pure art, like painting or writing; but much more akin to something like woodworking

yep! and i have almost exactly the opposite experience!

with ruby i feel (same caveats) like there is so much ambiguity that i can't build a coherent and predictable mental model of my program -- it makes me feel anxious and unsure

what you characterize as "cramped and constrained" i probably experience as "precise and unambiguous" -- it makes me feel calm and in control

no judgment from me about which of these perspectives is better or worse, i don't think there is any way to say that, just want to point out this interesting difference in perspective among practitioners

it's a spectrum, of course, but imo yes -- i don't want types to be opt-in at compile time, i want them to be mandatory

it's definitely possible to model programming as an art, and there is value in that model, but (imo) that model is neither productive nor accurate in most programming contexts

right! and, to build on that: people who see programming as maths understand it fundamentally differently than those who see it as prose, they approach every aspect of programming differently, evaluate "quality" on entirely different metrics, etc.

in my experience, this is a major source of friction in programming teams, and deserves to be addressed more directly -- if i had it my way, i'd prefer that those who see programming as prose would be disabused of this incorrect notion, but i understand that this is my bias speaking, and not any objective truth :)

it characterizes programming in a way that is basically incoherent to most stereotypical programmers

(i agree with you, for the record, it was gobbledegook to me too)

the question is: does programming represent some kind of subjective expression, or some kind of objective precision? why's little zine says it's the former, but that's not how i see it at all

programming is, for me, like working on math problems, or balancing equations, it's strict and pure and precise, and that's what i love about it, there's no connection to anything like art, or writing (in the novel sense), or other kinds of subjective expression

but for some people, programming is like art, or writing a novel, or in any case a subjective expression of some abstract idea (or ideas) that they have

at least this is what i see as the discrepancy

i don't think anybody really claims python can't be used to build large software

the claim is usually more about how the maintenance costs are just way higher versus a statically typed language

absent further qualifications it is two files

i think one important difference between externalizing complexity to unix tools like ssh, and externalizing complexity to npm libraries, is related to (for lack of a better term) quality control

any dingbat with a terminal can produce an npm library that you can use in your application, the level of quality control is basically zero

but it takes a pretty strong track record to get your software into coreutils, or really any base linux distribution

to put it kind of cynically, i think there is an enormous difference between relying on ssh vs. relying on leftpad, gatekeeping based on competence measured over time is i think actually important and good to do

it's pretty straightforward, everything that logs takes a logger as a dependency during construction

if you can delegate synchronization/ordering to the monotonic clock of a single machine, then you should definitely do that :)

but that's a sort of trivial base case -- the interesting bit is when you can't make that kind of simplifying assumption

do you think the things you mention were deliberate design decisions?

thanks! neat!

icinga? nagios?

you're stuck in 1999 friend

these tools, and the patterns they enable, have been outmoded for over a decade

haha, man, the absolute _chutzpah_ you need to make (incorrect) accusations like this, even as an anonymous person on the internet, is really breathtaking

i hope you reflect on this interaction at some point