Yeah, it doesn’t really belong in the ‘no’ column. It’s not an appropriate cat food because it’s not nutritionally complete.

So it’s rather like how just eating bread or cornmeal that don’t have added vitamins will give you scurvy or pellagra. But obviously they’re not poisonous or anything and most of the world eats them without a problem.

I mean, this is mostly about treats, so…

Cats being obligate carnivores means most of their calories must come from meat because they e.g. can’t synthesize taurine like a human or dog can. But eating a bit of cat grass isn’t gonna kill them.

She married her husband a year after they both graduated college. This would have been taken while she was still in college.

Her father was a career politician, and had spent about a decade as Baltimore’s mayor before Kennedy’s election. That’s presumably why she was there.

At any rate, she’s never had a career outside politics. She did volunteer work for the Democratic party when she was raising her kids; she first ran for office around the time they were graduating from high school.

And memory bugs are only a subset of bugs that can be exploited in a program. Pretending Rust means no more exploitation is stupid.

This is facile.

According to Microsoft, about 70% of security bugs they see are memory safety issues.

Yes: if you introduce memory safety, there’s still those 30% of security bugs left. But, well, I’d rather worry about 30% of issues than 100%…

Similarly, I use libraries that eliminate SQL injections unless you really go out of your way.

Vav is a product of ashkenaszi pronunciations due to yiddish. Originally it’s Waw.

Vav has nothing to do with Yiddish.

The pronunciation shift occurred in a large number of groups that didn’t speak Yiddish, and shifts like that also aren’t uncommon cross-linguistically.

The exact same shift happened in Italian, as well: v in classical Latin made a w sound, but morphed to a v in most romance languages.

Pronunciation shifts don’t have to come out of influence of other languages, they just kinda happen normally on their own. Sometimes this causes spelling changes (such as the many Spanish words with an h that came from a Latin f, like hablo or hijo), other times it changes the sound of the letter, such as how the Greek phi went from an aspirated p to an f sound, or a j went from a y sound to an English j.

And the multiple names for God thing comes from Kaballah

Kabbalah talks about the multiple names of god, but the Torah itself uses a number of different names for god.

For that matter, look at Hebrew names. You have names like Matityahu (gift of god), Daniel (god is my judge), and eliyahu (god is my god), using different names of god. Why do biblical Hebrew names use both el and yahu to refer to god, if multiple names was a kabbalistic innovation?

Symbols display with friendly string-y names in a number of languages. Clojure, for example, has a symbol type.

And a number of languages display friendly strings for enumy things - Scala, Haskell, and Rust spring to mind.

The problem with strings over enums with a nice debugging display is that the string type is too wide. Strings don’t tell you what values are valid, strings don’t catch typos at compile time, and they’re murder when refactoring.

Clojure symbols are good at differentiation between symbolly things and strings, though they don’t catch typos.

The other problem the article mentions is strings over a proper struct/adt/class hierarchy is that strings don’t really have any structure to them. Concatenating strings is brittle compared to building up an AST then rendering it at the end.

Edit: autocorrect messed a few things up I didn’t catch.

Javascript is generally considered OOP, but classes weren’t widely available till 2017.

Inheritance isn’t fundamental to OOP, and neither are interfaces. You can have a duck- typed OOP language without inheritance, although I don’t know of any off the top of my head.

Honestly, the more fundamental thing about OOP is that it’s a programming style built around objects. Sometimes OO languages are class based, or duck typing based, etc. But you’ll always have your data carrying around it’s behavior at runtime.

If you’d like to look up more about the origins of PIE, look up the Kurgan Hypothesis, which suggests that Proto-Indoeuropean originated on the steppes.

Basically everything we know about PIE, we know from looking at its descendants. If a word appears in multiple unrelated branches, it’s probably from the common ancestor. Particularly if there’s consistent sound changes on one or more branches.

For example, it seems that a lot of PIE words with a p morphed into f in germanic languages. So, given the English father, Dutch Vader, Old Saxon fadar, Latin pater, Sanskrit pitar, Old Persian pita, etc. we can figure out that father goes back to some original PIE word which was probably something like pəter.

Similarly, we see similar words for salmon both in Germanic and Slavic. And in the extinct Tocharian language, the word for fish in general was laks. Lox originating only 1500 years ago means that the Slavic and Tocharian would be a pretty strange coincidence.

keeping state (data) and behavior (functions) that operate on that state, together

Importantly, that’s “together at runtime”, not in terms of code organization. One of the important things about an object is that it has dynamic dispatch. Your object is a pointer both to the data itself and to the implementation that works on that data.

There’s a similar idea that’s a bit different that you see in Haskell, Scala, and Rust - what Haskell calls type classes. Rust gives it a veneer of OO syntax, but the semantics themselves are interestingly different.

In particular, the key of type classes is keeping data and behavior separate. The language itself is responsible for automagically passing in the behavior.

So in Scala, you could do something like

def sum[A](values: List[A])(implicit numDict: Num[A]) = values.fold(numDict.+)(numDict.zero)

Or

def sum[A: Num](values: List[A]) = values.fold(_ + _)(zero)

Given a Num typeclass that encapsulates numeric operations. There’s a few important differences:

1. All of the items of that list have to be the same type of number - they’re all Ints or all Doubles or something

2. It’s a list of primitive numbers and the implementation is kept separate - no need for boxing and unboxing.

