type systems – What are the problems of subtyping?

I’ve heard often that Subtyping breaks some important and useful properties: many nice innovations developed by pure programming language researchers can’t be brought to Java or C++ because of subtyping. They say that the language Rust avoided Subtyping for this reason.

Is such a claim correct?

What are some cool things that cannot be applied to languages with subtyping?

Is any language offering Subtyping completely cursed and incompatible with a lot of cool features? Or only the pieces of code that use subtyping are incompatible?

Could you try to explain what it means to someone coming from C++ with little theoretical knowledge?

I searched for explanations and found:

How the task is divided between multiple cores to perform in multiprocessing systems?

I am trying to find how single task is divided between two cores? what are the methods makes them work at the same time without interfering with each other?

tls – Should I redirect http request to https from my system’s application or from DNS or other?

I want to create a web server that does redirects HTTP to HTTPS. What is the simplest method to do this but also secure? Should the DNS handle this? (For example, Route53)

I used to do this with my app built from Node/Express but now that I am using a compiled language, I want to be able to do this by hand instead of relying on a framework.

If I configure DNS to redirect http to https, is that more secure than the server program? (My thinking here is that since the server never sent a response, the potential attacker’s req never arrived and thus has no message to receive.)

Would it matter which DNS does this? (For example, if you purchased your domain from domain.com but your server is on AWS linked through Route53?)

lo.logic – Are there “typical” formal systems that have mutual consistency proofs? How long a chain of these can we build?

No, this cannot happen, although it’s a little bit trickier than one might expect to prove this!

First, a miniature result:

Suppose $T,S$ are computably axiomatizable theories in the language of arithmetic, each containing the theory $ISigma_1$, with $Tvdash Con(S)$ and $Svdash Con(T)$. Then $T$ and $S$ are inconsistent.

If you haven’t seen $ISigma_1$ before, the only points you need to know are that it is finitely axiomatizable, strong enough for Godel’s theorems to be applicable, and self-provably $Sigma_1$-complete. Note that neither of the better-known arithmetics $mathsf{Q}$ or $mathsf{PA}$ will suffice: $mathsf{Q}$ doesn’t prove its own $Sigma_1$-completeness since it lacks induction, and $mathsf{PA}$ isn’t finitely axiomatizable.

PROOF. It will be enough (by symmetry) to show that $T$ is inconsistent.

Since $ISigma_1$ is finitely axiomatizable and proves its own $Sigma_1$-completeness, we have that $T$ proves “$S$ is $Sigma_1$-complete:” just verify in $T$ an $S$-proof of any single sentence axiomatizing $ISigma_1$. Consequently, $T$ proves the sentence $neg Con(T)rightarrow (Svdash (neg Con(T)))$.

On the other hand, since $Svdash Con(T)$ and $T$ is $Sigma_1$-complete we have that $T$ proves $Svdash Con(T)$. Putting this together with the above paragraph, we get a $T$-proof of “If $T$ is inconsistent, then $S$ proves $Con(T)wedgeneg Con(T)$” – that is, a $T$-proof of $neg Con(T)rightarrowneg Con(S)$.

But since $Tvdash Con(S)$, this gives a $T$-proof of $Con(T)$ – so $T$ is inconsistent.

The above can be improved, however.

First there’s the issue of generalizing beyond $n=2$. This isn’t very interesting though, since it’s clear how to proceed: simply iterate the above idea by applying “provable $Sigma_1$-completeness” over and over again.

More interestingly there’s the language issue: $mathsf{ZFC}$ for example is not a theory in the language of arithmetic, so the above result doesn’t immediately apply to it. This can be handled via the notion of an interpretation. Basically, a theory $A$ interprets a theory $B$ if there is some tuple of formulas $Phi_A$ in the language of $A$ such that for each sentence $varphiin B$, the theory $A$ proves that the structure defined by $Phi_A$ satisfies $varphi$. (Think about how $mathsf{ZFC}$ implements arithmetic via the finite ordinals, for example.)

Via interpretations, we can generalize the argument above to arbitrary languages. Combined with the generalization past $n=2$ above, this gives the stronger result:

Suppose $T_1,…,T_n$ are computably axiomatizable theories, each of which interprets $ISigma_1$, such that $T_1vdash Con(T_2)$, $T_2vdash Con(T_3)$, …, $T_nvdash Con(T_1)$. Then each $T_i$ is inconsistent.

The most difficult part here is being precise about what “$Con(-)$” should mean in each of the relevant languages (basically, we just “work along interpretations”).

The final improvement to be made is with respect to the base theory. $ISigma_1$ can certainly be pushed down substantially without changing the argument, but this doesn’t get us all the way to $mathsf{Q}$. So – dropping back to a more manageable level of generality along the other axes – we’re left with a natural question:

Can there be two computably axiomatizable consistent theories $T,S$ in the language of arithmetic containing $mathsf{Q}$ such that $Tvdash Con(S)$ and $Svdash Con(T)$?

If memory serves the answer is still “no,” but I don’t immediately see the proof. (Note that at this point we really should be careful about what specific consistency predicate we’re using – there are certainly easy modifications of the standard consistency predicates which make things go through nicely, basically by restricting attention to a “tame cut” of the natural numbers, but I’m not sure if those modifications are necessary.)

operating systems – Can the sandboxing technique prevent a buffer overflow attack?

Stack Exchange Network

Stack Exchange network consists of 176 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Visit Stack Exchange

Ordering Multicasting in Distributed Systems

We know that Causal ordering in ordering multicasting implies FIFO ordering. But does FIFO ordering implies Casual Ordering?

Why do we need hashed page tables for Paging in Operating Systems?

I understand that we might need hierarchical paging to handle page tables with sizes greater than the size of one frame, but what is the use of Hashed Page tables then? I would understand if we were storing page-numbers and mapped frame numbers as $key-value$ pairs, because then hashing would make the process of accessing a particular $key-value$ pair much faster but can’t we just store the base of the page table and add the virtual page number, go to that index of Page Table, and get the frame number anyway?

website – Is there any better alternative to Siteglide’s Design systems?

I find their Figma templates little clunky and rigid. Also they have very limited designs if you compare them to the existing design systems like Mailchimp or google material design.

Does anyone have any better alternative? My end goal is to reduce the development costs and increase the efficiency.

systems of equations – Set of solutions for given inequality

Given the matrix $Ainmathbb{R}^{ntimes n}$ with all eigenvalues inside the unit circle and the symmetric positive definite matrix $Pinmathbb{R}^{ntimes n}$ satisfying $ APA^top-P+I=0 $, I need to find the set of solutions $S$ for

S P^{-1} S^top + AS^top + S A^top leq 0

It is obvious that this set of solutions is nonempty since $S=0$ satisfies the above relation. Also another trivial solution is $S=-A P$ as well as $S= -alpha v v^top$ for some values of $alpha>0$, where $v$ is an eigenvector of $A$. However, I wanted to see if there is any more general form of the solution $S$.

ds.dynamical systems – Henon Attractors and Markov paritions

Consider Henon attractor $Sigma$ for $f(x,y):=(1-1.4x^2, 0.3x)$

Is there a proper Markov partition (countable) i.e.

$$Sigma=bigcup_{i}Sigma_i, $$
$$mathring{Sigma_j} bigcap mathring{Sigma_i}=emptyset, text{ and } gamma^u(f(x))) subseteq f(gamma^u(x)) text{ for any }x in Sigma.$$


$$text{ where } Sigma_i text{ a rectangle formed by a family of unstable manifold } gamma^u text{ and stable manifold } gamma^s, gamma^u(x) text{ means an unstable maifold contaning }x.$$