arwhatever

Our culture is an unfortunate nexus between strong contract enforcement and weak consumer protections.

We just had this a week or so ago. Stray cat was so cautious that at the end of convalescing in our garage following getting fixed (we had to trap him) he stayed in the garage all day after we opened the side door, and even then, near dusk he stood on the threshold and looked out for 11 straight minutes before taking a step out.

Last week coyotes took him (in part of the country quite far from King County) at night right next to our house, right next to his most familiar territory, and not 20-30 feet from a number of structures he routinely climbed on top of but which coyotes would have no chance of following.

I currently can’t help but take a dim view of coyotes at the current moment, for selfish reasons. I hadn’t thought this to be at all likely given the apparent caution the cat took, but I did spent a couple of years building up a good relationship with that sweet guy.

Occasionally see pizza delivery signs atop super duty trucks where I live.

UPDATE plate_scan SET soft_deleted = 1 WHERE now() - scan_date > 30

Some of the CEOs making comments such as in this article are certainly accelerating the downward spiral of bad faith between workers and employers as fast as they can.

I wonder if there is any good way for either side (or both sides) to break out of that cycle.

Perhaps the letter alone would be adequate.

But frustratingly, the AT&T website appeared to allow you to replace your current (auto-pay) billing method with some other billing method, but I didn't see any way to remove all current billing methods, which makes just stopping paying nigh impossible. :-(

My perception is that consumer protections are much weaker in the U.S. than in the E.U. It would be interesting if anyone has made any attempt at quantifying this.

We all know that there are other countries where far, far worse abuses of power take place, but I've wondered if the U.S. might be at some really unfortunate nexus of strong contract law enforcement + particularly poor consumer protections that leads to these particularly madding subscription cancellation-type services discussed in this thread.

Done, and done. 14 + 44 minute phone calls, gave all of my information to 3 redundant people, including explaining to confused agents that I don't recall the account pin, well you have to have the account pin, well actually the previous person accepted my answer to my personal security question and the person before that texted me a temporary pin but now for some reason those alternate methods don't work for you?

I'm listening to hold music right now, 30 minutes into my attempt at cancelling 3mbps home DSL service (not a typo), for which the price has crept up to $71 USD/mo.

I first spoke with a customer service agent whose accent I couldn't understand very well. I have him ALL my account information. He mumbled something about being unable to forward me to the actual customer service agent (then what is your role, dude?), then came back on and said he couldn't forward me and so I would have to call them myself.

He gave me the same number I had already called. I pointed this out to him and he gave me some other number, which is where I'm listening to on-hold music now.

Right now the on-hold music is interrupted to sell me shit.

It seems like delaying enforcement of anti-scam(ish) behaviors like this increases the average profitability of scam(ish) behaviors, and therefore creates an incentive to engage in scam(ish) behaviors in the first place.

It seems (to me) as if such behaviors were stamped out more rapidly not only would fewer customers be affected, there would be less incentive to try the scam(ish) behaviors in the first place.

That is hilarious and would be hilarious even without any context.

If I don't bookmark it now then I'll never be able to find it again. :-)

I’ skeptical when I see “% of code generated by AI” metrics that don’t account for the human time spent parsing and then dismissing bad suggestions from AI.

Without including that measurement there exist some rather large perverse incentives.

I ran into that particular term oodles in Domain-Driven Design, Tackling Complexity at the Heart of Software by Eric Evans. Pretty dense, though. I’ve heard that more recent formulations of the subject are more approachable.

The episode of the Search Engine podcast “The puzzle of the all-American bbq scrubber” goes into detail on an example of this, is very interesting and makes the same points you’re making here.

Ah yes that is definitely a nice addition to the C# language, albeit still with a couple of shortcomings compared to F#:

1. It doesn’t support code blocks, so if you need multiple lines or statements you have to define a function elsewhere. 2. To get exhaustiveness checking on int-backed enums you have to fiddle with compiler preprocessor directives.

