The only reasonable default assumption is that even "idiot" parents have more interest in the survival and well-being of their own children than the vaccination industry equivalent of the Sackler family.
> All of your data structures have types ... Static typing just means that you annotate ...
Programs have (static) types, data does not. Static typing removes correct programs from the language. Try this in some ML-like language:
let selfapply f = (f f) in
let identity x = x in
selfapply identity 42
If you transcribe this to (e.g.) Lisp, it will return the number 42. The program is short, simple, and safe, but well-regarded static type systems can't cope.
Any static constraint is likely to rule out good and bad programs. The tradeoff is how irreplacable those good programs are vs. how dangerous those bad programs are. "endofunction over either integers or endofunctions over integers (or over endo…)" is cute but I wouldn't lose a lot of sleep from underconstraining that domain.
> traits that are highly correlated with climate denialism
Sure. Since it is socially so much easier to be a secretly skeptic climate congregationist than an open climate denier, I'd bet one such correlated trait would be extreme honesty.
The search engine coughed up a PDF. I randomly opened it (p. 173) and read up to this author-provided "TL;DR" on p.176:
The main reason, however, for thinking that sociobiology is false, is the simple
one I gave at the beginning: that it is obvious that human beings are the most
intelligent and capable things on earth. But genes are not human. Therefore (etc.).
Well, it might make more sense in context. You can't litterally read a random sentence on a random page of a book and expect to have a reasonable opinion on its quality.
Also: money. Answering the question of how to name the streets is expensive (doubly so with the nasty political infighting), putting up street labels costs money too, and all of this creates plenty of opportunity for some parties to line their pockets. With that in mind, it's not surprising if the locals find the proposal not cost-effective.
True if you don't cooperate at all with the collector, but easily avoided in many cases. E.g., when using Boehm, try using gc_malloc_atomic() for data that you know cannot contain pointers, like your encryption buffers.
You don't think I might have mentioned it if he was?
He says that people who are loyal, hardworking, and not too bright are best suited to being slaves, and it stands to reason that some races are more inclined towards those traits than others, and that probably includes Africans.
Of course, this is a nice way of saying that slavery doesn't make rational sense - that it's a case of pure "might makes right", exactly as common sense would suggest. Think about it - if your slaves are "loyal and hardworking", do you even need to enslave them by coercion? Of course not - they'll work for you voluntarily as long as you treat them in a way that they accept as fair! (And oftentimes - perhaps even most of the time - they turn out to be a lot brighter than you gave them credit for while treating them as mere slaves.) And if this is the best case, what about everyone else? No, what the slaveowner really dreams of is that he's going to control his slaves purely by their fear. And Moldbug is saying: "nah, that's not going to work. Deal with it."
Way to miss the actual argument he's making, dude. You were not even on the same wavelength.
Of course I have - that's why I wrote the above. Moldbug may acknowledge that slavery seems to arise "naturally" in some circumstances, but he's not laboring under any delusion that what's "natural" - be it slavery or marriage - is per se good or desirable.
> "A type system is a syntactic method for enforcing levels of abstraction in programs. " [1]
> What syntactic methods are used in dynamically "typed" languages?
Interesting. You may have unwittingly provided one of the best justifications for the term "dynamically typed" I've seen so far.
That's because operations that violate a (safe) dynamically typed language's chosen set of abstractions (built using bits, church encoding, whatever) are syntactically inaccessible.
> That's because operations that violate a (safe) dynamically typed language's chosen set of abstractions (built using bits, church encoding, whatever) are syntactically inaccessible.
They are semantically inaccessible, not syntactically inaccessible. These languages enforce abstractions by attaching meaning to the tags implicit to all values, and these meanings combined with the operation are what drive the next evaluation step, ie. success or raise error value. This is not what happens in typed languages.
Lexical scoping is an example of a syntactic method commonly employed by dynamically typed languages. It's possibly the only one.
Edit: I have both of Pierce's "Types and Programming Languages", and "Advanced Topics in Types and Programming Languages". "Dynamic typing" is mentioned exactly once, on page 2 of the first text where Pierce says:
> The word "static" is sometimes added explicitly [...] to distinguish the sorts of compile-time analysis we are considering here from the dynamic or latent typing found in languages such as Scheme, where runtime type tags are used to distinguish different kinds of structures on the heap. Terms like "dynamically typed" are arguably misnomers and should probably be replaced by "dynamically checked".
> semantically inaccessible, not syntactically inaccessible.
You can give the semantics of everything that happens in a safe d-t language in terms of church encoded tag-value pairs and yet the programmer can't break the abstraction because abstraction-breaking operations are syntactically unavailable.
It should count as testament to the success of dynamic typing that the abstractions are so safely enforced that you can squint and suddenly the whole language is semantically founded on them.
> You can give the semantics of everything that happens in a safe d-t language in terms of church encoded tag-value pairs and yet the programmer can't break the abstraction because abstraction-breaking operations are syntactically unavailable.
This strikes me as just a Turing tarpit argument. Sure you can represent and enforce semantics syntactically, and you can probably also do this via automatic translations in many or most cases. Why is this compelling? And what does this have to do with types?
The definition of type system I gave is, "a syntactic method for enforcing levels of abstraction in programs". Ergo, not all syntactic methods qualify as a type system, but a specific kind of syntactic method classify type systems. Why do you think your translation qualifies?
The only reasonable default assumption is that even "idiot" parents have more interest in the survival and well-being of their own children than the vaccination industry equivalent of the Sackler family.