Hercuros

How do you count how many bugs a program has? If I replace the Clang code base by a program that always outputs a binary that prints hello world, how many bugs is that? Or if I replace it with a program that exits immediately?

Maybe another example is compiler optimisations: if we say that an optimising compiler is correct if it outputs the most efficient (in number of executed CPU instructions) output program for the every input program, then every optimising compiler is buggy. You can always make it less buggy by making more of the outputs correct, but you can never satisfy the specification on ALL inputs because of undecidability.

“Expression” is a bit of an overloaded word here. Carrying a swastika is considered similar to hate speech. Just like you cannot just make death threats in the U.S., even though you are just “expressing” yourself as long as you do not carry out the threat. Not saying those are exactly the same, but there are limits to expression, and spreading hate against large swathes of people is considered like that in Europe. Especially because that kind of speech can at some point turn into actual physical violence against the groups in question.

With the way things are going with climate change, I think that assuming “extreme climate events in different geographies are independent statistical events” is an extremely flawed assumption to make. You acknowledge that it is a simplified model, but that is not some minor oversight. Any model that does not account for this is deeply flawed, and I think no insurance company would choose to model extreme event risk like that. There are common factors (e.g. global average temperature) that can cause many of these events to be triggered in a correlated way.

A “2% risk of default” on an individual bond is something a retail investor might be able to understand, but no one should be buying a “diversified” bundle of these things if they cannot form a reasonable understanding of how correlated they are. Why should understanding the correlation risk be left up to individual investors building their own portfolios?

I also think forming an intuition for these more “all-or-nothing” type events is more difficult than e.g. understanding that if GOOG goes down 10% then AAPL might do too at the same time because they are both tech stocks.

Isn't the stigma desired anyway? It keeps people from going through with it. That's why society deliberately creates and actively cultivates the stigma.

That’s a very optimistic take on how “rational” society tends to be. The thought that “if things are in a certain way in society, then it must make sense (from a moral or societal point of view) for them to be that way.”

The person you are replying to shared some research by experts on the topic giving recommendations. You can argue for or against anything, but it’s useful to at least engage with the evidence being presented.

I guess the internal exposure state would be “wrong” if the compiler removes the dead load (e.g in a pass that runs before provenance analysis).

However, if all of the program paths from that point onward behave the same as if the pointer was marked as exposed, that would be fine. It’s only “wrong” to track the incorrect abstract machine state when that would lead to a different behaviour in the abstract machine.

In that sense I suppose it’s no different from things like removing a variable initialisation if the variable is never used. That also has a side effect in the abstract machine, but it can still be optimised out if that abstract machine side effect is not observable.

The specification proves a property about an algorithm/function, namely the equivalence between a more complicated memoizing implementation and a simpler direct recursive implementation.

It is also true that no numerical reasoning is happening: the memoized version of any recursive relation will return the same result as the original function, assuming the function is not stateful and will return the same outputs given the same inputs.

However, it is not true to say that it does this by exhaustion, since there are infinitely many possible outputs and therefore it cannot be exhaustively checked by direct computation. The “n” for which we are “taking the proof” is symbolic, and hence symbolic justification and abstract invariants are used to provide the proof. It is the symbolic/abstract steps that are verified by the type checker, which involves only finite reasoning.

Of course, the symbolic steps somewhat mirror the concrete computations that would happen if you build the table, especially for a simpler proof like this. But it also shouldn’t be surprising that a program correctness proof would look at the steps that a program takes and reason about them in an abstract way to see that they are correct in all cases.

How could you say that your views are aligned with those of Descartes and Kant if you have not seriously engaged with their works and what others have written about them?

All serious works in philosophy (Kant especially) are subject to interpretation. Whole research programmes exist around the works of major philosophers, interpreting and building on their works.

One cannot really do justice to e.g. the Critique of Pure Reason by discussing it based on a high level summary of the “main ideas” contained in it. These works have had a major impact on the history of Western philosophy and were groundbreaking at the time (and still are).

Exceptions, such as the entirety of Europe? This level of privacy violation is truly incomprehensible to most citizens of European countries.

I think the issue comes with trying to present a USB mass storage API to the host where you allow the host to write to any arbitrary byte offset of the mass storage device without the structure that is imposed by a file system.

If the host and guest both get presented with the same “array of bytes” mass storage interface, then they will compete and potentially mess up each other’s reads and writes, let’s say if they both treat that array of bytes as an ext4 file system and try to write a file system metadata to the same physical location at the same time.

Of course you have have a “virtual file system” exposed over USB, but isn’t that exactly what MTP is? The point is that USB mass storage is not a virtual file system.

It’s not just about the energy usage, but also purchase cost of the GPUs and opportunity cost of not using those GPUs for something more valuable (after you have bought them). Especially if you’re doing this at large scale and not just on a single desktop machine.

Of course you were already saying it’s not a good idea, but I think the above definitely plays a role at scale as well.