And for #2 any data associated with each enum variant is left implied by C# and has to be inferred from a reading of the surrounding imperative code, whereas in F# the union data structure makes the relationship explicit, and verifiable by the compiler.

if I may elaborate on "everything is an expression," F# allows you to do things like (with apologies for being a tad rusty with the syntax)

  let bar = 
      if foo then  
         7  
      else  
         11

or

  let bar = 
      try
        // code that might throw
        7
      with ex ->
        11

and will ensure that both/all code branches return a compatible type for the `let` binding.

Whereas in C# you have to do like

  int bar;

  if (foo) {
     bar = 7;
  } else {
     bar = 11;
  }

And C# will let you know if you omit the `else` on accident ...

Except that most C# developers do

  int bar = 0; // or some other default value`

to get the red squiggly to go away while they type the rest of the code, unknowingly subverting the compiler's safety check.

This doesn't seem like a big deal given these examples. But it becomes a much bigger deal when the if/else grows super large, becomes nested, etc.

Unions remain the killer F# feature missing from C#.

Also, basic object initialization in C# has turned into a nightmare with recent versions. You need a flowchart to select among the 18 syntax options which suite your current needs.

With F# (and other newer languages), record fields are either `T` or `T option`. No need to worry about whether the value needs to be computed in a constructor and then remain immutable, whether it needs to be initialized by an object initializer and/or a constructor or not, whether it needs to remain interior-ly mutable throughout the life of the record, and so on. (Although as I recall you do still need to consider null values assigned to non-nullable references in your F# code that consumes C#.)

I am hard-pressed to think of a context in which .clone() is better-suited than in business apps.

Notwithstanding the other comments about the effect GDP per capita might or might not have on individuals, how much of this GDP difference is driven by the strength or weakness of consumer protections within a given economy?

Is higher GDP per capita truly a strong argument against consumer protections?

"Where there's a will, there's a way."

Might not be HN-worthy conversation, but I often reflect on how funny this piece of satire is: https://clickhole.com/i-know-this-sounds-like-spam-but-i-rea...

He wants to defund U.S. support for Ukraine, but isn't can't directly own his decision like an adult, and so has to stage this baloney conflict of a press conference.

Just mentioned to an acquaintance a couple of days ago that Entity Framework is the biggest flip-flop of my personal career. I was a _rabid_ supporter when it was released a decade and a half or so ago, and the appeal has decreased linearly over time, to the present day.

Statically-typed queries written in a mini-DSL within your application language seems like such a joy!

But then the configuration is a hassle. The DbContext lifecycles are a hassle. The DbContext winds up a big ball of mutable state that often gets passed all up and down your call stack, reducing the ability to reason about much of the code locally. Was this instance initialized with or without change tracking? How many and what changes have been applied? Were these navigation properties lazily or eagerly loaded?

And it promises to keep your domain persistence ignorant with its fluent configuration syntax. But then you have compromise on that here, then compromise in it there.

Pretty soon, you realize that you started out building a project for domain X or domain Y, only to realize that you're trying to shoehorn domain X/Y behavior into your Entity Framework app.

I suspect that the place these removals came from was the desire to dictate other's behavior and/or to feel more enlightened than you, masquerading as protecting from hurt or offense, which is not really a very good place.

“Sign up for a free trial to see the rest of the job match results!”

-alate, -ster, etc. :-)

Also importantly, it’s now quite good-looking, too.

No doubt it’s harder to write structured code and assertions against a string stacktrace, but as a human reading it, the information is immensely valuable.

There’s also (in C#) init, readonly, required, and quite a few more keywords and techniques, governing property mutability, private class field mutability, and so on.

And then none of those techniques work as well as manually typing out a required constructor which hard-enforces that required data be priced upon object initialization.

I understand required vs optional immediately a la Rust and F# (ignoring for a moment F#’s null awareness) but as a 17 year C# dev, I’ve had to create an initialization chart to keep straight all of the C# techniques.

I’d be eager to hear folks poke holes in this opinion, but it seems like C# has made a wild mess of class/record initialization in recent versions, whereas in Rust fields are either simply required or are optional.