3. Even if that list is empty, you still have access to the implementation, so you can return a type-appropriate zero value

4. Generic types can conditionally implement a typeclass. For example, you can make an Eq instance for List[A] if A has an Eq instance. So you can compare List[Int] for equality, but not List[Int => Int].

The Italian word for earth is la terra, while in Spanish it’s la tierra.

Does it make any sense to say that one language had it first? Both are directly from Latin terra.

English, German, Dutch, Swedish, etc. all descend from a common ancestor, Proto- Germanic. There’s a lot of vocabulary they all inherited from it.

8k years ago, the distant ancestor of English was spoken on the steppes of Ukraine.

Their word for salmon was laks.

That became the English lox, Swedish lax, German lachs, Lithuanian lašiša, Russian losos, and Polish łosoś.

Yes, English didn’t exist 8000 years ago. Instead, there was a language called Proto-Indoeuropean spoken on the steppes of Ukraine. Just like how Latin spread and local dialects slowly became Spanish, French, Italian, Romanian, etc., PIE spread out and its descendants became Greek, Sanskrit, Russian, Latin, German, etc.

Part of what happened over time was sound shifts. For example, PIE p morphed into an f in Proto-Germanic. Father and the Latin word pater go back to the same PIE root word, but father exhibits the sound change of p -> f you saw in Germanic languages.

Similarly, Spanish has a sound change where f changed into h. So the Latin word fabulari (to chat) became hablar in Spanish and falar in Portuguese.

The point of the article is that the PIE word for salmon, laks, by random chance didn’t really morph much in Germanic languages. So you have lax, lox, lachs, etc.

Interestingly, the Old English word for salmon was leax, and that made its way into Middle English and early Modern English as lax. It died out in favor of the French-derived salmon, and then we borrowed lox back from Yiddish.

It’s like if beef entirely replaced cow, then we borrowed back koe or kuh from Dutch or German.

Ah, yes, that’s why the French still speak perfect Latin.

Yes, old grammar textbooks have been an incredibly important resource for linguists, particularly for reconstructing ancient pronunciations. They’re useful for teaching historians etc. Old French or whatever.

But we generally haven’t been terribly successful at beating students into using obsolete grammar rules and to stop using modern grammatical innovations.

Yep, 8,000 years ago laks meant any type of fish, living or prepared food.

Citation?

From what I’ve seen, 8000 years ago it meant salmon. Today, in English it means smoked salmon.

It’s a surprisingly minor shift for 8k years.

Which is why it’s one of the hardest languages to learn, there wasn’t even a noble population who were helping rules be set logically, it’s a slang language.

Which languages had nobles changing the rules of the language to be logical, and beat the peasantry until they repeated their absurd shibboleths?

Proscriptivists have existed in many languages, English included. They’ve basically always been tilting at windmills.

Governments tend to be most effective at killing languages wholesale, rather than systemically changing grammar. And it’s something that’s been far more effective in the past couple hundred years as part of nation- building projects. E.g. the efforts of France, Italy and Spain to squash minority languages like Occitan, Galician or Neapolitan.

According to etymonline,

Lax. Noun. “salmon,” from Old English leax (see lox). Cognate with Middle Dutch lacks, German Lachs, Danish laks, etc.; according to OED the English word was obsolete except in the north and Scotland from 17c., reintroduced in reference to Scottish or Norwegian salmon.

It’s weird in that lax died ~400 years ago, then was borrowed back ~100 years ago into American English from Yiddish-speaking immigrants.

It’s a weird loanword in that it was a loaned obsolete word that underwent some semantic narrowing in the loan.

Important words undergo sound changes all the time.

For example, in Germanic languages, Proto Indoeuropean p sounds consistently morphed into f sounds. So the PIE word pods became Proto Germanic fots became English foot. pəter became fader became father. The preposition per became fur became for.

Lox is mostly unusual in that it didn’t have any major sound changes affect it in Germanic languages.

The idea of a Pokémon clone isn’t protectable, but existing Pokémon are.

You can make a Pokémon clone with entirely novel monsters, but if a judge thinks they look too much like an existing Pokémon they’re gonna have a problem.

Yeah, projects also exist in the real world and practical considerations matter.

The legacy C/C++ code base might slowly and strategically have components refactored into rust, or you might leave it.

The C/C++ team might be interested in trying Rust, but have to code urgent projects in C/C++.

In the same way that if you have a perfectly good felling axe and someone just invented the chain saw, you’re better off felling that tree with your axe than going into town, buying a chainsaw and figuring out how to use it. The axe isn’t really the right tool for the job anymore, but it still works.

C is not how a computer truly works.

If you want to know how computers work, learn assembly and circuit design. You can learn C without ever thinking about registers, register allocation, the program counter, etc.

Although you can learn assembly without ever learning about e.g. branch prediction. There’s tons of levels of abstraction in computers, and many of the lower level ones try to pretend you’ve still got a computer from the 80s even though CPUs are a lot more complex than they used to be.

As an aside, I’ve anecdotally heard of some schools teaching Rust instead of C as a systems language in courses. Rust has a different model than C, but will still teach you about static memory vs the stack vs the heap, pointers, etc.

Honestly, if I had to write some systems software, I’d be way more confident in any Rust code I wrote than C/C++ code. Nasal demons scare me.