Still, at its core, PyPy is a Python interpreter which is itself written in Python and the name PyPy fittingly describes its technical design.

The observation is that second implementation of a successful system is often much less successful, overengineered, and bloated, due to programmer overconfidence.

On the other hand, I am unsure of how frequently the second-system effect occurs or the scenarios in which it occurs either. Perhaps it is less of a concern when disciplined developers are simply doing rewrites, rather than feature additions. I don't know.

[0] https://en.wikipedia.org/wiki/Second-system_effect

I'm not a physicist, but from my understanding, the situation is a bit more complicated than the phrasing in your question suggests.

Observation #1: The light from far-away galaxies is redshifted (spectral lines are a bit off from where we'd expect them to be). This suggests that these galaxies are moving away from us. The farther away the galaxy, the more it is redshifted. This suggests that the farther away the galaxy, the faster it is moving. Observations indicate that the recession speed is directly proportional to distance.

This observation is consistent with general relativity, which suggests an expanding universe with homogeneous mass.

But on a smaller scale, gravitational binding somehow takes over, and on even smaller scale, things like electromagnetic and nuclear interactions start having a greater impact, and that's why the Milky Way isn't itself expanding. For that matter, even Andromeda (0.8 Mpc) is too close to be affected by Hubble-style expansion, which only becomes observable at the multi-megaparsec scale.

It's original purpose, if I understand correctly, was to guarantee that fundamental rights were an essential part of the constitution and couldn't be amended away.

Wikipedia says that multiple countries appear to have adopted the principle: Pakistan, India, Bangladesh and Uganda.

One can objectively reason through the first set of considerations, while the second involves a subjective element and is likely heavily influenced by their upbringing and life experiences.

Nobody knows how much to save or how much to spend on insurance. It's completely reasonable to seek advice, and one's parents might be a great starting point.

Instead of the ones(10^0)-thousands(10^3)-millions(10^6)-billions(10^9)-... system followed in most other parts of the world, the Indian numbering system uses ones(10^0)-thousands(10^3)-lakhs(10^5)-crores(10^7)-...

So, for example, half a million subscribers (500,000) would translate to 5 lakh subscribers (5,00,000).

var x: int = y + 5

Here x is the variable being defined, it is declared to hold values of type int, and its initial value is given by the term y + 5.

In many mainstream languages, types and terms live in distinct universes. One starts by asking whether types and terms are all that different. The first step in this direction of inquiry is what are called refinement types. With our imaginary syntax, you can write something like:

val x: { int | _ >= 0 } = y + 5

Once again, x is the variable being defined, it is declared to always hold a value of type int at all relevant instants in all executions, and that its initial value is given by the term y + 5. But we additionally promise that x will always hold a non-negative value, _ >= 0. For this to typecheck, the typechecker must somehow also confirm that y + 5 >= 0.

But anyway, we have added terms to the previously boring world of types. This allows you to do many things, like so:

val x: int = ... val y: int = ... val z: { int | _ >= x && _ >= y } = if x >= y then x else y

We not only declare that z is an integer, but also that it always holds a value that exceeds both x and y.

You asked for the type of a function that multiplies two numbers. The type would look weird, so let me show you an imaginary example of the type of a function that computes the maximum:

val f : (x : int) -> (y : int) -> { int | _ >= x && _ >= y } = ...

This doesn't really get you to the maximum, because f might be computing max(x, y) + 5, but it does show the idea.

The final step in this direction is what are called full-blown dependent types, where the line between types and terms is completely erased.

Or at least not completely extinct in South India. Some of my favorite childhood memories are from these messes (short for mess hall, I assume). You go there, pay what they ask, eat what they serve.

