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.

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

Prescriptivism is mostly just an unprincipled mishmash of shibboleths someone pulled out of their rear end hundreds of years ago, classism, and knee-jerk reactions against language change.

For example - why do people distinguish less vs fewer to refer to countable vs uncountable nouns? Because someone wrote in 1770 that they thought that distinction was elegant, despite not actually reflecting the way English at the time was spoken.

Why is ain't "not a word"? Because it originated in the speech of poor people, and was used less commonly by rich people. People roll their eyes at new business-speak because it comes from rich, powerful people, but look down their nose at language innovations from poor hillbillies and other disfavored groups.

And you can find writings from old prescriptivists complaining about literally every change in the language, such as hating the new ambigious use of singular 'you' when 'thou' was perfectly good and unambiguous or hating phrases like 'very pleased'.

Reddit very much depends on the subreddits you subscribe to.

Browsing /r/askhistorians or /r/programming isn't really the same experience as r/memes or whatever. Not logging in to reddit makes it way worse since you only see the popular low-effort threads instead of better niche content.

If you knead bread by hand, it'll have some human DNA in it from e.g your skin cells. It's almost impossible to cook or process food while preventing it from getting literally any human cells into it, because humans are shedding cells and DNA literally all the time. You can wear gloves, hairnets, and frequently mop up, but eliminating the problem entirely is hard.

Both a vegetarian burger and a beef burger are probably going to have more human DNA in it than either a steak or a pot of black beans would.

Pigs and chickens don't eat air, you know.

70% of US soy becomes animal feed. Some of the rest is used industrially, or becomes biodisel. Relatively little US soy becomes soy sauce, tofu, etc.

Soy subsidies, in practice, mostly function as a chicken and pork subsidy.

You'll notice that we heavily subsidize animal feed crops like corn and soy, and spend much less money subsidizing fruits and veggies, nuts, and other legumes like black beans or lentils.

No.

Honey bees are dying because of parasites and pests, pathogens, poor nutrition, and sublethal exposure to pesticides.

It's not just one thing. Most of those things on their own won't even kill them. For example, Varroa mites will kill an already weakened hive, but not a healthy one.

Lawns absolutely contribute to poor nutrition, due to habitat loss. Same with all the mowed grass we have everywhere in suburbia. Monocropped agriculture does as well, because bees do best with a variety of flowers.

I've let the back part of my property grow wild the past couple years, and it's currently filled with a ton of goldenrod, chicory, and a bunch of other random flowers. You would not beleive the number of honeybees I've seen back there at once, or how loud the buzz was.

Similarly, there's a reason I see a ton of fireflys in my yard, but I see almost none in my neighbors yards. It's because they're well- manicured green wastelands

But I guess non-action and bootlicking while we wait for our thoroughly bribed politicians to do nothing is better.

Nation-wide action, of course, is best. Something like the green new deal or even a market-based solution like cap-and-trade or a carbon tax.

On a local level, though, there’s a lot of action that can be done.

Nation-wide, the biggest category of carbon emissions is transportation, at 28% of all emissions. Over half of all transportation-related emissions are from cars and trucks.

The amount people drive is closely tied to local urban design, which comes down largely to local zoning regulations and infrastructure design. Those are primarily impacted by the people who show up at town meetings and vote.

Advocate for walkable, mixed-use zoning, improved bike infrastructure, etc. Most people aren’t “drivers”, “cyclists” or “public transit riders”, they’re people who want to get from point A to point B as easily as possible and will take whatever is best.

The problem with gas stations isn’t their LCD screens.

A large number of gas stations are franchises. Breaking the LCD screens hurts the local franchise owner, not whichever fossil fuel company they’re working with.

More to the point, breaking LCD screens accomplishes absolutely nothing. Most people don’t drive because they love driving, they drive because of zoning, sprawl and a lack of reasonable alternatives. If you get rid of fossil fuel infrastructure without fixing the underlying car dependency, they’ll be stuck at home.

Being a much better language than Java isn’t exactly a high bar.

Efficiency in economics has a particular technical definition.

Pareto efficiency or Pareto optimality is a situation where no action or allocation is available that makes one individual better off without making another worse off

Free markets are great at producing outcomes that are efficient in a particular technical sense, but not especially equitable.