In many European countries there is an expectation that employers behave in socially responsible ways. In many cases this is also codified into law.

Employers also benefit from government support (e.g. the government sponsors education that ultimately provides the workforce for the employers).

Does that make it any better even if it is true? (And I don’t think that it is as true as you make it out to be, e.g. it’s not true for my medium-sized organization)

Just because it’s good for “career optimization” does not make it less of a strange mindset to view your colleagues as predators. The article also puts all of the blame on the so-called “predators”, when it should be blaming the organization’s culture and leadership if helping others is viewed in this way.

For every story like this, there’s another story where everything moves in the opposite direction.

The data would still be awful, and people would pay less attention to the study because it’s not a priori surprising that ChatGPT would write worse poetry than the most celebrated poets in history.

If I use bad data to conclude that “Java is faster than C++ in most cases” you can be sure it will receive a lot more attention than if I reached the opposite conclusion based on similarly bad data.

I don’t fully agree with putting down “fun” movies like the Avengers, but at the same time “serious” art is not primarily for plain entertainment.

People might find “serious” art meaningful and it might spark feelings in them, but that’s not the same as getting an adrenaline rush from exploding cars in an action scene.

Of course there are also cases where the boundary between “fun” and “serious art” is not so clear, there are always exceptions to any attempt to define what makes something “serious art”. Art can also be subversive and run counter to traditional expectations of what art “should” be. But I don’t think the Avengers is an example of that.

I suppose the memory being mapped twice could be detected by anti-cheat though. You can then also make more mitigations to prevent detection of the mapping (e.g. hooking the syscall to check the active mappings), but it’s always a cat and mouse game.

I don’t think speculation about AGI is possible on a rigorous mathematical basis right now. And people who do expect AGI to happen (soon) are often happy to be convinced by much poorer types of argument and evidence than presented in this paper (e.g. handwaving arguments about model size or just the fact that ChatGPT can do some impressive things).

I think the biggest fallacy in this type of thinking is that it projects all AI progress into a single quantity of “intelligence” and then proceeds to extrapolate that singular quantity into some imagined absurd level of “superintelligence”.

In reality, AI progress and capabilities are not so reducible to singular quantities. For example, it’s not clear that we will ever get rid of the model’s tendencies to just produce garbage or nonsense sometimes. It’s entirely possible that we remain stuck at more incremental improvements now, and I think the bogeyman of “superintelligence” needs to be much more clearly defined rather than by extrapolation of some imagined quantity. Or maybe we reach a somewhat human-like level, but not this imagined “extra” level of superintelligence.

Basically the argument is something to the effect of “big will become bigger and bigger, and then it will become like SUPER big and destroy us all”.

Why is it all about doing more and not about doing less? I sincerely doubt that a technological solution is possible that would not require any reduction/change in our current lifestyles. Where is the evidence that we only need a sufficient amount of science and engineering to prevent disastrous climate change?

Moreover, merely developing the technology is not necessarily enough to get it actually adopted. Lobbyists will fight to protect established interests from industries like oil and gas. There will be narratives about how such new technologies destroy jobs, in an attempt to sway voters.

Ultimately, not enough change is going to happen without political will. That is because fighting climate change is not going to make everyone happy. There will be losers, and there is never going to be some magical piece of technology that will let us have our cake and eat it too. Creating political will requires more than just clever engineering, and people like Greta Thunberg can help motivate and inspire large groups of people to create that political will.

You can have some seriously in-depth discussions in sociology or philosophy as well, that would be hard to follow for someone with just a STEM background. The kind of sociology or philosophy one would discuss without preparation or reading with friends is not really comparable with the academic disciplines. It is just armchair philosophy/sociology.

I have a feeling many technically minded people would struggle to read and write an essay about Heidegger or Habermas. In fact, I doubt most people are even aware of that type of philosophy due to not having actually delved into it very deeply, and yet as outsiders to such fields they feel confident in making claims that those fields are "easier." (And usually there is also an implication that this being "easier" is an indication of those fields being less serious or worthwhile.)

I think times are also just different now. Now a lot of the talent just gets vacuumed up by the Big Tech companies where they can be a cog in some wheel.

You seem to be ascribing some moral failure to the younger generations whereas there are also factors at play that go beyond individuals. It might be more sensible to say that the internet could not be invented in the current economic/social climate.

One thing that does always strike me about such libraries is that they are often relatively easy to use for common scenarios like that, and the mental model is really not so complicated or abstract as to require category theory or something like that. When you use such libraries, I don't think you are really doing deeply category-theoretic thinking. More so just seeing how the types fit together and maybe thinking of some higher-order functions that you want to combine and apply.

If you take Haskell and remove all the types (e.g. Scheme or JavaScript), you can have all the same abstractions, with basically the same syntax and operational behavior. But then of course the operational behavior is just applying/composing functions in the end... And because there are no higher-kinded types to deal with, category-theoretic language is less likely to sneak in.

