Website: https://hopl4.sigplan.org Papers: https://dl.acm.org/toc/pacmpl/2020/4/HOPL
167 karma · joined January 25, 2018
Website: https://hopl4.sigplan.org Papers: https://dl.acm.org/toc/pacmpl/2020/4/HOPL
In particular, I see many obstacles to a "free society in which everyone gets to pursue a dignified life": healthcare costs, ongoing climate disaster, erosion of labor rights, rising nativism and authoritarianism on the far-right, etc. chief among them. To be as monomaniacally focused on "cancel culture" as Mounk (and many others on the center/right of the American political spectrum) strikes me as misguided at best and disingenuously self-serving at worst.
Persuasion seems to me a massive over-reaction to the minor injustice that is "cancel culture" wrapped in some self-important and grandiose rhetoric.
Just as a little extra context on what "unsound" means here since the term is often misused or used in different contexts: this program violates "type soundness", which is informally stated as "well-typed programs don't go wrong".
Generally you'll see this shown via a "progress" lemma (~ "all non-value expressions can take a step in the operational semantics") and a "preservation" lemma (~ "expressions' types are unchanged by the operational semantics") which, by induction, yield a theorem like "all expressions of type T can be evaluated to a value of type T" (for all T).
This paper, since it deals with actual programming languages and not minimal calculi, may feel a little bit removed from the theoretical stuff, but under the hood it's the same idea: preservation doesn't hold when applying `coerce`, so well-typed programs _can_ go wrong.
There's some great discussion in Section 6.3 about the (abundant!) literature on Java subsets/core calculi, and both the benefits and limitations of using such languages to reason formally about actual PLs.
Source: PL PhD candidate, used (parts of) it to teach a graduate compilers course.
the idea should generalize to whatever thread-pool/effect constraints you want to express, but the paper and implementation are focused on keeping UI effects on the android main thread.
My friends, colleagues, and community are being directly endangered by CU's obfuscation of case data, refusal to provide comprehensive testing, and foot-dragging on promised safety measures. It's ridiculous that the city/county are being forced to mitigate the downstream effects of this doomed-from-the-beginning plan, but the "run it like a business" university administration is a lost cause.
[1] https://www.bouldercounty.org/families/disease/covid-19/covi...
As for "pessimistic", well, I'd just say that the facts don't care about your feelings. Powerful institutions are (generally speaking) violent and uncaring towards those without power; ignoring that fact does us all a disservice.
An abstract machine is a formalization of the concrete semantics of a programming language, and we'd like to be able to "lift" that concrete semantics to an abstract semantics: a finite (and therefore computable) over-approximation of program semantics.
However, the concrete structures of an abstract machine (most notably continuations) are themselves potentially infinite, so you can't just build a "structural abstraction" by applying the abstraction function pointwise over concrete structures -- the resulting abstraction is infinite and thus static analysis may diverge.
That's where this paper comes in: its key insight is that, by store-allocating continuations and bounding the number of store addresses, you can finitize an abstract machine such that structural abstraction works out nicely while preserving the underlying semantics.