What kind of runtime tag corresponds to generics, exactly?

Python handles generics essentially the same way that Java 1.0 handles generics: it just kinda punts on it. In Java 1.0, list is a heterogenous collection of Objects. Object, in Java 1.0, allows you to write polymorphic code. But it’s not really the same sort of thing; that’s why they added generics.

It’s compile-time that has limitations on what it can do, runtime has none.

Ish.

There’s typing a la Curry, where semantics don’t depend on static types and typing a la Church, where semantics can depend on static types.

Haskell’s typeclasses, Scala’s implicits and Rust’s traits are a great example of something that inherently requires Church style typing.

One of the nice things typeclasses let you do is to write functions that are polymorphic on the return type, and the language will automagically pick the right one based on type inference. For example, in Haskell, the result of the expression fromInteger 1 depends on type ascribed to it. Use it somewhere that expects a double? It’ll generate a double. Use it somewhere you expect a complex number? You’ll get a complex number. Use it somewhere you’re using an automatic differentiation library? You’ll get whatever type that AD library defined.

That’s fundamentally not something you can do in python. You have to go with the manual implementation passing approach, which is incredibly painful so people do it very sparingly.

More to the point, though, limitations have both costs and befits. There’s a reason python doesn’t have goto and that strings are immutable, even though those are limitations. The question is always if the costs outweigh the benefits or not.

Bob Harper uses ‘unityped’ in his post about how dynamic typing is a static type system with a single type in disguise. I’ve literally never heard “monotyped” used as a term in a dynamic context.

In Types and Programming Languages, Ben Pierce says “Terms like ‘dynamically typed’ are arguably misnomers and should probably be replaced by ‘dynamically checked’, but the usage is standard”. Generally, you’ll see ‘tag’ used by type theorists to distinguish what dynamic languages are doing from what a static language considers a type.

Type systems have existed as a field in math for over a century and predate programming languages by decades. They do a slightly different sort of thing vs dynamic checking, and many type system features like generics or algebraic data types make sense in a static context but not in a dynamic one.

Basic stuff like maps aren’t easy to implement either.

This is mostly due to a preference for immutable data structures. That said, the standard library has a balanced tree-based map that’s not too complex.

If you want a good immutable data structure with O(1) find and update, you’re unfortunately looking at something like a hash array mapped trie, but that’s the same in e.g. clojure or Scala.

Haskell started out as an academic language.

The problem Haskell was trying to solve was that in the late 80s, there was a bunch of interest in lazy functional programming but all the research groups had to write their own lazy language before writing a paper on whatever new feature they were interested in. So they banded together to create Haskell as a common research program that they could collectively use.

It’s been remarkably successful for a research language, and has become more practical over the years in many ways. But it’s always had the motto “avoid (success at all costs)”.

There’s a bunch of companies that use Haskell.

Off the top of my head, Mercury is an online bank built on Haskell, Tsuru capitol is a hedge fund built on it, Standard Chartered bank has a big Haskell team in Singapore, and Facebook’s automated rule-based spam detection software is built in Haskell.

There’s also cardano, in the crypto space.

And various other companies might have a project or two written in Haskell by a small team.

Isn’t the whole point of dynamic languages that they’re monotyped? They’re equivalent to a type system with only one type, any. Really, most dynamic languages are equivalent to having a single tagged union of all the different sorts of values in the language.

If you add additional types, you get into gradual type systems.

From his blog post:

While you may compile dialects into it, you still have to accept the fact that running code in the browser means running JavaScript. So being able to write that, free of any tooling, and free of any strong typing, is a blessing under the circumstances.

By his logic, JS linters are bad because they’re tooling that restricts your access to all of Javascript. But linters mean you don’t have to read PRs with a fine tooth comb to make sure there’s no footguns like using == instead of ===.

Also, you could use that same logic to advocate for writing JVM bytecode directly instead of Java/Kotlin/Scala/Clojure/etc.

The question is really whether tooling pays its way in terms of lower bug rates, code that’s easier for coworkers to read, and code that’s easier to reason about.

There’s assorted companies that sell parasitic wasps as pest control.

Spalding sells theirs as “fly predators”; they basically look like tiny gnats but lay their eggs in fly pupa. They work great.