Rationale | Android permission rationale helper dialog | Authorization library

Note: understanding IEEE 754. Please be patient.

IEEE 754-2008 (emphasis added):

In addition, under default exception handling for underflow, if the rounded result is inexact — that is, it differs from what would have been computed were both exponent range and precision unbounded — the underflow flag shall be raised and the inexact (see 7.6) exception shall be signaled. If the rounded result is exact, no flag is raised and no inexact exception is signaled. This is the only case in this standard of an exception signal receiving default handling that does not raise the corresponding flag. Such an underflow signal has no observable effect under default handling.

As I understanding it: underflow == inexact && tiny.

Simple question: why Underflow depends on Inexact?

I.e. why if exact subnormal is produced, then no Underflow exception is raised? What is the motivation / rationale of such behavior?

The rationale for this is to build an ESLint rule auto-completion plugin, but of course, I don't want ESLint rule autocompletes suggested outside my comments, and I also don't want to have to enable all suggestions within comments.

I'm trying to replicate the behavior like in this VSCode plugin for the same purpose.

I'm also not entirely certain if this behavior requires autocomplete, snippets, or both?

For those unaware of ESLint's comment syntax, it's like this:

With the following prometheus config:

I have a data structure in my code that (for the sake of an MWE) is a list where the first element is a string, and the second element is an integer. For example:

foo: MyStructure = ["hello", 42].

Now, since there is an ordering to this structure, usually I would use a tuple and instead do:

foo: Tuple[str, int] = ("hello", 42).

But I explicitly want to be able to easily modify elements within the structure. In particular, I want to be able to set foo[0] = "goodbye", which cannot be done if foo is a tuple.

What is the best way to go about typing this structure?

(I don't think that this question is opinion-based, since I think there is likely clear rationale for how to handle this that would be preferred by most developers.)

Right now, the main solution I can think of is to not actually type the structure correctly, and instead to define my own structure whose true type is listed in a comment:

To quote the Book (emphasis mine),

The same is true of generic type parameters that are filled in with concrete type parameters when the trait is used: the concrete types become part of the type that implements the trait. When the type is forgotten through the use of a trait object, there is no way to know what types to fill in the generic type parameters with.

I cannot understand the rationale. For a concrete example, consider the following

Why does cherry-pick check for conflicts between the cherry-picked commit from one branch and the commit where it will be put after on the other branch if the history will remain linear on that second branch? I'm just trying to understand the internals and rationale behind cherry-pick checking for conflicts despite the fact that all its purpose is to copy a commit from one location to another.

I'm setting up a task definition for an ECS task. One of the environment variables on a container in the task is a set of credentials that is currently stored in the Parameter Store as a SecureString. I'm wondering what's the rationale to not just store it directly as an env variable in the task's container?

The only added security that storing it in the Parameter Store seems to bring is that AWS users and resources can be segmented to not have direct access to it, but is there any other reason?

according to the most popular style guides:

First of all, I've read this question and all the related answers. As explained there, the round function rounds a half number to the nearest even number. A simple example: