mpartel

If there were a nice answer to this, the "hard problem" would be a lot less hard. But I'll give it a shot.

Along the lines of Descartes, assuming maximal paranoia about everything, it's the thing whose existence you can doubt the least.

That is, let's follow Descartes's line of thinking about how the external world and even all the ideas and concepts in your mind could, in principle, all be an elaborate lie. Then the only thing you absolutely cannot doubt is the existence of the experience of your own thinking. That experience is qualia.

Checking this definition against your criteria:

- Could it mean anything or nothing? It may be ambiguous in that there might be multiple things whose existence you can doubt equally little, but I'd say they're all probably in the ballpark.

- Trivial or fuzzy? Maybe? Admittedly I invoke the somewhat fuzzy concept of "doubt", which I haven't defined properly, and probably can't. But hey, all reasoning builds on some axioms :)

By the way, are you sure your challenge places the burden of proof in the right place? I feel like your position of "our brains are fooling us" is quite a bit stronger and "less default" than my fairly agnostic position. I feel your position at least owes an explanation of why our brains might be fooling us in such and oddly specific and seemingly unnecessary way.

Can you think of an example where we were not only unable to understand something but were even unable to describe the thing we could not understand?

Vitalism (https://en.wikipedia.org/wiki/Vitalism), and the progression from Newtonian physics, are common examples given for this.

Whether we have been unable to describe the things we could not yet understand, I suppose it depends on what counts as a description. We have always been able to point at the objects and phenomena that didn't fit our theories, sure. Qualia on a subjective level might be fundamentally more ineffable for now, but if we insist on immediate objectivity (and I don't think we necessarily should), we can point at qualia too at least on the behavioural level of "we don't know how or why human brains produce this peculiar behaviour of contemplating qualia".

Just like physicists needed to ask the right questions to improve upon Newtonian physics, I think finding correlations between brain activity and (reported) qualia will help us find the right questions, probably at first along the lines of "what's so special about this specific brain region / process". I doubt we'll manage to answer the behavioural question in satisfactory detail without getting at least some new ideas about how to approach the subjective question.

Does that mean that you would be willing to attribute full consciousness to a CPU with some RAM if it ran some software creating the same patterns in memory as they occur in our brains?

The closer the simulation's implementation is to a one-to-one to physical brain processes, the more likely I would think it is to have qualia. If a sufficiently one-to-one implementation of whatever mechanism turns out to be responsible for qualia is possible with CPU and RAM as they exist today, then it'd follow that qualia (and the behaviour of talking about them) are a "by-product" of certain kinds of information processing, rather than some funky physics shenanigans. I'm entirely open to that possibility.

And yes, my sciencey brain also pattern-matches what I just said with "actually having qualia is unnecessary in that statement!", and I'd be inclined to agree with that if qualia weren't so seemingly unnecessary and elaborate for a mere illusion, and if I didn't actually have qualia :)

In other words, knowing how to simulate a phenomenon is not for me a sufficient explanation of the phenomenon, nor even necessarily a very strong indication of what the phenomenon's actual implementation is like.

It seems that only my brain is telling me that there is something more going on in humans but there is no evidence for that, at least none that I am aware of.

Why such distrust in your own brain? :) I think (the existence of) your own immediate subjective experience is evidence, and compelling evidence at that. It's just not the kind of evidence that's currently easily accessible by science. Over the course of history, many things have been inaccessible to science, and then science has progressed.

Science has at least one plausible angle of attack too. Qualia seem to be associated with only some processes in the brain (others are entirely subconscious), some of the time (attention can be redirected). This gives some hope of finding correlations between qualia and brain activity, which AIUI is a major topic in neuroscience currently.

That can be useful depending on what you want to achieve in the discussion, but ignoring the qualia question altogether won't make it go away :)

what are objective properties of qualia?

If we could answer that, we would have solved most of the problem. The closest thing to an objective property is that we indeed talk about them i.e. they do objectively affect the external world. This is true whether they're illusory by nature or not.

I've tried to understand the illusory explanation, but I really can't get over the sheer undeniability of actually having a subjective experience, that being (as Descartes put it) the only thing whose existence I can be really truly certain of. The illusory explanation feels too much like saying "if it doesn't fit our current scientific worldview, it's not real". How did you get over this hurdle?

