You are of course right about what the word "commons" refers to. Still, I want to quibble.
Maybe the definition covers both, but I still think it's worth distinguishing between incentives creating a bad equilibrium and simply antisocial behaviours. When I hear "tragedy of the commons", I think of the former.
> stuck to why he thought it was bad for Bun to do this
Quite the opposite. "When Jarred announced the Rust rewrite, we were ecstatic."
> It’s definitionally an ad hominem against Jared.
Who Jarred is, as a CEO, definitely has an impact on how the company develops software - how Zig is used. And the argument is that Zig is used badly in Bun. Without that context, I, as a reader, would have to actually read through a lot of code to be convinced of that point.
> This feature does have some limitations, for instance when we have multiple nested function calls, but in those cases an explicit lambda expression is always still possible.
The solution is to delimit the level of expression the underscore (or dollar sign suggested in the article) belongs to. In Kotlin they use braces and `it`.
{ add(it, 3) } // Kotiln
add(_, 3) // Scala
Then modifying the "hole in the expression" is easy. Suppose we want to subtract the first argument by 2 before passing that to `add`:
{ add(subtract(it, 2), 3) } // Kotlin
// add(subtract(_, 2), 3) // no, this means adding 3 to the function `add(subtract(_, 2)`
x => { add(subtract(x, 2), 3) } // Scala
I don't mind adopting features from popular languages. (After all, Virgil using _ for partial application turned out to be a happy accident that aligned with Scala.) Adopting features that are popping up in other languages helps to reduce the explanation burden, but I'm not sure on this one. It took me about 10 years to finally settle on having `fun` as a keyword to introduce lambdas instead of the parser back-tracking madness that JS parsers do.
In that case I want the signature of "this function pre-computes, then returns another function" and "this function takes two arguments" to be different, to show intent.
> achieved through compiler optimisation
Haskell is different in that its evaluation ordering allows this. But in strict evaluation languages, this is much harder, or even forbidden by language semantics.
Here's what Yaron Minsky (an OCaml guy) has to say:
> starting from scratch, I’d avoid partial application as the default way of building multi-argument functions.
Jooq with Kotlin for a back-end has been the best of both worlds for me.
Much cleaner, shorter code and type safety with Postgres (my schema tends to be highly normalized too). And these days I’ve got it well integrated with Zod for type safe JS/TS front-ends as well.
I worked on a purely functional Scala codebase (Cats). I joined after the original authors were gone.
Some new comers were not fluent in it after ~a year.
reply