Sherclod Holmes @wallhackio@cat.family

me coming to report you for offensive content (the toot was completely innocuous)

i am software egineer

@coriander my superpower in education was that i tested very well.

god made sure i never experienced test anxiety, but at the cost making sure i had anxiety in absolutely everything else

it is said that speech first developed by primitive humans who would utter simple phrases to each other

least masculine salad ingredient:

The thing I find most perplexing about value categories in the C++ standard is the concept of "identity." The C++ standard never defines what "identity" is, and I can't even find discussion on stackexchange on the concept. It is treated as a self-explanatory concept.

The concept of an expression having identity, as I understand it, is the idea that expression carries around, directly or indirectly, the address in memory associated with the value of that expression.

One way this can happen is if the program is well-formed if the expression is given to std::address_of, which explicitly returns the address in memory for the value of the given expression.

Other ways this can happen is if the expression is an array subscript operation (on a type that does not overload that operation). This because "by definition, the subscript operator E1[E2] is exactly identical to *((E1)+(E2)).

If you subscript a non-overloaded value that cannot be given to std::addressof, the standard requires that expression also cannot be given to std::addressof. However, the C++ standard still considers this expression to have "identity" because the expression, by definition, is an explicit computation of an address in memory.

However, we arrive at a contradiction if we remember that two facts that the C++ standards considers all lvalues to have "identity", and that function names are defined to be lvalues. This is absurd because if a function is overloaded, the actual subroutine referred to by that name is ambiguous. In fact, function names are the only lvalue in the language which sometimes cannot be provided to std::address_of.

So the definition of "identity" is not self-explanatory. It is, in fact, a completely arbitrary concept. It should be precisely defined in the standard. Upon doing so, the standards committee will realize that it is completely arbitrary and unnecessary, and then also realize that xvalues are completely arbitrary and unnecessary, and then we will return to just having lvalues and rvalues like we should have in the first place.

in short i vendored a javascript packaged myself and manually edited the minified bundle to expose private functionality as global variables to make possible things that weren't supposed to be possible

i had a lot of fun doing some very questionable things with my stardew math code last night

back when i catsit freya one of the challenges of taking photos of her was that she loved biting the corner of my phone whenever i would get it out

Suppose you have a function called pipe:

const addTwoAndSquare = pipe(
  x => x + 2,
  x => x * x);
console.log(addTwoAndSquare(1)); // 9

What is your preferred implementation?

const pipe = (...fns) =>
  x => fns.reduce((z, fn) => fn(z), x);

VS

const pipe = (...fns) => {
  return (x) => {
    let z = x;
    for (let i = 0; i < fns.length; ++i)
        z = fn(z);
    });
    return z;
  };
};

i, for one, would allow the turkish man to light my ears on fire

wait mgk just made a nu-metal song with fred durst lmaooooo??????????????

actually i should have bought five of them