On Two Views of Computation in Computer Science - <AUTHOR> https://pressron.wordpress.com/2016/08/30/what-we-talk-about-when-we-talk-about-computation/ <comment><USER2> > _You're free to think about computation as acting on bits… but for those > bits to do us any good, they have to actually represent something (e.g., > data structures)._

I suspect this is a case of confusing epistemology with ontology.

Galaxies are ontologically composite in that they're the highest holonym in the supervenience hierarchy [0]. Atoms are ontologically fundamental in that they're the the lowest meronym in the supervenience heirarchy.

Galaxies are epistemically abstract in that the notion of galaxy is far removed from everyday experience. Atoms are _also_ epistemically abstract in that the notion of atoms are also far removed from everyday experience. What's epistemically fundamental are the immediate objects of our everyday experience, like chairs and food. (My impression of Zen is that it advises to focus more on things like chairs and food [1].)

[https://www.xkcd.com/435/](https://www.xkcd.com/435/)

In the xkcd, which is more "fundamental", Math or Economics? Well, it depends. Likewise, what's more "fundamental", bits or ADT's? Well, it depends.

[0] powers of 10: [https://www.youtube.com/watch?v=0fKBhvDjuy0](https://www.youtube.com/watch?v=0fKBhvDjuy0)

[1] [http://www.itsokblog.com/2011/01/wash-your-bowl-zen-of- mothe...](http://www.itsokblog.com/2011/01/wash-your-bowl-zen-of- mothering_3089.html)

<comment><AUTHOR> Well, in this case all models are quite abstract, and there's a very real computational complexity difference between them. The key, if I were to use your way of presenting the issue, is the recognition that some epistemological abstractions are more computationally costly than others. So it's true that you can choose either representation as a foundation, but the representations objectively and radically differ in their computational complexity.

<comment><USER2> The key is to recognize how it's not just that TOP and TOC both measure X with different models. It's that TOP measures X while TOC measures Y.

It's as if we claimed Spell Checking were as complex as Natural Language Processing because they were both called "linguistics". Yes, they both abstract over language. But the primitives of Spell Checking are _glyphs_ while the primitives of NLP are _morphemes_. Glyphs don't exhibit the same patterns as morphemes. Which is why Spell Checking uses a Trie while NLP uses a Matrix. Debating whether glyphs or morphemes are "more fundamental" is a distraction.

Likewise, bits don't follow the same patterns as ADT's. Calling both _the study of bits_ and _the study of ADT 's_ "Complexity Analysis" is misleading, which I believe is what Pressler was getting at. But we've put bits and ADT's in the same bucket for the entire history of computing, because the Church Turing thesis (i.e. anything a TM can do, lambdas can do too) lead us to believe Turing and Church were studying the same primitives.

<comment><AUTHOR> What I was getting at in the article is that:

1\. TOC and TOP ask different questions.

2\. The disparity of the computational complexity involved in the two classes of models is so great, that it is objective proof that they represent two distinctly different things, and therefore comparing them directly is meaningless. That a jet and a bicycle require vastly different amounts of energy to power is conclusive and objective proof that completely different tradeoffs must be involved in choosing them.

</comment></comment></comment></comment><comment><USER3> I think mathematicians would call this "representation theory." This is the whole question of do we think of a calculation as syntax, or can we represent this syntax as a "dynamic", or action; something that is being moved around or transformed.

Some people really are driven to just calculate stuff (pushing language itself around), and others seem to want to know "what does it mean?" Ie. what are the representations of this language. Logicians call this semantics: it's a model for the syntax.

I'm a theoretical physics grad student, and see plenty of this. Most physicists seem to just want to calculate stuff, and don't care where the symbols "live". For me, a calculation is rarely enlightening. I want the context, the type theory that tells me how the pieces talk to each other.

<comment><USER4> I think you've got an interesting point, and I'd like to add to it a bit and refine/correct it a bit.

First off, minor thing, but as Jeremy has pointed out, your terminology is wrong; "representation theory" means something else. You seem to mean something more like "model theory".

But anyway -- I'm a mathematician, and I've noticed something like this too when I've dealt with physicists or their writings. But before I discuss physicists, let's discuss mathematicians, because I think you've mischaracterized them a little.

(Note, all claims here are just based on my experience.)

You talk about considering syntax vs. considering the different models of the syntax. But most mathematicians, unless they are logicians or set theorists or something, don't take either of those views. They take the Platonic view -- they're discussing a world of mathematical objects; the statements just describe it. They're not considering the statements as primary and then considering multiple models of it, they're considering the one true world of mathematical objects and describing it with statements (which might have other models, but who cares). This point of view breaks down somewhat when you have to deal with things like the continuum hypothesis and such, but that sort of thing doesn't really come up in ordinary mathematics.

(Note though that taking the Platonic view does not necessarily mean taking the "theory of programming" perspective the article discusses. I mean, I wouldn't take Aaronson's view, that computation is prior to everything else; that's pretty incompatible with it. But to my mind, computation is fundamentally about finite strings over a finite alphabet. Talking about computation with higher types -- where the Church-Turing thesis can fail -- as though it were, well, _computation_ , feels really weird to me.)

Also, another terminological correction: Most mathematicans don't care about type theory. They care about _types_ , at least implicitly, though they might not use that term; but they are not going to consider types as an object of study in and of themself. But yes -- when you want to understand a mathematical object, one of the first questions is, "What sort of object is that?" or "What space does that live in?"

So anyway -- yeah, physicists. I've noticed this too, and I don't know what to make of it. Where physicists don't tend to fully specify their, let's call it an ontology, and have a hard time answering questions like "What sort of object is that?" or "So that's a function from what to what?" Where they don't seem to properly distinguish between a mathematical model or description, and a method of calculation that's useful when working with that model or description. (I have so often failed to get an answer to, "So are virtual particles an actual physical phenomenon predicted by the quantum field theory, or are they just part of a useful method of calculation for working with quantum field theory?") Where they seem to care primarily about methods for getting numbers out, rather than building full, coherent models.

It's all weirdly instrumentalist, which to me seems backwards from what you'd expect -- like, mathematical Platonism is a philosophical question, but the physical world is definitely real! And sure, maybe the bits we can't measure are more of a philosophical question too -- especially since one can quite possibly come up with multiple isomorphic usable models for the laws of physics, whatever they turn out to be -- but still, mathematicians have no trouble just treating their mathematical objects as real things to be reasoned about, so this kind of instrumentalist view among physicists seems weird to me.

I hadn't even considered the possibility that they were thinking "syntax- first", so to speak! But I guess that does kind of sum it up pretty nicely. Bugs the hell out of me, though. Makes it pretty difficult to talk about the math of their theories with them, too.

<comment><USER3> > your terminology is wrong; "representation theory" means something else. You > seem to mean something more like "model theory".

I really do mean representation theory, in the widest sense of the word. Wide because I am trying to make connections here, not distinctions.

So for instance, of course group representations. On the one hand there is an abstract group multiplication, and on the other side we are representing this as a geometric action.

The same thing goes for "bigger" gadgets, lie algebras, hall algebras, etc. All kind of algebraic objects that we can define abstractly (syntactically) but then lo! it is actually represented by some kind of (geometric?) action.

And then in a more logical vein you have the lattice type theories. Boolean algebras, heyting algebras. These things have topological representations (or is it functions on topological spaces). And then to denotational semantics of lambda calculus. And it's all kind of a syntax on one side, and a semantics on the other.

I don't know much about models of set theory, but I'm assuming these also involve a kind of "active" representation of syntax. I would also include things like algebraic topology, topological quantum field theory. These are all "functors" which act to represent an algebraic gadget in a more dynamic way (i'm possibly over-generalizing here.)

Anyway, there's no concrete definition for what I mean by a "representation" so that's why i gave some examples. It's quite mysterious imho.

> So anyway -- yeah, physicists.

Well, it's easy to criticize physicists, but I also think mathematicians are guilty of this. Ok, so they define their calculations rigorously (not always), but then it's gloves off and away we go! I've come to realize that the whole program of categorification is an attempt to bring more context to these calculations (this is what I would call type theory for mathematics btw.) And most mathematics is written down as calculations, without this context. Probably because it's much harder to categorify everything. The simplest example of what I mean is this: "why keep track of a (finite) set when you can just say how many elements are in the set?" And so on. I really do think that alot of mathematicians are just as guilty as physicists of the "shut up and calculate" attitude. But, they are certainly much more humble :-)

<comment><USER5> What you're describing sounds more like homology theory, where there is an abstract set of concepts (short exact sequences, etc.) which become different theorems in different contexts. But, unless I'm mistaken, most of the time these are closer to unifying foundations, or starting points, from which the special features of each model allow you to say more beyond the abstract framework. So sure you can get some general category-theoretic theorems, but saying the specific model is useless (as the Language folks say about Turing machines) is ludicrous.

</comment></comment></comment></comment><comment><USER6> This is an interesting article, but I'm still fairly confused about the notion that is made

>Harper's attack on the utility of machine models and lack of modularity is tantamount to an architect saying to a chemist, "both of our disciplines concern the arrangement of molecules, yet my discipline is superior, as yours doesn't even have the modular notion of a room!"

But wouldn't the whole point be that a chemist, seeing the room as nothing less than an abstraction, can also understand the room through their given framework? Much in the same way that, for any computational model, we can think of a TM with an Oracle tape, or some similar IO model, that has the same computational power as any defined language?

I'm afraid that I thought I understood the distinction at first: where those who support CT view computation as a fundamental case (e.g. every other mathematical 'primitive' can be derived from a computation with the appropriate oracles[1]) and and the TOP view which sees mathematical foundations as the main case, and then sees computers as being an abstraction of functions in some sense, such that one can construct a calculus of these functions which constitutes a language.

Did I get this all wrong? I'm afraid I still don't understand the main distinction to be honest. It seems that both parties are going around in circles on exactly the same thing, but assuming different axiomatic systems and showing that each is equivalent to the other.

[1] For example, with no oracles, we receive all of constructive mathematics, etc.

<comment><AUTHOR> You can translate and transform many things to many others. The important question is what is the computational complexity of the transformation? If it is large, then the two things are very different.

As Scott Aaronson once said, waterfalls could be viewed as playing chess, but as the complexity of the translation from the "waterfall language" to a chess language understandable by humans is as great as the complexity of an actual chess-playing program, all the work is done in the translation.

So the question you should be asking is where the complexity is being spent and on what.

<comment><USER6> Wait, but I thought the question being posed wasn't about the computational complexity of any model but about the power of a given computational model relative to another (e.g. the subject of the CT thesis).

Even if we're talking about just computational complexity, if we allow Turing machines with arbitrary oracles, or (equivalently) we allow arbitrary mathematical constructions in languages, I'm still unsure as to why the complexity matters.

W.r.t the waterfall case. Sure, I agree with that statement, but I'm unsure as to how it plays into the final case---the question isn't about a specific model performing a specific task, but about a model being able to completely replicate another in terms of computational power. Anything I can do in a language (with some functions) I can do in a Turing machine with the appropriate oracles; and conversely, anything I can do in a Turing machine with some given oracles, I can do in a language.

<comment><AUTHOR> Both models are equally powerful in the things they compute in terms of the Church-Turing Thesis. The TOP view also has other consideration. My point in the article was not to settle the debate on Aaronson's blog but to show that language models and machine models are objectively and inherently so different from one another that comparing them in terms of programming concepts (like types) is meaningless.

<comment><USER7> And it seems that most of the "my way is superior to yours" is based on setting up strawmen of "yours" to make it be addressing the same questions as "mine".

<comment><AUTHOR> Yes, but it goes a little further. I can't say my way is superior to yours if my way means solving a harder task _and_ paying market price for it.

I got the leather seats because I chose to pay full price for them. That they come as a standard option with the car because the car is more expensive is not an argument. You can choose to pay the same difference in price and have them installed in your car, too.

Whether those leather seats matter or not is no longer an objective question but a question of values, and here is where caring about completely different values is the point.

</comment></comment></comment></comment></comment></comment><comment><USER8> The author contends in the article's abstract that machine models are "self- contained" whereas "language models" (not clearly defined, but meant to encompass at least an untyped lambda calculus) are not. But both can be viewed as a state plus a well-defined set of rewriting rules, so I suspect that the article is struggling to make what is really a distinction without a difference.

<comment><AUTHOR> Author here.

> But both can be viewed as a state plus a well-defined set of rewriting > rules, so I suspect that the article is struggling to make what is really a > distinction without a difference.

1\. I state that the untyped lambda calculus is, indeed, a borderline case, and is a simple rewriting system which, in turn, is a special case of a nondeterministic abstract state machine.

2\. That many things are abstract state machines does not mean that the computational complexity required to validate whether what you have is a well- formed description is similar.

3\. That complexity difference is absolutely huge -- zero for the machine models vs. exponential to undecidable for the typed language models. It is hardly a struggle to draw the conclusion that the two are objectively completely different classes.

Also, I gave a list of machine and language models. The latter group consists of the process calculi and the lambda calculi.

<comment><USER9> Could you encode all untyped lambda calculus expressions by just numbering them and writing the number as the string of bits?

Maybe this enumeration is the "external collaborator" in this case, but it's a very simple one.

<comment><USER10> Inside the lambda calculus, the only thing you can do with a lambda abstraction is apply it.

And one thing you can't do using your numbering scheme (which is basically a Gödel numbering) is establish whether two syntactically different functions are extensionally equal (under some fixed reduction strategy).

</comment></comment></comment></comment><comment><USER11> _It's really weird that the Church-Turing thesis, which is ridiculously robust at first order, falls apart so comprehensively at higher type._

A statement like that makes me feel like Neel Krishnaswami does not understand the Church-Turing thesis _at all_ (what does the Church-Turing thesis even mean at a "higher type"), but considering that this person has significant experience in this field, much more than I do, I am just going to assume that it is me who does not understand until I read up on this exactly.

<comment><USER10> The Church-Turing thesis is a statement about which functions of type `nat -> nat` are computable, either in the lambda calculus or using Turing machines. This completely disregards:

(0) Computational complexity. Neither the lambda calculus nor Turing machines were invented to answer questions of computational complexity.

(1) Functions at types other than `nat -> nat`. Curiously enough, programming in the real world is seldom about evaluating functions of type `nat -> nat`.

<comment><AUTHOR> > The Church-Turing thesis is a statement about which functions of type `nat > -> nat` are computable, either in the lambda calculus or using Turing > machines.

This is how Krishnaswami frames things. From the TOC perspective, there is no such thing as functions at all. Computations consume and produce strings. Both Church and Turing explain how those strings can encode the natural numbers (there was no talk of types by either). Interpreting a computation as one computing functions on the natural numbers or any other set is an entirely interpretive activity that is external to the computation itself.

<comment><USER12> How then do _you_ state the Church-Turing thesis? I note that the Wikipedia page claims that Church and Turing themselves used the word "function":

[https://en.wikipedia.org/wiki/Church%E2%80%93Turing_thesis#S...](https://en.wikipedia.org/wiki/Church%E2%80%93Turing_thesis#Statement_in_Church.27s_and_Turing.27s_words)

<comment><AUTHOR> They do use the word function, just not in terms of the language itself, but in the same sense of saying that a falling apple integrates the function from its mass to acceleration; it's a human interpretation of the encoding. I would state the Church-Turing thesis like so: a universal computation model can compute anything any physical machine can. As Hodges says in one of the links in the article, this is how Church and Turing themselves understood it. How would I define "anything"? As a function on any countable set -- the natural numbers, would do -- and I would explain what it mean to compute a function: pick a function, pick an input element, pick a finite representation for the input and output; if a physical machine can compute the output representation from the input representation, so can a universal computation model.

I could choose a function between _any_ two countable sets, e.g. (Nat -> Nat) -> (Nat -> Nat): pick a representation for the input and output and all models can compute the same functions, and those are the functions that machines can compute. They differ in abilities regarding representation _within_ the model, but as the language models' representation require very significant computational work, I'd expect their representation to do more: they're paying for it.

A C compiler works hard, so you'd expect it to provide you with a representation more suitable to your wishes than machine code. It's just that as a compiler like C translates a "meaningful" language to a machine encoding, everybody notices the work. The language "computation" models work in a vacuum, so I just pointed out that even though they don't translate anything from one representation to another, they still have to pay for their natural representation.

<comment><USER13> _a function between any two countable sets, e.g. (Nat - > Nat) -> (Nat -> Nat): pick a representation for the input and output_

There isn't a TM-suitable representation for things of type (Nat -> Nat). No matter how you _try_ to encode a Nat->Nat as a Nat (or a bitstring, if you prefer), you're going to screw up equality (which means you're actually encoding _some other type_ ). You'll map two unequal functions to the same Nat, or (more likely) map one function to multiple unequal Nats. This is the difference between how lambda calculi and Turing machines handle higher-order things: A Turing machine can always inspect the "internals," so you need an actual _bijection_ from functions to strings, whereas lambda calculus hides the internals, so it's safe to map one function to multiple syntactic representations.

<comment><AUTHOR> If you take the normal mathematical definition of a function as a mapping from one set to another, pick two sets, pick a representation and all models can compute the same mapped elements. Tell me what your (higher-order) function is — i.e., what output element it maps to what input element — and a TM would compute the exact same outputs. That it can't _internally_ "reason" about those functions is obvious, but, as I showed, that ability comes at a cost. You could build, say, a Haskell compiler that would pay that cost and translate the language to a machine representation (or, speaking more abstractly, a TM could simulate, say, System Fω — at a computational cost), or you can use an abstract language model without any underlying machine, but the same cost must be paid regardless.

This shows that the concept of a type requires actual computational _work_ rather than just a matter of "free" perspective. Your mere presentation of a function as an inhabitant of a type creates a computationally harder problem than presenting a function as a mapping between sets. Put differently, when a typed language model computes a function (Nat -> Nat) -> Nat, it does more work, and solves a harder problem than necessary to compute that function in the normal set-theory sense. You can choose to solve that problem on a TM by simulating type checking if you like, but you can't compare "compute a function in the set-theory sense" and "compute a function in the type theory sense", because those are two different problems with two radically different computational complexity costs. You can decide to do that extra work or not (you may want to because you gain benefit from it), but you can't compare a model that always does — and pays handsomely for it — with one that doesn't.

Otherwise, I could create a language model that solves all NP problems in polynomial time by defining my language as requiring a proof certificate with every input problem, which my model would then check in polynomial time. No one would believe my language actually really solves a computational problem: it simply pushes the difficulty to the collaborator.

Equality is also an internal question. Define any relation between two sets (your definition of equality), and all models would be equally able (or unable) to decide it.

<comment><USER10> > and solves a harder problem than necessary to compute that function in the > normal set-theory sense

People who use set theory as their foundations impose on themselves the even harder task of making sure their mappings are coherent w.r.t. whatever notion of structure they want to work with, i.e., homomorphisms in a category of interest.

> Otherwise, I could create a language model that solves all NP problems in > polynomial time by defining my language as requiring a proof certificate > with every input problem

No, this is wrong. Changing the input type means that you are _not_ , in fact, solving the original problem.

<comment><AUTHOR> > People who use set theory as their foundations...

Let's not get into this old debate because we'll never get out of it. Suffice it to say that it that there is no doubt that Turing and Church (and Gödel and von Neumann) used set theory as their foundation, and when they said "function" they meant a set-theoretic function, namely a mapping from a domain (set) to a range/co-domain (set). If by "function" you mean a type-theoretic function then you're talking about a computationally harder problem, as you need to compute the underlying set-theoretic function _and_ check a proof. You can certainly ask a TM to simulate a type checker and compute a type-theoretic function. There's actual work involved, and someone must do it. You cannot say that your formalism gives it to you for free, or you'll have a formalism that proves things for free, which is impossible.

> Changing the input type means that you are not, in fact, solving the > original problem.

Exactly! But that is precisely what you do when you interpret "function" to mean a "type-theoretic function", and solve a different problem. Any work that needs to be done under the normal meaning of "function" also needs to be done in the typed formalism. If you need to ensure/prove something, there is work and computational complexity involved. Pushing it to a collaborator doesn't make it disappear (let's call this the law of preservation of computational complexity). Someone has to do it, and in no model does it suddenly become free. It's perfectly OK to say that you start counting _after_ much of the hard work is done, but in that case you need to say that your model requires upfront work, and therefore cannot be compared to models that don't. That's my whole point.

<comment><USER10> Of course, proving things, that is, doing mathematics requires work. But at least it's work that produces a useful result, unlike carrying out computations without paying attention to their meaning. (By the way, this meaning _always_ exists, even if you don't particularly care about it.) And the best moment to study the meaning of a computation, in the sense of minimizing the amount of long-term work, is as early as possible, which is exactly what types force you to do.

<comment><AUTHOR> But this is now a programming discussion, not a computation discussion. Also, I don't think it's right to declare things "useful" only if they're useful to the particular problems you're trying to solve.

BTW, any logical formalism forces you to pay attention to meaning; choosing to encode the logic in types has advantages and disadvantages, but it is not at all the only way to logically describe a program.

<comment><USER10> > Also, I don't think it's right to declare things "useful" only if they're > useful to the particular problems you're trying to solve.

Pray tell, what's the use of a computation without paying attention to its meaning? My use case is simply "knowing the meaning as early as possible", and there ought to be no discussion that this should be everyone else's use case as well. Nobody performs a computation without some sort of expectation about the relation between the inputs and the outputs.

> BTW, any logical formalism forces you to pay attention to meaning

I never said types are the only way. For instance, you could use Hoare logic, but it's notoriously more difficult to use, precisely because it gives programs no a priori meaning.

<comment><AUTHOR> > Pray tell, what's the use of a computation without paying attention to its > meaning?

First, I don't think that the only way to assign meaning to computation is by _formally_ assigning meaning to the syntactic components that comprise its program, as written in some human-readable language. Most of the relevant meaning is in human interpretation of the input and output or the sensors and actuators. Components' meaning may be stated informally. I am not aware that formal meaning is the only valid meaning. People wrote the software that landed men on the moon in assembly; that was pretty meaningful. I believe this is still the prevailing view in computer science.

Second, you keep identifying the notion of computation with the notion of a program written by a person. The theory of computation, from its earliest days -- by Turing himself -- has studied computational phenomena in neural networks, genetics (Turing was a pioneer of both NNs and genetic algorithms) and quantum phenomena. Some of the greatest achievements in CS are not specifically related to software (I count at least 20% of all Turing awards).

> For instance, you could use Hoare logic, but it's notoriously more difficult > to use, precisely because it gives programs no a priori meaning.

Or TLA+, which makes types notoriously more difficult to use by comparison.

<comment><USER10> > First, I don't think that the only way to assign meaning to computation is > by formally assigning meaning to the syntactic components that comprise its > program, as written in some human-readable language.

Please suggest alternatives - that actually work.

> Most of the relevant meaning is in human interpretation of the input and > output or the sensors and actuators.

The _relation_ between the input and the output. This can only be stated formally.

> Components' meaning may be stated informally.

That leads to disaster very quickly.

> I am not aware that formal meaning is the only valid meaning.

Well, I am. Too much nonsense has been said as a result of not formalizing things.

> Second, you keep identifying the notion of computation with the notion of a > program written by a person.

No. Even if a computation "arises in nature" (which is just your way of looking at things, actual physical phenomena is what you can measure, plain and simple), the only way to make sense of it is to write a program that reproduces the computation. This is how scientific theories work.

> Or TLA+, which makes types notoriously more difficult to use by comparison.

Some type systems are more difficult to use than others, and the type theory community is definitely guilty of not paying enough attention to usability, but I don't see how model checking has a higher power/cost ratio than sensibly designed type systems. Which tool satisfies the following criteria?

(0) Compositionality: you can understand a large system by studying its parts in isolation.

(1) Handles higher-order constructs (first-class functions, objects) gracefully.

(2) Stops you from saying nonsense as early as possible.

I rest my case.

<comment><AUTHOR> > Please suggest alternatives - that actually work.

AFAIK, the only languages that fully express the computational meaning formally with types are the dependently typed ones. AFAIK, there has been exactly one non-trivial real-world program written in such a language, and its author wasn't too pleased with the process (I'm referring to CompCert and Xavier Leroy). _Every_ other program in every other languages has most of its meaning expressed informally, in the mind of the programmer. Unless you believe that no programs work, then nearly all programs that do express most of their meaning informally.

> Too much nonsense has been said as a result of not formalizing things.

Formalizing things doesn't imbue them with good sense. You can state plenty of nonsense formally. The only thing you're guaranteed is that it's _consistent_ nonsense, and, as someone said on one of my favorite TV shows, "The sole virtue of the ineffectual is consistency".

> Which tool satisfies the following criteria? ...

TLA+, and far more elegantly and simply than any typed language you've seen.

<comment><USER10> > AFAIK, the only languages that fully express the com meaning formally with > types are the dependently typed ones.

I said "formally", not "with types". I firmly believe in using the right tool for the job, and some things are best handled with manual proofs. As helpful as types might be for computer-generated proofs (type inference), I'd rather carry out my manual proofs using good old-fashioned predicate logic. Some proof techniques still need to be backed up by type structure, though (e.g., induction over datatypes).

> _Every_ other program in every other languages has most of its meaning > expressed informally, in the mind of the programmer.

Unfortunately, I can't read minds. I can only read proofs that have been explicitly written down.

> Unless you believe that no programs work, then nearly all programs that do > express most of their meaning informally.

My definition of "work" is "works in all cases". No bugs. No unforeseen cases.

<comment><AUTHOR> So you're specifying an empty set. There has never been a large program that's been completely formally proven -- not a single one -- and there are therefore no methods that work. The small programs that _have_ been mostly proven, took such a great effort, that their creators wouldn't say that the approach "works" in any widely applicable way.

<comment><USER10> Yep, that's the state of the art. It means that more human work has to be done on making it easier to write programs that work.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER14> I'm not really sure I completely understand where the conflict is here. Even in the "machine model" the church-turing thesis "fails spectacularly" once you start adding in unreasonable things like halting oracles. TM+Halting oracle > TM. It's just that the TM+halting oracle doesn't exist in our universe, even though you can define it mathematically.

When building a language, it's similarly easy to introduce "unreasonable" things that either require huge complexity to translate to the machine representation or might even be completely unrealizable in the real world! Even ignoring higher types, compiling a C++ program requires a potentially unbounded amount of work because templates are a turing-complete functional programming language. As stated in the article, just determining if a C++ program is valid is undecidable!

Nothing stops you from designing these languages, but you can't say that Church-Turing fails until you consider also the systems required to actually execute these languages in the real world. If you can't, then your programming language is perhaps an interesting mathematical abstraction, but just as useful ultimately as that TM+halting oracle model of computation.

<comment><USER5> > TM+Halting oracle > TM

Why is this a failure of the Church-Turing thesis? The Church-Turing thesis says, "Anything that can be computed in our reality (i.e. by a human, ignoring resource constraints) can be computed by a TM." TM+Halting oracle doesn't satisfy the hypothesis.

<comment><USER14> It's not a failure of Church-Turing. The whole point of my comment is that you can easy construct more powerful models that are "unreasonable" because they don't exist in our universe. It's the same for programming language models.

</comment></comment></comment><comment><USER15> The article refers to one quora answer where the author says - "The machine- based models offer no notion of composition of programs from parts". The instructions are the parts of the so called machine model, isn't sequencing of those instructions and control flow instructions are nothing but composition?

<comment><USER13> It's a very impoverished form of composition if the only things you can really compose are the absolute primitives, rather than allowing you to compose things that are themselves composed. When you "program" with Turing machines, you don't have a way to take a section of "code" and paste it into another, larger program. You'll have to deal with two pieces numbering their states the same, overwriting each other's tape data, etc. If you have two Turing machines that solve separate pieces of the problem, you know there exists a single machine that does both things, but nobody actually goes and constructs that machine. Instead, they just mention its existence as justification for writing "do this; do that;" in a higher-level machine description.

<comment><USER15> I think the problem can be defined as "Composition without isolation", each composed sequence of instruction has this same global context (all of memory) to work with which can lead to problems.

</comment></comment></comment><comment><USER16> Honestly,

I think Aaronson is clearly and transparently correct about Church-Turing and higher types. Computation on higher types is just a higher-order construct having no more to do with computation as we understand it than other higher order constructs like Hilbert Spaces.

</comment><comment><USER17> Academia is feudal and thus no answer to this is about to become widely accepted. :(

<comment><USER18> Actually it's a bit more like 42.

<comment><AUTHOR> How is showing that two representations are fundamentally different because they objectively and radically differ in computational complexity open to interpretation?

<comment><USER17> It shouldn't be.

I'm skeptical of your parsing argument because the normal way to construct type theory terms is inductively in their "native" tree form, which is cheap. Looking at them as a formal language isn't so convenient.

As a PLer, I hope dependently typed langauges see wide use not because they are the one true foundation of everything, but because they are the richest lingua franca for every academic discipline to represent their ideas—I'm personally enamored of such theories as a foundation for math, but I don't know much about the theory of computation and I'm fine if others just see it as a tool.

Anyways once that happens and fields have distilled their intentions into precise models in the lingua franca, perhaps the walls between fields can be broken down and we finally grok each other's concepts.

<comment><AUTHOR> > their "native" tree form, which is cheap

It is _not_ cheap at all, as type checking can be arbitrarily hard, depending on the type system, and perform arbitrary computation at the "validation" stage. This is real, significant (and useful, depending on circumstance) computational work, that no formalism or representation can reduce (only hide, by pushing it over to the collaborator).

> but because they are the richest lingua franca for every academic discipline > to represent their ideas

I disagree. I strongly recommend you (and everyone) read this terrific essay by Lamport on a lingua franca for algorithms: [http://research.microsoft.com/en- us/um/people/lamport/pubs/s...](http://research.microsoft.com/en- us/um/people/lamport/pubs/state-machine.pdf)

Not only is TLA just as powerful as dependent types, it is _far_ simpler[1]. Lamport says that the reason PLers aren't interested in TLA+ is because it's so simple, so there's not much to write about it. You see plenty of papers about embedding all kinds of things (separation logic, cost models, concurrency etc. etc.) with dependent types, things that are so trivial in TLA+ that they're barely worth a mention. Ideas from Hoare logic, behavioral refinement, differences between notions of program equivalence from process calculi (trace equivalence vs. bisimulation) simply collapse into simple, familiar logic in TLA (the only thing missing is probabilistic reasoning).

Lamport wrote about his experience trying to publish a paper showing that specifying real-time systems with TLA is trivial (it's a matter of defining a time variable): [http://research.microsoft.com/en- us/um/people/lamport/pubs/p...](http://research.microsoft.com/en- us/um/people/lamport/pubs/pubs.html#real-simple) You can only write a few papers on a simple approach that solves many problems, but lots and lots of papers that show how to use complicated approaches to solve them.

A lingua-franca must be simple. TLA+ uses notation and concepts that are familiar to all mathematicians and all computer scientists, plus a couple of new concepts that can be learned in a few days. Dependent types (and intuitionistic logic) are almost as arcane today as they were decades ago, virtually unknown outside the circles of logic and PLT, each of them is a particularly isolated sub-discipline within math and computer science. That so many papers are written about dependent types is strong evidence that they _cannot_ serve as the lingua franca, and pretty conclusive proof that they cannot serve as the lingua franca just yet.

That PLers, as Lamport writes in his comment on my post, fail to see that Plotkin's SOS is an abstract state machine, and that some fail to see that computing a set-theory function and a type-theory function are two different computational problems with radically different computational complexity is further evidence that language models obscure rather than reveal.

Of course, as Lamport also says, real-world programming is very complicated, and so _programming_ languages are justifiably complex (and whether dependent types can help with that remains to be seen[2]). But that complexity is absolutely not required for the purpose of a lingua franca with clear and simple semantics (TLA's semantics are far simpler than _any_ programming language) for the purpose of specifying and analyzing algorithms.

Disclosure: I've contributed some code to the TLA+ project.

[1]: Not only do properties ("types") and algorithms share the same terms in TLA+, they are the same objects. This confuses some people to believe that TLA+ doesn't support higher-order algorithms, when, in fact, it becomes a non- issue. Instead of a parameter of a certain type, you have a concrete program that _is_ the type (e.g., the program that nondeterministically returns, say, any even integer).

[2]: I'm skeptical because I believe we're close to the "Brooks limit": [http://blog.paralleluniverse.co/2016/07/23/correctness- and-c...](http://blog.paralleluniverse.co/2016/07/23/correctness-and- complexity/)

<comment><USER17> I am curious what you think of math.andrej.com/2016/08/30/formal-proofs-are- not-just-deduction-steps/

<comment><AUTHOR> He mostly talks about proof assistants for general mathematical theorems, something I don't use, but in TLA+, proofs are of logical formulas, the steps are logical formulas (unlike in dependently typed provers), and a computation is just a (temporal) logical formula, so TLA+ already lets you incorporate computations into proofs, but the process isn't automatic. Then again, TLA+ isn't really designed nor used as a general theorem prover (though it certainly can prove general mathematical theorems) but as a tool to specify and verify algorithms.</comment></comment></comment></comment></comment></comment></comment>


On a Bahamas Sail, 8 Friends Get a Taste of Robinson Crusoe - <AUTHOR> https://www.nytimes.com/2019/12/16/travel/bahamas-exuma-islands-sailing.html <comment><USER2> They had to eat something.

<comment><AUTHOR> Reading the article, I thought of this contrasting quote:

"I could not forbear getting up to the top of a little mountain, and looking out to sea, in hopes of seeing a ship : then fancy that, at a vast distance, I spied a sail, please myself with the hopes of it, and, after looking steadily, till I was almost blind, lose it quite, and sit down and weep like a child, and thus increase my misery by my folly."

― Daniel Defoe, Robinson Crusoe</comment></comment>


iOS7 Will Slowly Kill Location-Based Services - <AUTHOR> http://thenewb.com/thenewb/2013/9/5/ios7-will-slowly-kill-location-based-services

<comment><USER2> "swiping upward to remove an app from the switcher completely disables that application as if it were uninstalled from the device"

I doubt this statement is true. Some technical resources would be nice.

<comment><AUTHOR> Quoting a rep at Apple:

If a user swipes up in the app switcher then the OS will not launch the app unless explicitly told to do so by the user. So no, SLC will not be launching the app, nor will silent notifications. The only thing that will launch the app at that point is the user tapping the icon. The intention here is that the user has expressed their choice of not having that app running any more for any reason, so we honor that.

In this situation, there's really nothing that you can do. The next time the user launches the app you can let them know that some of the data may be missing, although you really cannot tell whether there's missing data or not (i.e. you might have been killed by the OS in the background and the user may not have moved thereby not triggering any SLC notifications). My suggestion would be to gather the data you can within the policies of the OS and if the user has manually killed the app then respect that wish and don't do anything.

</comment></comment><comment><USER3> "As many know, there is a new "app switcher" in iOS7 that mimics the multitasking functionality of Android."

Apparently the author never knew about webOS.

</comment><comment><USER4> iOS 7 also has a feature that will automatically start apps based on the times of day that you use them. So even if users are constantly dismissing apps from the multi-tasker (which I don't think will happen) the apps that are used the most will constantly be switched back on.

<comment><USER5> AFAICT as a developer writing an app that uses the new background fetch stuff, it's also disabled if the user explicitly closes the app.

As a user aware of this behavior I'm a big fan of it, but I suspect it's going to be the source of some support headaches.</comment></comment>


Dell's 32-inch 8K UP3218K Display Now for Sale - <AUTHOR> http://www.anandtech.com/show/11220/dells-32-inch-8k-up3218k-display-now-for-sale <comment><USER2> Sometimes I feel like I'm the only person who is really excited about these resolution improvements. When the MacBook Pro Retina came out in 2012, the _only_ reason I bought it was because of the display. I had never used a Mac before then.

Going from 4K to 8K for a 32" monitor may seem like a small improvement, but it is a subtle sensory improvement that just makes using a computer more _pleasant_. Until displays reach 1/60th of an arc minute from standard viewing distances (roughly the discerning power of the human eye under assumptions on contrast), I will always want higher resolution.

Other than resolution improvements, it would be nice if someone would attempt an HDR light field display. This would ultimately lead to a monitor that is indistinguishable from a window.

<comment><USER3> Frankly, a 4K 32" monitor is quite crappy...4K works at 24" or so, but above that you begin to see pixels if you use it as a standard monitor (arms length) rather than a TV (a few feet away). 8K is fairly reasonable for 32", putting it in 200+ PPI area (279.73 to be precise), meaning it could be used as a real monitor...but...it's a bit big for me (27" is kind of a stretch already).

I would like to see OLED's at this size/resolution, which would accomplish something similar.

<comment><USER4>
      Frankly, a 4K 32" monitor is quite crappy..

The Apple Cinema display is 2560×1440 (1440p) at 27" and plenty of people use that. That was a pretty standard resolution for 27-30" screens before 4K became popular. Most people would find 2160p (i.e. 4k) at this screen size to be really nice.

<comment><USER3> Apple no longer makes or sales that, it is outdated tech. I'm so used to 200+ PPI now that when I had a 4K 28" monitor at work, I thought it was just not that good.

<comment><USER5> I just bought a P2715Q (27", 163ppi) and I really haven't noticed the difference from my 220ppi 15" MacBook Pro. I'm sure if I put them side by side and shoved my face into them I would notice, but practically speaking, 163ppi is pretty great.

<comment><USER3> If you are using Mac OS, font smoothing makes it really hard to tell. If you are using Windows, the difference is more apparent given a more sharp font rendering.

<comment><USER6> This makes sense. I've also had a P2715Q for more than a year and it looks retina to me, but I'm mostly looking at the (anti-aliased) text when determining that.

</comment></comment></comment></comment></comment></comment></comment><comment><USER7> Any engineers familiar with DSC 1.2 care to comment on how the required compression to support 8K@60Hz over DP 1.4 could presumably manifest undesirable artifacts (for lack of a better analogy) which would run counter to the reasons that would make this high-end display attractive from a productivity perspective? I initially thought this would be a vanilla lossless frame transaction, but that's apparently not the case. If imperfections aren't perceivable at 32", I'm curious how they'll visually manifest (if at all) as display size scales up.

Wiki[1] notes that DSC is _visually lossless_ per ISO/IEC 29170-2 test method, but I'm neither familiar with DSC nor the ISO/IEC standard. What are the practical implications of calibrating against a $200+ colorimeter accessory that Dell is so intent on adding to your cart?

[1] [https://en.wikipedia.org/wiki/DisplayPort#Display_Stream_Com...](https://en.wikipedia.org/wiki/DisplayPort#Display_Stream_Compression)

</comment><comment><USER7> Dell specifies[1] 87W (typical) to 125W (max), with 89.5W in Energy Star mode. Has anyone ballpark-estimated power requirement to _generate_ the video signals driving such a monitor?

Also, any idea what DP cable lengths will be pragmatically limited to at such a resolution?

P.S. The naivete of this type[2] of marketing tactic never fails to blow my mind away...as perceived from an _inferior_ Dell U2415.

[1] [http://www.dell.com/en-us/shop/dell- ultrasharp-32-8k-monitor...](http://www.dell.com/en-us/shop/dell- ultrasharp-32-8k-monitor-up3218k/apd/210-alez/monitors-monitor-accessories)

[2] [http://i.dell.com/das/xa.ashx/global-site- design%20WEB/2a9f3...](http://i.dell.com/das/xa.ashx/global-site- design%20WEB/2a9f39a0-0d5c-0c11-0730-f51153f16311/1/OriginalPng?id=Dell/Product_Images/Peripherals/Output_Devices/Dell/Monitors/UP_Series/UP3218K/pdp/dell- monitor-up3218k-pdp-03.jpg)

<comment><USER8> "Dell specifies[1] 87W (typical) to 125W (max), with 89.5W in Energy Star mode. Has anyone ballpark-estimated power requirement to generate the video signals driving such a monitor?"

I've never looked at LCD panel power usage before ... are those numbers high or low or ... ?

If I go to best buy and buy a 50" samsung 4k TV, what would that power usage be, roughly ?

(just trying to get a sense of comparison)

<comment><USER9> For comparison, my 10 year old Dell 3007WFP (30" 16:10 1600p monitor for similar market segment) is 147W typical 177W max. So 8x the pixels for ~60% of the power consumption after a decade of improvement sounds good. Shame it's 16:9.

</comment></comment></comment><comment><USER10> >It's worth noting that Raja Koduri, SVP of AMD's Radeon Technology Group, has stated that VR needs 16K per-eye at 144 Hz to emulate the human experience

This is tangential to this thread, but can anyone in here explain the state of the art in eye tracking? Actually rendering 16k quality for my peripheral vision seems insane to me, so I'm really interested in the barriers between today's tech and a good foveated headset.

<comment><USER11> I cannot possible believe that rendering at this resolution is necessary. Most VR users don't turn their eyeballs while wearing headsets, but opt to use controls to adjust their perspective. I've read several accounts of hacks developers have taken when rendering VR games, but one that has kept cropping up is reducing resolution of areas in the periphery.

While you certainly could use 16K displays for VR, I think it would be entirely unnecessary.

<comment><USER12> Most VR users don't turn their eyeballs right now because the field of view is pretty small.

</comment></comment></comment><comment><USER13> 16:9 is suboptimal for me. I usually like one extra display in portrait orientation for code and web pages.

My current 16:9 24" 4k display in portrait is too tall---have to move my head up and down a lot, and too skinny---hard to put two windows side by side comfortably. Have to fiddle with overlapping windows a lot. In landscape it would be too short, and I rarely watch movies on my desktop. One movie trailer a quarter approximately, so optimizing for that use case is absurd.

I would prefer a fatter 16:10 instead, and was happy with the 22" 1920x1200 that was replaced, though I love the increased resolution of the new monitor.

<comment><USER14> This is the single reason why I have not made the switch to 4k displays. I simply cannot give up my existing 24" 16:10 monitors.

<comment><USER15> I use two 24" 4K displays and scale the image to look like 2560x1440 per monitor (macOS). It took a while to get used to the smaller UI, but I love the amount of space I get.

Edit: The rendered viewport per monitor is 5120x2880 (=2560x1440 Retina), so everything is sharp.

</comment></comment></comment><comment><USER16> 8K doesn't excite me. I want a monitor with 4K, FreeSync, over 144hz, running on Displayport-over-USB type C... and ideally powered only by USB.

This seems like it will be possible one day.

</comment><comment><USER17> Give me a 50+ inch 8K concave OLED desktop display with a matte surface and I will pay a _huge_ premium.

My predictions aren't holding up [1]. I feel too many customers are satisfied with small form-factor and/or are tolerant of using multiple displays and suffering the inconvenience of bezels.

[1] [http://tiamat.tsotech.com/ideal-desktop- displays](http://tiamat.tsotech.com/ideal-desktop-displays)

<comment><USER18> What's the use case where bezels are inconvenient? For me I want natural delineation of workspace. Being able to snap applications to 3 physical boundaries makes it easier for me to organize my work, vs one massive display where every window is floating arbitrarily.

I'm not saying those are the only two options, I'm just curious what the downside is, specifically with productivity use. I feel like if I had a 50" concave display, I'd want my window manager to have some kind of logical organization similar to what I'd have with multiple monitors anyway.

<comment><USER19> For one, you can't actually expand something across multiple screens. Depending on the kind of work you do (especially anything visual like graphics), the bezels may be a deal-breaker. Personally, I also just prefer having one large monitor because my head doesn't need to move.

</comment></comment></comment><comment><USER20> > "Linus from LinusTechTips should be happy, as they just invested in a pair > of 8K video cameras. Time to submit my own acquisition request"

I have never understood what's the point of investing in such an expensive and new tech for videos for YouTube, most of the tech channel videos on YouTube will be non relevant really fast so it's not like you are future proofing...in two years from now still very few people will have 8k screens, and cameras will cost at least 50% less. Storing 8k videos will increase storage costs and processing bandwidth too.

<comment><USER21> > _I have never understood what 's the point of investing in such an expensive > and new tech for videos for YouTube_

these people are professional content makers. they make their living from buying/receiving gear and reviewing it on youtube. this isn't a hobby. youtube is big media now. very, very big. "just because you don't use it doesn't mean nobody else does."

if a film editor, or professional photographer, or rich guy, or web developer, or options trader, or magazine designer, or whoever is in the market for an 8k display and/or camera rig, they go to youtube and watch the reviews.

but in general... you know we used to have 640x480 screens and 20MB hard drives, right? that was 'normal', and 1024x768 seemed excessive. welcome to the forever now.

<comment><USER22> I believe a lot of people shoot in higher resolution than intended output because they want to be able to crop the video and still have desired resolution.

<comment><USER23> I just want to have nicer text.

</comment></comment></comment></comment><comment><USER24> tl;dr: US$4999, 7680 × 4320 resolution, 1300:1 contrast, 31.5" IPS, 60Hz refresh, 2 × DisplayPort 1.4 to handle the bandwidth

<comment><USER8> One last spec: it is indeed 16:9.

Which is unfortunate.

</comment></comment><comment><USER25> That is a lot of pixels. And quite an improvement over the 16 lines of 64 characters on a converted television that the first computers had.

The article points out the challenge though, all that memory that needs to from where it is into the pixels on the screen at a rate fast enough to not annoy you with repaint lag. Which reminds me that the real 'winner' in this space will be if someone can put 300 ppi where ever you are looking in a larger field of view and leave the rest at 100ppi and 50ppi.

<comment> angus-prune That'd be a fascinating piece of tech.

I'd bet against it being achieved before GPU's have caught up with the requirements though.

<comment><USER26> Foveated rendering has already been demonstrated at GDC this year, it's expected to be included in the next generation of vr headsets, and there are already some attachments for your monitor you can buy now.

[http://www.tobii.com/](http://www.tobii.com/)

</comment></comment></comment><comment><USER27> I have 3x 4k monitors, one 31.5" DCI 4k, one 28" UHD 4k and a 55" UHD TV (that also reports itself as DCI capable).

Frankly, 8k at 31.5" is kinda pointless unless you have eyes of an eagle or are working glued to your monitor. As a tech demo from Dell, it's cool!

<comment><USER28> I agree. I couldn't use my 4k Dell monitor with anything but my mbp on OS X because I couldn't read much on Windows. Windows does not do display scaling very well.

I imagine 8k is not the easiest to use on Windows and there do not seem to be any Apple products with the right amount of power to use a display like this correctly (i.e. With the same power you'd put on a custom machine running Windows.).

<comment><USER29> Windows 10 works mostly ok for me (27" UHD), I just set the scaling to 175% and everything scales nicely (if a program doesn't fully support scaling then, it's usually scaled up but blurry). It's supposedly a per-monitor setting, but I haven't tried it.

Linux is the real pain - most things only support integer scaling for UI elements and 200%/2x makes it feel a bit big to me.

<comment><USER30> > Linux is the real pain - most things only support integer scaling for UI > elements and 200%/2x makes it feel a bit big to me.

That's actually only the fault of Gnome.

All KDE and Qt programs support fractional DPI scaling – with a different ratio per screen.

Don't blame all Linux programs if it's only Gnome that's broken.

The environment variable used is

        QT_SCREEN_SCALE_FACTORS=DisplayPort-2=1.75;HDMI-A-0=1.08;

</comment></comment></comment></comment><comment><USER31> 280 ppi! At around 800 ppi you don't need to do AA anymore. So, around 32k at same size.

<comment><USER32> Why would you need AA at 280ppi? At sane viewing distances, I would imagine that 99% (maybe 100%) of the population lacks the visual acuity to benefit from >280ppi.

Where does your 800ppi claim come from?

<comment><USER31> Yeah, it depends on viewing distance, of course. there was a calculation which from 800 came out as a number, which I forgot and can't produce atm. I remember the output. Same as in print when printing fine detail, such as maps, no less than 800 dpi ever (not related, but there was also a calculation which I forgot, but remember the output).

<comment><USER32> Print and monitors aren't directly comparable. Print needs higher DPI because people will literally hold a map up to their face to look at fine detail. You just zoom a digital map instead.

If you aren't holding your face up to your monitor, you don't need 800dpi. The original iPhone "retina" display was 326ppi and that was assuming a 12 inch viewing distance. For monitor viewing distance, you'll be 20 or more inches away, making 280ppi plenty for the vast majority of people.

</comment></comment></comment></comment><comment><USER33> Do you think that the market will sooner or later move to 8K monitors? I'm not so sure.

At a normal viewing distance a 100dpi monitor is already decent. A UHD monitor is just great. You have to get very close to see individual pixels. I'd say doing AA is no longer required even then.

8K seems overkill for most purposes. Sure, there is a niche that can take advantage of it, but I don't see advantages for the mass market.

Same as with SACD, CD tech is simply good enough for pretty much everyone so SACD never took off.

I write this despite being a high dpi junkie, I bought a ViewSonic VP2290b (IBM T221 clone, 3840x2400 22") back in 2006 and dealt with a huge hassle of 4 DPI inputs for years.

<comment><USER34> >At a normal viewing distance a 100dpi monitor is already decent.

No it isn't.

<comment><USER35> You'll see, it'll do perfectly in a couple of decades. Most people wear glasses nowadays, and those who don't will at some point in the future.

<comment><USER32> Wearing glasses doesn't reduce the need or desire for higher resolution monitors. Maybe _uncorrectable_ vision problems do, but if your glasses get your eyes close to 20/20, you'll benefit from higher resolution just like people with natural 20/20 vision.

And as another poster pointed out, the blurriness of the screen may compound with the natural blurriness of uncorrectable vision loss.

</comment></comment></comment></comment><comment><USER36> From our human eyeball's perspective, aren't we getting to a point of diminishing returns?

I just wish Apple had made a retina Cinema display and left it at that (they have the tech, it's in the 5K iMac).

<comment><USER37> Until the last year Apple didn't make any devices that could actually reasonably drive a 5k monitor (save the iMac of course), and that's ignoring the connectivity problem.

</comment></comment><comment><USER38> > "By then, 16K might exist, back at the $5000 price point. Maybe."

I appreciate the author saying 'maybe' because I can't, off the top of my head, understand why 16K would add any benefit over 8K... Aren't we at 'retina' with 4/8K anyway?

EDIT: at a 32" resolution...

<comment><USER39> Retina is determined by view distance and visual acuity. You can get retina on any 4k tv right now at several meters of view distance (hell, you can get "retina" on old 1080p tvs when you are sufficiently far enough away), but if you stood right in front of it it would be obviously pixilated anywhere from 30"\+ resolution.

Same applies to desktop monitors and phones. The reason phone screens pushed high DPI first was because you were much closer to the screen to make it fill your view.

</comment></comment><comment><USER40> The image on the screen in that article certainly looks better than the monitor I' using ;)

<comment><USER41> Right? And I also don't understand this side-by-side comparison. If I'm viewing the image on a 1080p screen (say), then why can I tell the difference between these images? What is the comparison supposed to be showing?

<comment><USER42> The comparison images are zoomed in, though they should specify how much. Presumably by a factor of four.

</comment></comment></comment><comment><USER43> So can I drive this from a 15" touchbar MBP?

</comment><comment><USER44> Personally don't see the point. I was disappointed w/ 4K monitors when half of my applications didn't scale well for them. I imagine even less things will scale well for an even less popular resolution.

</comment><comment><USER45> I brought 27 inch 4K display recently and instantly regret I hadn't purchased 4K display 3 years ago.

Back then, 4K display was still way too expensive. Although I could buy one, I didn't think spending half the price of good laptop computer for a 4K display doesn't worth the money. I was wrong.

4K display greatly improved my productivity. I should have purchased a few of them already.

</comment><comment><USER46> I don't need a super-high DPI display, but 3440x1440 @2x is almost 7K, and that sounds like a natural upgrade from the existing 21:9 34" displays.

It's a pity that most operating systems aren't designed for huge screens - Windows' start menu is always in the bottom-left corner, for example.

</comment><comment><USER47> Hopefully, they drop the price on the 32'' 4K monitor to under $1,000. That'd be a great deal.

<comment><USER48> There are 32" 4k monitors (IPS, 60Hz, 4ms response) for $600 or less from LG already.

<comment><USER49> Can you please provide a link? They are not showing up on the LG website or Amazon. If anyone else knows of a 32" 4k monitor for 500 USD or less, share a link. For me 32" is smallest size I can get away with 100% scaling at 4k.

<comment><USER50> I have bought this one in December, there's 1 bad pixel but otherwise am satisfied. [http://www.ebay.com/itm/QNIX- NEW-32-UHD3216R-REAL-4K-MINE-38...](http://www.ebay.com/itm/QNIX- NEW-32-UHD3216R-REAL-4K-MINE-3840X2160-60Hz-IPS-UHD-Monitor-AMD- FreeSync-/131906201627?hash=item1eb638e81b)

</comment></comment></comment></comment><comment><USER51> That article says I can get 4K for 350. More interested in that than the 8K, anybody got a link in Europe?

<comment><USER52> 2-3 years ago I got a 28" 4k TN panel for ~£280. Then a 24" 4k IPS for ~£200.

This year 2 27" 4k IPSs for ~£350 each (both LGs, the first one a better model but cheaper because pre-Brexit-vote).

Prices have gone up from my POV.

In answer to your question: [https://www.overclockers.co.uk/monitors/by- type/4k-ultra-hd?...](https://www.overclockers.co.uk/monitors/by- type/4k-ultra-hd?sSort=3) \-- under £300 for 24" 4k IPS. OCUK is a UK subsidiary of Caseking (de), so I'd be surprised if similar prices weren't available across Europe.

In all the above experience, I've found Acer to be very good (3 monitors, 2 excellent and 1 with pixel defects), Benq to be poor (multiple returns before I gave up and bought something cheaper) and LG to be absolutely flawless.

</comment></comment><comment><USER53> I might be tempted if it used a USB-C input and was compatible with my MacBook. I recently bought from Apply the LG ultradef monitor they recommend for the MacBook, and while the LG + MacBook combination is great, even a larger higher resolution screen would be great.

</comment><comment><USER54> Interesting that it uses two DisplayPort 1.4 inputs. I guess HDMI 2.1 isn't ready yet?

<comment><USER55> Any current gfx cards featuring HDMI 2.1?

<comment><USER54> Oh, right, there's a chicken-and-egg problem there.

</comment></comment></comment><comment><USER56> I'm using multiple 32" 4K monitors, and while the additional definition might be "nice," I certainly can't work with any "smaller" text.

I wish Dell would produce 8K monitors in a much larger format, like 48".

<comment><USER57> Forgive my ignorance since I've been on Mac for so long, but does windows still not do UI scaling?

<comment><USER58> Windows has HiDPI support pretty well nailed down AFAIK. Laptops like the Dell XPS have been shipping with HiDPI screens for a while.

Linux support is spottier, especially when using multiple displays of varying DPIs, but even Gnome works pretty well on a HiDPI laptop these days.

<comment><USER33> I'm using Ubuntu 16.04 on a Dell XPS 13 (3200x1800) and it works well as long as I use 2.0 as the magnification value. Other values such as 1.83 are broken.

<comment><USER59> I'm using XFCE (Debian unstable) on a Zenbook (3200x1800) and that works really well too. There isn't a magnification value to set - rather you set the display DPI.

</comment></comment></comment></comment></comment><comment><USER60> Per HN's own doctorpangloss 1 week ago: _The Dell P2715Q is the best deal_ on a high DPI display [https://news.ycombinator.com/item?id=13901752#13902158](https://news.ycombinator.com/item?id=13901752#13902158)

HN's skwirl, right as I posted this: _(27 ", 163ppi)_ [https://news.ycombinator.com/item?id=13949827](https://news.ycombinator.com/item?id=13949827)

I don't think anyone is beating [https://amzn.com/dp/B00PC9HFO8](https://amzn.com/dp/B00PC9HFO8) at $540.

If you found this info useful, this is a referral link you could choose of your own free will (no pressure from me!): [http://amzn.to/2nvx9XP](http://amzn.to/2nvx9XP)

</comment><comment><USER61> 8k but no Rec.2020 gamut support... that's actually incredibly disappointing.

</comment><comment><USER62> holy shit...look at the size of the taskbar

</comment><comment><USER63> Now if only Microsoft could fix that Remote Desktop resolution scaling problem, things would be so much better. Remote Desktop to a hi-res machine shrinks everything to unviewable level.

</comment><comment><USER64> Is it with matte finish?

</comment><comment><USER65> Can't wait for AR/VR to make monitors obsolete.

<comment><USER66> FTA: "It's worth noting that Raja Koduri, SVP of AMD's Radeon Technology Group, has stated that VR needs 16K per-eye at 144 Hz to emulate the human experience, so we're still a way off in the display technology reaching consumer price points at least."

Dual 16k @ 144Hz

Granted, phones are ahead of desktop displays in pixel density, and that seems more applicable to VR displays.

<comment><USER67> I still can't imagine that they would replace displays at work for anyone who regularly interacts with a team. VR is not good for collaboration. Just as an extension if you need to shut out the world around you. But it'll be hard to tell your company that you suddenly need 8K displays and VR.

<comment><USER68> Project your teammates into a shared VR world. Just think, finally you can gesture wildly at the whiteboard without whacking people in the head.

<comment><USER69> > _whacking people in the head_

Which, incidentally, you could do now that you are in a VR, whenever you feel like.

</comment></comment></comment></comment></comment><comment><USER70> 4k is 4096p, I would expect 8k to be 8192p, but it's only 7680p.

<comment><USER71> 4k refers to approximately four thousand horizontal pixels. 1080p refers to 1080 vertical pixels. So how many 'k' and how many 'p' a display is/has aren't comparable figures.

<comment><USER72> The 'p' stands for progressive scan, not the dimension being measured (neither does 'k').

<comment><USER71> I know that and 'k' just means thousands, but in context they still indicate which dimension is being referred to. 'p' is never used to refer to horizontal dimension metrics and I've never seen 'k' on it's own with a number used to indicate vertical resolution. Not without that being explicitly stated anyway.

</comment></comment></comment></comment><comment><USER73> meanwhile, 60hz...</comment>