I see several people sharing the Stanford bithacks link, so I'll throw in a slightly-less well-known resource that I found particularly instructive. Basically, a collection of the lemmata we can prove about fixed-length sequences of bits and the fun algorithms that can be built atop those results.
For my toy example I don't think it is because it's generally easy (in the languages I work in) to overload arithmetic operators on types that are basically constrained scalars so there's no explicit wrapping/unwrapping to do when you want to operate on them as if they were plain scalars.
Maybe you could give me an example of the kind of pathological situation you're alluding to?
They absolutely do have a cost. The question is whether the benefit they bring in implicit documentation is worth their cost.
> Even beyond the DX of readable names, it also acts like a type-checker. By reading the code, you can verify at least the semantics make sense.
I would strongly prefer that the actual type system do this job instead. As a toy example, if a function is only meant to operate on "lengths" (i.e., non-negative scalar values) then that should be modeled in the types of its arguments, not in its name.
> the semantics it learns sometimes have significant artifacts resulting from associations that are common in news coverage
I think this is largely the point. The game is significantly easier (for me at least) when I limit myself to thinking about what words would have high co-occurrence in English print journalism.
| It tests my anxiety levels at least 5x more than my skillset.
I'm not so convinced that these are two distinct things. I want coworkers who can maintain their level of skill under extremely hostile, stressful conditions. I'm not going impose those conditions on them, but I can't necessarily control the myriad third parties or circumstances that might.
First, I claim there exist disasters that are not simple to mitigate against collectively. Civil unrest (the full spectrum, from vigorous protest to outright governmental collapse) being the big one I have in mind.
Second, I claim that the wealthy character in the story above has significantly greater ability than the non-wealthy character to: (1) have accurate situational awareness about disasters (e.g., can distinguish shit actually hitting the fan from shit narrowly missing the fan (possibly via superior sensing apparati, more likely, just by delegating the task)); and (2) have well-equipped (read: expensive) bug-in/out plans in place. Thus, even in cases where disasters are mitigated against collectively as you claim is possible, the wealthy character will be in a better position to maintain their pre-disaster quality of life than the non-wealthy character.
That said, this is all a little too removed from a concrete comparison for my liking. Maybe you have one in mind? Ideally, an example where collective efforts at disaster mitigation basically made outcomes for individuals insensitive to the wealth of those individuals.
> Yeah, there are reasons to use dynamic linking, but I'm still not sure why dynamic linking gives you better profiling and tracing.
It's not so much that the tracing becomes better, but that it becomes feasible at all. Two specific situations come to mind, both MPI-adjacent. (1) Running a PMPI-based tool on code you can't recompile yourself (e.g., you need a Q clearance to see the source, but not to actually execute it--weird I know, but not that uncommon in the DOE labs.); and (2) running multiple PMPI-based tools simultaneously which are composed at runtime via PnMPI.
Consider a meeting in which you are attempting to read the body language of an adversary. Video chat may not be sufficient. For a concrete example, consider poker. Note that I am taking a fairly broad definition of "meeting" here.
What does OpenMP (the shared memory parallel runtime) have to do with optimizing away less-used branches? Am I missing something here or did you mean something else instead of OpenMP?
My understanding is that in IEEE 754 compliant implementations of floating-point arithmetic, commutativity over "+" holds but not associativity. (With the possible exception to commutativity for the NaNs, though I don't remember offhand whether this caveat is necessary).
https://www.jjj.de/fxt/
And for the non-pdf-phobic: https://www.jjj.de/fxt/fxtbook.pdf