> That just isn't true
Generational ZGC is free for everyone to use.
713 karma · joined April 26, 2021
> That just isn't true
Generational ZGC is free for everyone to use.
AFAIK, in the current implementation, Java's virtual threads yields only when they block (cooperative). But the spec allows a JVM to implement them as preemptive.
Then they added structured concurrency, which roughly solves the same problem as Go's context, arguably more elegantly.
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.
https://en.wikipedia.org/wiki/Committee_to_End_Pay_Toilets_i...
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.
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.
I've also complained about that a while ago https://news.ycombinator.com/item?id=35707689
---
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) } // ScalaIn 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.
https://discuss.ocaml.org/t/reason-general-function-syntax-d...
I think Java (or other JVM languages) are then best positioned, because of jooq. Still the best SQL generation library I've used.
I use ShiftIt (a lovely project, but dead) reimplemented in Hammerspoon. It is very comprehensive.
In this case some slop is hacked and exposed. I check them out to see if they're good yet. The quality of the slop is unrelated to whether they'd get hacked.
This reminds me of some youtube videos when I was researching some stuff to buy. Those videos are just still images plus text-to-speech narration, usually with an annoying background music.
> some core developers (who are compiler developers by trade) are actually experimenting with and using these same tools too, but haven't suddenly turned into 13kLoC PR-opening AI superheroes.
>> Here's my question: why did the files that you submitted name Mark Shinwell as the author?
> Beats me. AI decided to do so and I didn't question it.
Indeed, and they won't buy the knife at this price anyway. My point is that not being dishwasher-safe does not matter for ~everyone. If they care, they won't do it; if they don't, they won't buy it.
They can manufacture 80 GWh a year. To get through dunkelflaute with moderate renewable percentage we need tens of TWh. Not to belittle Tesla, but that's 3 orders of magnitude difference.
Are you changing your mind or can you give me numbers to change mine?
Since you're in the industry, maybe you can answer this question and change my mind.
> has resulted in big changes
The change was allowing market forces to align incentives.
That is very plausible, I really want it to be true as a fan of IntelliJ and Kotlin. I used Cursor at work and tried out Junie on a hobby project. Maybe it's the different niche, maybe I'm more used to Cursor for chat bot workflows, but I got a personal Cursor license after trying out Junie.
`val point: Bound.shape = Shape.Point` type-checks, because `type shape = S.shape`. To drive the point home, so does
val DoesNotReturnPoint : Shape.shape -> Bound.shape = fn x => x
So the module example does not show "this function won't return a point" as one would have hoped.