MTR, Brindavan on MG Road (though that's long gone), Iyer Mess in Malleshwaram.

What they lack in choice they usually make up for in taste.

You're right that they have a more traditional ambience and newer restaurants offer more choice, but they are definitely thriving in the parts of Bangalore that I grew up in.

I remember reading an article some time ago about European vs North American traffic signs. The article was praising the European system that relies more heavily on icons over the North American system which is more text-heavy. I can't remember the details now, but I remember disagreeing vehemently with the article.

I find many of the traffic icons (particularly the ones indicating something about parking, stopping and one-way streets) very unintuitive. I strongly prefer the text-heavy signage that I see in the US.

Growing up in India, iodized salt was the norm. Given that I'm vegetarian, now that I have moved the US, I have continued to use iodized salt for my own cooking. Whatever Morton / Kroger / other grocery store brand is most readily available. I usually keep it stored in an airtight plastic jar but use it for cooking like normal.

Should I be worried about iodine loss during cooking?

I just wrote a script without a .py extension, and it seemed to work fine.

In my experience, treewidth is one of those ideas at the outer limits of my ability to understand.

I have spent several hours staring at the idea on several different occasions, and at the end of each of these sessions, I come away with a vague sense of why it is important and why the definition is natural, only for its complexity to completely overwhelm me the next time I encounter the concept.

There are basically two ways to produce big numbers: add two small numbers, or multiply two small numbers. You can produce all positive integers by starting with zero and repeatedly adding one. You can almost do the same thing with multiplication too, except for these pesky primes, which are somehow atomic. Naturally then, one might ask: (a) How many primes are there? (b) How frequently do they occur? (c) Can we look at a number and determine whether it is a prime? Now consider: Despite being among the oldest of the mathematical disciplines, there are still open problems about primes that can be explained to high school students.

Also, multiplication and addition are not simply operations that are of interest with respect to integers, but similar ideas apply to a bunch of other domains too. Polynomials, for example. So primality and primality-like ideas are like catnip for mathematicians.

Perhaps another way of asking the question is: Are there any results, either about individual programs or in PL theory as a whole, that were made simpler / clarified / generalized because of category theoretic insights?

I still have lots of questions:

1. Doesn't this system raise the possibility of coercion? For example, a goon or abusive spouse might, under threat of violence, force you to vote in a certain way and mark your ballot for them to audit afterwards. Isn't plausible deniability also one of the key desiderata of the election process?

2. The system allows me to mark my ballot paper and confirm that my vote was correctly counted, after the fact. But I still need to trust all the other votes uploaded to the website. Of course, the presence of independent election observers (who watch the counting process and the ballot boxes being moved around) would mitigate this fear.

The way I read these rules is not from left-to-right but from right-to-left. In this case, it would say: Pick two numbers a > 1 and b > 1, their product a*b is a composite number. The solver starts with the facts that are immediately evident, and repeatedly apply these rules until no more conclusions are left to be drawn.

"But there are infinitely many composite numbers," you'll object. To which I will point out the limit of numbers <= 30 in the line above. So the fixpoint is achieved in bounded time.

Datalog is usually defined using what is called set semantics. In other words, tuples are either derivable or not. A cursory inspection of the page seems to indicate that Logica works over bags / multisets. The distinct keyword in the rule seems to have something to do with this, but I am not entirely sure.

This reading of Datalog rules is commonly called bottom-up evaluation. Assuming a finite universe, bottom-up and top-down evaluation are equivalent, although one approach might be computationally more expensive, as you point out.

In contrast to this, Prolog enforces a top-down evaluation approach, though the actual mechanics of evaluation are somewhat more complicated.

I can't say that I've understood it all, but he appears to criticize scientists for not thinking about play seriously, and instead reducing most aspects of animal behavior to things like survival, fitness, and evolutionary pressure.

Does the complicated flowchart point to deficiencies in the Slack user interface? If the user cannot intuit the flowchart, then how can they (as several sibling comments rightly point out) reliably turn notifications on or off?

Algorithmic transparency should be a thing, no?

"Don't turn this knob. But if you really need to, talk to this person first."

And that little bit of process is perhaps what keeps many industries safe.