I say this as someone who has used Haskell for years and studied category theory / PL theory as well. And I like all of those things, just think it's sometimes not really necessary to get the mental model at all and be able to use those tools.

I think that some code duplication is also not always the worst thing. Just because strings can be "combined" through concatenation and numbers can also be "combined" through addition does not necessarily mean you need one general notion/function to capture both, especially because if you take that to an extreme then you end up with some function that "sqoogles the byamyams" (i.e. the abstraction has become so general that the only way people really understand/use it is by looking at its concrete instantiations).

I think that it's also important to realize that maximizing "health" is not some kind of absolute goal. Not every aspect of life needs to be optimized to the highest level.

Of course, obesity is a huge issue (especially in the U.S. compared to many other "developed" countries) that can affect people's lives negatively and causes further medical issues such as diabetes, and ultimately can prevent people from leading a life that is as fulfilling and meaningful as they would have liked.

But we are still dealing with people here, not rats in a laboratory experiment, and I think the issues that directly follow from being obese are already bad enough that it does not help to pile on more shame by treating those people as being "weak-willed" or something of the sort, or denying them basic human dignity and respect for being outside the sacred norm. Do we really have to add artificial negative consequences for being overweight? Does that help those people have a more fulfilling and meaningful life?

I don't think people will just forget the direct negative physical/social consequences of being overweight by not being reminded of them all the time in a moralistic tone (and even just reminding people of such information can be moralizing, depending on the context in which the information is provided).

I am personally not a big believer in the idea that art is just a means to an end (even if that end is something we consider very valuable). This article uses the words "purpose" and "goal" a lot, and it is that aspect that I disagree with, although I would agree that art is phenomenon that can only be considered properly inside of its social context.

That is, saying that a painting is just a tool for the painter to evoke certain emotions or experiences in the viewer (or social goals for the painter, like wealth and status), just as a hammer is a tool for driving nails into wood, is to reduce the painting to a mere instrument.

Art is meaningful to people, and I think that cannot be reduced to art being just a goal-directed tool we use to manipulate/control the world or people around us.

It's not the case though that what's most "productive" in the economic sense is also necessarily the most socially desirable outcome. The economy might be optimizing for some objective of productivity (though it's probably imperfect at that by any measure), but I don't think we can reduce it to something simple like "more overall money / goods / services = better", unless we also start looking in more detail at how those are distributed among different groups of people, and what kind of real value it is providing to them.

To be fair, even if you were able to get BB(n), it might still be (and probably is) some ridiculously large number, like a billion times the number of atoms in the universe or something. So that wouldn't really help you solve any math problems even if you were able to get the maximum amount of steps

For a lot of things, like solving boolean SAT, we have the equivalent of a "busy-beaver" limit: if you want to solve a SAT instance of size n, you need at most 2^n steps. And being able to solve arbitrary SAT instances in reasonable time would be huge for mathematical proofs as well, because you could do stuff like find proofs up to a fixed size quickly. Point is that math is probably even harder than BB in some sense, since having BB would not really help you solve math problems in practice most likely.

In an interactive application, you probably don't want to allow the user to queue up 30000 actions that will then slowly get executed over the next, say, 10 minutes. That would mean there is an extremely large delay between taking a UI action and seeing the result of that action (because the other 29999 actions have to be handled before the latest one can be handled). That's also why some applications display a progress spinner and block you from interacting with the UI further (of course that's not always ideal either, you might want to have some small queue and optimistically update the UI already).

If they are just batch background tasks (i.e. there is no expectation of seeing some immediate UI update as a response), then having a larger queue might be fine. There's not really that much reason to put a (small) limit on say the number of files to be downloaded in a queue. And having a really large queue bound is not that dissimilar from having an arbitrarily large queue (limited be memory of course), in terms of buffer bloat and added latency.

I would say that implementation details could be visible to you as a user, but should not be relied upon because they are not part of the documented API.

E.g. it might be visible to you that a certain operation runs quickly on certain inputs, or that a particular output is chosen for a particular input, even though the documentation does not specify the exact output.

How much does this optimization save in terms of executable size on realistic examples (i.e. a full-sized code base)?

I would naively expect that for most functions you know too little about their arguments or the state in which they will be executed to be able to tell that certain branches will definitely not be taken. Especially since any function that has some mildly interesting side-effects (like loading and storing from a pointer or a class/struct field, or even _calling into any function that does that_) would seem to foil the analysis and turn large chunks of code into "unknown reachability".

Rephrasing, I would expect the set of basic blocks that can be removed just by essentially repeated constant propagation of statically-known function arguments to be pretty small. But I would be happy to be proved wrong if that intuition is not right.

Printf is somewhat of an exception, since the format strings are usually known at compile time, meaning that a lot of the control flow can indeed be deduced by compile-time evaluation, but for most functions I would not expect that.