If that’s something that regularly happens in the US, do you have any examples from the last decade, instead of three examples from 55-60 years ago?

Yeah, there’s a pretty big difference between a lawn in Vermont or Ohio, and one in Nevada or southern California.

Grass really, really depends on location and climate. I literally never water or fertilize my lawn; it looks fine.

The worse thing here is ecological. I keep my mower set to 4", and keep my lawn a bit longer than my neighbors. I see a ton of fire flies in my yard in the summer, and see a fraction as many in my neighbors yard.

Short lawns are terrible habitat, which makes them good for sports or a children’s play area. But 80% of my neighbor’s lawn is just aesthetic, which is something I really don’t get. Lawns are about as visually exciting as a beige wall. They’re a waste of space.

Fair. I should have said that many legless lizards aren’t snakes.

Not in the right clade, basically.

They look similar, but aren’t directly related. It’s similar to why legless lizards aren’t snakes, and bats aren’t birds.

Dinosaurs are currently defined as anything that descends from the most recent common ancestor of triceratops and the pigeon.

Which, as others pointed out is mostly due to dinosaurs being originally defined before we found the first pterodactyl.

If you want to refer to dinosaurs and pterodactyls, you could use avemetatarsalians (anything more closely related to birds than crocs) or ornithodirans (dinosaurs + pterosauromorphs).

Also fun is that there’s a number of crocodillians that look suspiciously dinosaur- like, like Shuvosaurus. Convergent evolution is wild.

They particularly look like diffraction spikes/starbursts.

Astigmatism, cataracts, glaucoma or smudged glasses can cause you to see starbursts when you look at bright lights at night.

Yeah. Power plants are nowhere near 90% efficient.

It’s worth emphasizing, though, that they’re still way, way more efficient than car engines are.

Also, regenerative breaking saves a lot of energy. Basically, instead of using the motor to increase the cars speed, you use it as a generator to recharge the battery.

I assume his point is that calling Manchin or Sinema “liberal” isn’t super accurate.

And memory bugs are only a subset of bugs that can be exploited in a program. Pretending Rust means no more exploitation is stupid.

This is facile.

According to Microsoft, about 70% of security bugs they see are memory safety issues.

Yes: if you introduce memory safety, there’s still those 30% of security bugs left. But, well, I’d rather worry about 30% of issues than 100%…

Similarly, I use libraries that eliminate SQL injections unless you really go out of your way.

Emacs is a bunch older than common lisp.

One of its more idiosyncratic design decisions was using dynamic scope, rather than lexical scope. They did add in per-file lexical scope, though.

It also just doesn’t implement a lot of common lisp’s standard library.

Although it’s been used for a fairly wide array of algorithms for decades. Everything from alpha-beta tree search to k-nearest-neighbors to decision forests to neural nets are considered AI.

Edit: The paper is called

Avoiding fusion plasma tearing instability with deep reinforcement learning

Reinforcement learning and deep neural nets are buzzwordy these days, but neural nets have been an AI thing for decades and decades.

Emacs unfortunately uses Emacs lisp, not common lisp or scheme.

Symbols display with friendly string-y names in a number of languages. Clojure, for example, has a symbol type.

And a number of languages display friendly strings for enumy things - Scala, Haskell, and Rust spring to mind.

The problem with strings over enums with a nice debugging display is that the string type is too wide. Strings don’t tell you what values are valid, strings don’t catch typos at compile time, and they’re murder when refactoring.

Clojure symbols are good at differentiation between symbolly things and strings, though they don’t catch typos.

The other problem the article mentions is strings over a proper struct/adt/class hierarchy is that strings don’t really have any structure to them. Concatenating strings is brittle compared to building up an AST then rendering it at the end.

Edit: autocorrect messed a few things up I didn’t catch.

Suppose one year you spend $60k, but only earned $50k. You lost $10k.

The next year, you spend $57k, and earned $53k. You lost $4k, and your losses narrowed by $6k.

Disney+ lost 1.3 million subscribers in the final quarter of 2023 amid a hefty price hike that went into effect last fall, but managed to narrow its streaming business’ losses by $300 million during the October-December period.

That doesn’t really sound like it backfired to me. They lost subscribers but made more money.

It’s not that there’s anything unnatural about water. It’s just not a remedy for anything but dehydration.

Javascript is generally considered OOP, but classes weren’t widely available till 2017.

Inheritance isn’t fundamental to OOP, and neither are interfaces. You can have a duck- typed OOP language without inheritance, although I don’t know of any off the top of my head.

Honestly, the more fundamental thing about OOP is that it’s a programming style built around objects. Sometimes OO languages are class based, or duck typing based, etc. But you’ll always have your data carrying around it’s behavior at runtime.

keeping state (data) and behavior (functions) that operate on that state, together

Importantly, that’s “together at runtime”, not in terms of code organization. One of the important things about an object is that it has dynamic dispatch. Your object is a pointer both to the data itself and to the implementation that works on that data.

There’s a similar idea that’s a bit different that you see in Haskell, Scala, and Rust - what Haskell calls type classes. Rust gives it a veneer of OO syntax, but the semantics themselves are interestingly different.

In particular, the key of type classes is keeping data and behavior separate. The language itself is responsible for automagically passing in the behavior.

So in Scala, you could do something like

def sum[A](values: List[A])(implicit numDict: Num[A]) = values.fold(numDict.+)(numDict.zero)

Or

def sum[A: Num](values: List[A]) = values.fold(_ + _)(zero)

Given a Num typeclass that encapsulates numeric operations. There’s a few important differences:

1. All of the items of that list have to be the same type of number - they’re all Ints or all Doubles or something

2. It’s a list of primitive numbers and the implementation is kept separate - no need for boxing and unboxing.

3. Even if that list is empty, you still have access to the implementation, so you can return a type-appropriate zero value

4. Generic types can conditionally implement a typeclass. For example, you can make an Eq instance for List[A] if A has an Eq instance. So you can compare List[Int] for equality, but not List[Int => Int].

Yeah, projects also exist in the real world and practical considerations matter.

The legacy C/C++ code base might slowly and strategically have components refactored into rust, or you might leave it.

The C/C++ team might be interested in trying Rust, but have to code urgent projects in C/C++.

In the same way that if you have a perfectly good felling axe and someone just invented the chain saw, you’re better off felling that tree with your axe than going into town, buying a chainsaw and figuring out how to use it. The axe isn’t really the right tool for the job anymore, but it still works.