This tends to get cleared up when a keyword like "qualia" gets mentioned, but it's so common to see lots of words wasted before that happens, if it even does. It's interesting how impactful the breadth of a shared vocabulary can be.

The compiler can explore the call graph of the loop body and find out which methods might be called on the list, and then check that none of those methods write to the list's internal length variable.

How deeply and precisely the compiler (or JIT) analyzes the code in an attept to prove that the length won't change involves a tradeoff in compilation speed, but I'd expect .NET to have found a pretty good sweet spot by now.

That said, some of the refinements, especially the (TypeScript-inspired?) record typing and manipulation facilities, look quite pleasant.

It seems best to defer architecting just long enough to see that some component is becoming problematic, but not much longer. Do it too early and you waste effort. Do it too late and you have a much larger mess to clean up.

That said, I find the idea of game-theory as a "universal basis" of ethics intriguing.

This change introduces a new "extensions changed" event that extension points must (correctly) implement, so the cost is more code i.e. more opportunity for bugs. The essential question is of course, how much more, and I have no answer to that.

My main issue is when I type a '.', the C# extension gives me an accurate list of members, but TabNine intersperses its own guesses, which are often wrong.

Possible fixes or mitigations (VSCode API permitting):

- After a '.', discard the TabNine completions whose prefix doesn't match one of the C# completions.

- After a '.', discard all one-word TabNine completions.

- Give all TabNine completions a different icon and maybe sort them all at the top or bottom.

The masking stuff reminds me of how branching works (or at least used to work) on GPUs, so I wonder, could all this be made to work on a GPU too?

Can Skip maintain such a self-referential invariant automatically? Does the answer depend on A and B's mutability?

(This "graph as array" escape hatch seems to come up in many language designs with compile-time pointer analysis. It's useful, maybe even essential, but you tend to lose some nice language features/guarantees with it, in my limited experience.)

The GC thing sounds excellent!

Certain kinds of networked games are built as a model, deterministically updated by clock ticks and commands from the server, and a view layer on top of that. And even model-level objects often monitor each other for changes. Seems like a perfect fit.

Game objects often have graph-like (not tree-like) dependencies though. E.g. two characters may want to move towards each other, creating a pointer cycle. Ideally I'd want one to be "magically" updated if the other disappears or changes state. I wonder if Skip has a good answer there, or if a good language-level answer is even theoretically possible.

It seems to contain a bunch of amendments that seem to make at least Article 13 a bit less draconian. In particular, 13.2b seems to require a human-reviewed and appealable complaints mechanism.

All in all, it's still very shitty.

I intend to save the list of those who voted for and set a reminder to dig it out when the next EU elections come up. I hope people with more social media presence than I do the same.

I wrote to them last time this was voted on and expected zero replies (partly due to the late hour), but actually got 2 out of 13, one of which indicated they had actually taken a few seconds to read some of my words. I later read they had received "thousands" of messages on the subject. I can't imagine most of them getting anything close to even this small amount of attention.

E.g. "intel-microcode-legacy" and "intel-microcode" would be more diplomatic (disgustingly so IMO).

And one could argue that every package in non-free would deserve a "-legally-restricted" suffix.

Might even come from a media organization if their lawyers deem this sufficiently unlikely to be enforcable in their country.

I've missed this property when writing Java and JS even before Rust was a thing, and Go has felt the same.

Arguably (very arguably), US and EU censorship is somewhat justified by the attempt to protect individuals, but Chinese censorship is pretty blatantly about protecting existing power structures (in the name of "stability").

For most other uses of globals, I fully agree.

As with any software engineering guideline, there are exceptions. E.g. Java-style loggers are so ubiqitous and "not that mutable", that it's generally good for them to be global.

Edit: also from experience, suddenly wanting two of something where before there was only one, is not that uncommon.

Also, if you have so many globals that passing them around as parameters / instance variables becomes truly tedious, that can be a valuable signal that the program is poorly structured.

Of course, none of this matters in small codebases, as long as they stay small.