> 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.

You can still do this though:

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

Or if you prefer left-to-right:

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

Maybe what isn't clear is that this hole operator would bind to the innermost function call, not the whole statement.

Even better, this method lets you pipeline into a parameter which isn't the last one:

  let result = input
    |> add_prefix_and_suffix("They said '", $, "'!")

Yeah, especially in F#, a language that means to interpolate with .Net libraries (most not written with "data input at last" mindset.) now I'm quite surprised that F# doesn't have this feature.

Wow, this convinced me. It's so obviously the right approach when you put it this way.

This is essentially how Mathematica does it: the sugar `Foo[x,#,z]&` is semantically the same as `Function[{y}, Foo[x,y,z]]`. The `&` syntax essentially controls what hole belongs where.

For pipelines in any language, putting one function call per line often works well. Naming the variables can help readability. It also makes using a debugger easier:

  let foos = foobinate(a, b, input)
  let bars = barbakize(c, d, foos)

Other languages have method call syntax, which allows some chaining in a way that works well with autocomplete.

> Naming the variables can help readability

It can, or it can't; depending on the situation. Sometimes it just adds weight to the mental model (because now there's another variable in scope).

Sure, I like chained method calls too, for simple things. But it gets ridiculous sometimes where people write a ten-stage pipeline in a single expression and then call that "readable."

I'm with you 100%. The main thing is that sometimes a "break point" (using a variable rather than _more_ chain) can help readability. And sometimes it makes things worse. It's really a case-by-case type of thing.

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.

The road network expansions and maintenance required to support the suburbs does. Ottawa has this exact problem. They are widening inner-suburb roads to satisfy demand created by outer-suburb development. A double-whammy.

DC is an exception, most American cities have large swaths of suburbia within the city limits and even larger ones within the same state.

Those suburbs outside the city limits still need money. They get it from state and federal funds which were mostly collected from people in the city limits. For example the Highway Trust Fund as one of many examples. If you check the per capita spending, it's higher for suburbanites than urbanites but the urbanites are putting in more money.

Absolutely not in the case of the DC metro area, on both the MD and VA sides. Those counties subsidize DC proper in various ways, along with the less populated portions of their own states, and because the median household income is so high, they also pay a disproportionate amount of federal income taxes when compared to DC residents.

I also have no idea why you think city dwellers are the primary contributors per capita to the Highway Trust Fund which is funded via a tax on fuel (i.e. miles driven).

The tax on fuel has not been able to keep up with expenditures for the Highway Trust Fund for two decades; now a third of the money comes from the General Fund.

https://t4america.org/2025/05/22/the-highway-trust-fund-isnt...

That said, suburbs with high median household income are probably still putting a lot of money into the General Fund by income taxes.

they aren't putting as much in as the city by call kinds of measures. It generally cost up to 4-5x to maintain suburban areas vs urban. High income suburbanites don't make up that difference. They're subsubdized by the urban citizens.

The suburbanites pay for that maintenance, and there are many other costs to city living that urbanites like to ignore (significantly higher expenses on emergency and social services for example). It's not nearly as straightforward as urbanites like to claim.

One thing that is absolutely clear is that commercial districts subsidize residents in every jurisdiction, and urban commercial districts rely on commuters (from surrounding suburbs) to thrive.

“Seem to be” being the key words.

There’s been somewhat of a continuous cycle of movement with the upper class of America that goes something like this:

1. Move in to the latest newly constructed suburb with low taxes and fresh housing stock

2. Infrastructure ages, tax rates increase, housing standards evolve, the upper class moves to the next new suburb built on former farm land

3. The inner suburb declines, becomes low-income, companies leave, and infrastructure crumbles. Municipal debt piles up, sometimes the city goes bankrupt.

This is especially obvious in cities where regional growth didn’t continue upward forever.

I recommend reading up on Strong Towns’ growth ponzi scheme content.

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.

And this is your translation:

Every time I log onto LinkedIn, it’s a powerful reminder of the energy and passion required to thrive in today’s ecosystem. As a seasoned professional, I’ve reached a point where I’m pivoting away from traditional corporate structures to focus on what truly matters: the craft of software and the people behind it.

I’m thrilled to be entering a new chapter where I can prioritize authentic collaboration over "career" optics. It’s all about the joy of the build and the impact we make together. Grateful for the journey and excited for what’s next! #WorkLifeBalance #SoftwareEngineering #AuthenticLeadership #NewBeginnings

You know, this seems actually useful. I have to tell people some uncomfortable truths sometimes and being too blunt makes people think that I am rude or mean. Translating it like this may help me come up with something that delivers the message in a positive tone, though of course I will need to remove some of the way over the top expressions!

I go to LinkedIn to message old colleagues whose other contacts I lost, and the thing that baffles me is the thing where people describe things in this weirdly epic slop style.

"We were doing X. But then we suddenly found that Y. This is where frobling the wjoozies finally made sense. As a Long time warbler, I can tell you need to..."

Who do they write it for? What value to they get from writing it?

(Not everyone writes like this, luckily).

I don’t participate, but signaling other participants that you’re willing to participate is a signal is a subconscious signal in itself, apparently.

Weird stuff all around. Quality of the audience or the content doesn’t matter at this point. There’s an implicit understanding that the bigger your audience, the more likely you can get any attention, which translates into influence, money, trend and culture setting.

Religion is a signalling mechanism itself. Everybody knows there is bad stuff in there. Like fireflies synchronising their flashes. Or magnetization has locked in the spin states and now changing the direction is very difficult.

They aren't writing that, it's the AI running with their ideas.

Maybe the only place in the entire world where AI has improved the quality of writing.

"weirdly epic slop" is the most concise description of linkedin posts i've yet seen

Same here. I think no site brings me less joy than LinkedIn. I find broetry particularly tiring to read.

LinkedIn did me a favour and locked me out of my account.

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

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

I guess because the hash of an instance stays consistent (which is used to retrieve the value from the dict). The `__eq__` method must disregard the hash and return False for all nans.

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.)

That equality check also considers object identity first:

  >>> class Evil:
  ...     def __init__(self, hash_value): self.hash_value = hash_value
  ...     def __eq__(self, other): return False
  ...     def __hash__(self): return self.hash_value
  ... 
  >>> e1, e2 = Evil(1), Evil(2)
  >>> {e1:1, e2:2}
  {<__main__.Evil object at ...>: 1, <__main__.Evil object at ...>: 2}
  >>> {e1:1, e2:2}[Evil(1)]
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  KeyError: <__main__.Evil object at ...>
  >>> {e1:1, e2:2}[e1]
  1

I'm pretty sure that this is meant as an optimization.

(But it does have to find the instance via the hash lookup first. This won't work if you e.g. return a random number from `__hash__`.)

I can’t tell if “table of context” is a clever new phrase or a typo.