munchler

As a kid, I liked arithmetic function machines that "magically" force a particular output or allow one to quickly deduce the input from the output. These are usually based on non-obvious (to a kid) identities. I would invent my own and then ask family members to play along. I'm not sure if this sort of puzzle game has a name?

A simple example:

- Multiply your number by 2

- Add 10

- Divide by 2

- Subtract the original number

The classic I remember from childhood is the card game "War". Assuming neither player cheats or makes a mistake, the outcome is totally predetermined.

If, say, a certain version of Claude tends to be better at front-end than back-end work, that can be important for deciding how to use it in the future. Just like when managing human developers.

> Disclose your "AI" tools in a merge request if needed but leave them out of the damn commits, those are for technical information and not for advertising.

I think this is very poor advice. Knowing who/what changed the code is often crucial for understanding why it changed.

All types of problems. F# can do almost anything C# can do and with less ceremony. The quote I like is that once you get comfortable with F#, switching back to C# is like "having to fill out government forms in triplicate".

Yes, all that stuff. I try to stick to F# where no special syntax is required for missing values (via Option<T>).

Simple example:

   type Expr =
       | Primitive of int
       | Addition of (Expr * Expr)
       | Subtraction of (Expr * Expr)
       | Negation of Expr

All the weird cruft around nullability, for starters. Once again confirming that allowing null references is usually a mistake.

Unions are simpler than subclasses and more powerful than enums, so the use cases are plentiful. This should reduce the proliferation of verbose class hierarchies in C#. Algebraic data types (i.e. records and unions) can usually express domain models much more succinctly than traditional OO.

F# leads the way and C# slowly catches up, as always. Yet for some reason, C# still gets all the mindshare.

My understanding is that E2E encryption implies encryption in transit. The message is encrypted at the source and only decrypted at the destination, so it is encrypted everywhere in between.

The point is that, logically, the first part of that rule (“expose the king”) is implied by the second part (“leave that king”), so the first part is redundant. You could simplify the rule to:

No piece can be moved that will leave the king of the same color in check.

If Google stops driving traffic to websites, won't those websites stop allowing Google to crawl their pages? The pendulum might be in motion, but it seems like there should still be some natural equilibrium that it's heading to.

Well, that’s my point. You can model a coin flip, but you can’t predict it. A model and a prediction are two different things.

I think this is all true, but it dodges the bigger issue. A presidential election has a binary outcome: yes/no, win/lose. If your statistical model doesn’t contain this single bit in its output, then it doesn’t meet the minimum requirement for being a prediction.

Now you might say that it was on me as a consumer to understand this in 2016, but I remember the look of total shock on Nate Silver’s face when he called the winner on live TV that night, so clearly he didn’t really understand it either. Lesson learned for all of us, I guess.

This is charming, but not at all like the soul-sucking content typical on LinkedIn.

The choppy language is the biggest trigger for me. Examples:

* "With Fraud Defense, there was no process to respond to. The product launched. The requirements page went live."

* "That is not a technical limitation waiting to be engineered around. It is the mechanism."

* "The defeat is mechanical. Bot operators point a camera at a screen, a trivial automation with off-the-shelf hardware."

I could be wrong, of course. Maybe humans are starting to write like LLM's, or maybe it's just confirmation bias on my part.

I think this is the third HN link I've clicked on in a row that leads to an LLM-generated article. I'm not opposed to AI, but I'm tired of seeing it quietly substituted for human thought and expression.

Thank you for this explanation. So the AI can respond based on the DOOM game that it’s watching? E.g. Could you ask the chatbot for advice on what to do next on the current game level?

Wut? How are chefs like waterboarders?

> There’s another cat space on the underside of the desk surface, in the normally unutilized space in front of your knees when you’re sitting.

"Normally unutilized"? This is where the drawer goes. Otherwise, it's just a glorified table, not a desk.

I think OP is proposing a lump of antimatter with no net electric charge.

My guess is that even in this case the lump’s positrons would immediately interact with the table’s electrons and explode.

You do realize that there a lot of people who sit at a desk and use a computer all day, right? Those are the ones whose jobs are vulnerable, not the ones who work with their hands or interact with the public.

Can’t tell if this is intended as humor, but I LOL’ed.

Well, I totally disagree with this. One of the main benefits of currying is the ability to chain function calls together. For example, in F# this is typically done with the |> operator:

    let result =
        input
            |> foobinade a b
            |> barbalyze c d

Or, if we really want to name our partial function before applying it, we can use the >> operator instead:

    let f = foobinade a b >> barbalyze c d
    let result = f input

Requiring an explicit "hole" for this defeats the purpose:

    let f = barbalyze(c, d, foobinade(a, b, $))
    let result = f(input)

Or, just as bad, you could give up on partial function application entirely and go with:

    let result = barbalyze(c, d, foobinade(a, b, input))

Either way, I hope that gives everyone the same "ick" it gives me.

Most true suburbs aren't within the big city limits, so I'm not sure your point is well-founded. For example, in the DC area, the suburbs aren't even in the same state as the city and yet the suburbs seem to be thriving.

Thinking about society is not introspection. Introspection is, by definition, only about one’s own thoughts and feelings.

I can feel my soul draining out of my body every time I visit LinkedIn. I'm old and my tolerance for corporate culture has run out. I still love making software and working with people, but not having to think about my stupid "career" so much anymore is a relief and a joy.

But the hash alone shouldn't be enough to match the key. Isn't an equality check also needed to avoid a false positive? That's the idea behind a hash table, as I understand it. (I'm not a Python programmer.)

    >>> my_dict[nan] = 3
    >>> my_dict[nan]
    3

Wait, how does that work if nan isn't equal to itself?