It reminds me of this weird theory about proto-Castillan. According to some scholars, the change from initial /f/ in Latin to /h/ in Spanish could have been caused by the bad teeth of the speakers of lore, a phenomenon ultimately due to the water quality in some areas.
It doesn't hold water. It's just a typical form of lenition. plenty of languages exhibit the same phenomenon. The example I'm most familiar with is Irish, where /f/ under certain phonological and grammatical conditions softens to almost nothing (written "fh" to maintain the underlying sound). The interesting thing is that the exact same set of circumstances causes /p/ to soften to /f/ (written "ph" to maintain the underlying sound). The sound didn't go away, but its partial disappearance became grammaticalised into what's called "séimhiú", which is incidentally appropriate as it contains an example of the phenomenon.
I don't know anything about Spanish language changes, but a change needn't have the entire population afflicted in order to occur-just enough people for it to become fashionable. And as modern trends constantly demonstrate, fashionable trends can come from anywhere, no matter how small a section of of a population, nor how silly the trend seems to be to the population at large, even as the population at large is overtaken by the fashion.
Even centuries later (1200s) the king Alfonso X the wise had to choose a main variety of Spanish among the ones that were used in the kingdom of Castilla y Leon.
So I doubt any previous change in the language was a coincidence or fashion: the population that spoke old Spanish was so big and diverse that it’s nearly impossible for them to suffer the same events.
> Typescript actually has an insanely powerful type system
I think you are conflating expressivity with complexity here. You do not need a complex type system to get a very expressive language. For instance, the typing rules of dependent type theory are fairly simple compared to the amount of trickery needed to make TypeScript work.
At constant expressivity, a simple type system is always preferable to a complex one. So I am not amazed by the fact that TS needs advanced PLT debauchery to kind of work. It doesn't even give you strong guarantees. There is a reason why Hindley-Milner type systems are called the sweet spot of static typing.
I think Typescript has both a complex and expressive type system. When I say "advanced" I'm talking about expressiveness. It is more expressive than Scala and (absent a laundry list of GHC extensions) Haskell.
I agree that Typescript certainly seems like a tower of hacks next to Idris.
Yet somehow it's pulled off a reputational miracle: having a more expressive type system than Haskell but not being regarded as an "advanced" language. Unfortunately I think that's mainly due to the ways the type system can be undermined, but it's still a useful nugget I ponder from time to time.
> It doesn't even give you strong guarantees. There is a reason why Hindley-Milner type systems are called the sweet spot of static typing.
HM by itself doesn't give you strong guarantees (see e.g. the ML family of languages which have comparatively weak guarantees next to Haskell). That's really due to other language and standard library decisions acting in concert.
HM type systems are often the sweet spot for static typing not because of the guarantees they offer, but because of the global type inference it yields. More expressive extensions of HM often break global type inference in some way.
The phenomenon described in this article is actually an instance of Reynold's parametricity. This one of the free stuff you get for using a (reasonable version of) static typing.
Nah, I agree with Hobsbawm in "The Short Twentieth Century" that the previous century ended in 1989, with the fall of the Berlin wall. Since then we've been observing the heyday of neoliberalism, fueled by a lack of a serious contender.
Neoliberalism effectively stopped any history. We are living in a Neoliberal Atemporality. Or more precisely: we have lived through it and are now about to leave it. Not sure what will follow next, but one thing is certain: the history is about to reboot itself.
What do you mean? CoC definitely supports impredicative encodings, and as far as expressivity goes, this allows to implement a lot of programs. Proving them correct is another matter, but that's not what you implied. Also, CIC is notably not Turing-complete.
I was referring to https://link.springer.com/chapter/10.1007/3-540-45413-6_16; induction is not derivable in pure CoC. I suppose yes technically you could base a dependently-typed language on it if you didn't mind not supporting induction, but I can't imagine many people wanting to use it, as it would be quite limited compared to one supporting inductive proofs. Or at least when people think of "dependently typed programming language", they're usually thinking of something at least as expressive as CIC.
It's even clearer when you consider higher-order functions. These diagrams are only able to represent functions of order at most 2, i.e. what is called "dependency injection".
"Jour" is polysemic, it literally means "day", but metaphorically it also means "light". For instance, "voir quelque chose sous un nouveau jour" means "to see something under a new light", rather than "a new day".
https://en.wikipedia.org/wiki/Phonetic_change_%22f_%E2%86%92...
Needless to say I've always found this hypothesis doesn't really hold water...